mojo/public/cpp/bindings/tests/validation_test_input_parser.cc

   1 // Copyright 2014 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 "mojo/public/cpp/bindings/tests/validation_test_input_parser.h"
   6
   7 #include <assert.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10
  11 #include <limits>
  12 #include <map>
  13 #include <set>
  14 #include <utility>
  15
  16 #include "mojo/public/c/system/macros.h"
  17
  18 namespace mojo {
  19 namespace test {
  20 namespace {
  21
  22 class ValidationTestInputParser {
  23  public:
  24   ValidationTestInputParser(const std::string& input,
  25                             std::vector<uint8_t>* data,
  26                             size_t* num_handles,
  27                             std::string* error_message);
  28   ~ValidationTestInputParser();
  29
  30   bool Run();
  31
  32  private:
  33   struct DataType;
  34
  35   typedef std::pair<const char*, const char*> Range;
  36
  37   typedef bool (ValidationTestInputParser::*ParseDataFunc)(
  38       const DataType& type, const std::string& value_string);
  39
  40   struct DataType {
  41     const char* name;
  42     size_t name_size;
  43     size_t data_size;
  44     ParseDataFunc parse_data_func;
  45   };
  46
  47   // A dist4/8 item that hasn't been matched with an anchr item.
  48   struct PendingDistanceItem {
  49     // Where this data item is located in |data_|.
  50     size_t pos;
  51     // Either 4 or 8 (bytes).
  52     size_t data_size;
  53   };
  54
  55   bool GetNextItem(Range* range);
  56
  57   bool ParseItem(const Range& range);
  58
  59   bool ParseUnsignedInteger(const DataType& type,
  60                             const std::string& value_string);
  61   bool ParseSignedInteger(const DataType& type,
  62                           const std::string& value_string);
  63   bool ParseFloat(const DataType& type, const std::string& value_string);
  64   bool ParseDouble(const DataType& type, const std::string& value_string);
  65   bool ParseBinarySequence(const DataType& type,
  66                            const std::string& value_string);
  67   bool ParseDistance(const DataType& type, const std::string& value_string);
  68   bool ParseAnchor(const DataType& type, const std::string& value_string);
  69   bool ParseHandles(const DataType& type, const std::string& value_string);
  70
  71   bool StartsWith(const Range& range, const char* prefix, size_t prefix_length);
  72
  73   bool ConvertToUnsignedInteger(const std::string& value_string,
  74                                 unsigned long long int* value);
  75
  76   template <typename T>
  77   void AppendData(T data) {
  78     size_t pos = data_->size();
  79     data_->resize(pos + sizeof(T));
  80     memcpy(&(*data_)[pos], &data, sizeof(T));
  81   }
  82
  83   template <typename TargetType, typename InputType>
  84   bool ConvertAndAppendData(InputType value) {
  85     if (value > std::numeric_limits<TargetType>::max() ||
  86         value < std::numeric_limits<TargetType>::min()) {
  87       return false;
  88     }
  89     AppendData(static_cast<TargetType>(value));
  90     return true;
  91   }
  92
  93   template <typename TargetType, typename InputType>
  94   bool ConvertAndFillData(size_t pos, InputType value) {
  95     if (value > std::numeric_limits<TargetType>::max() ||
  96         value < std::numeric_limits<TargetType>::min()) {
  97       return false;
  98     }
  99     TargetType target_value = static_cast<TargetType>(value);
 100     assert(pos + sizeof(TargetType) <= data_->size());
 101     memcpy(&(*data_)[pos], &target_value, sizeof(TargetType));
 102     return true;
 103   }
 104
 105   static const DataType kDataTypes[];
 106   static const size_t kDataTypeCount;
 107
 108   const std::string& input_;
 109   size_t input_cursor_;
 110
 111   std::vector<uint8_t>* data_;
 112   size_t* num_handles_;
 113   std::string* error_message_;
 114
 115   std::map<std::string, PendingDistanceItem> pending_distance_items_;
 116   std::set<std::string> anchors_;
 117 };
 118
 119 #define DATA_TYPE(name, data_size, parse_data_func) \
 120     {name, sizeof(name) - 1, data_size, parse_data_func}
 121
 122 const ValidationTestInputParser::DataType
 123     ValidationTestInputParser::kDataTypes[] = {
 124   DATA_TYPE("[u1]", 1, &ValidationTestInputParser::ParseUnsignedInteger),
 125   DATA_TYPE("[u2]", 2, &ValidationTestInputParser::ParseUnsignedInteger),
 126   DATA_TYPE("[u4]", 4, &ValidationTestInputParser::ParseUnsignedInteger),
 127   DATA_TYPE("[u8]", 8, &ValidationTestInputParser::ParseUnsignedInteger),
 128   DATA_TYPE("[s1]", 1, &ValidationTestInputParser::ParseSignedInteger),
 129   DATA_TYPE("[s2]", 2, &ValidationTestInputParser::ParseSignedInteger),
 130   DATA_TYPE("[s4]", 4, &ValidationTestInputParser::ParseSignedInteger),
 131   DATA_TYPE("[s8]", 8, &ValidationTestInputParser::ParseSignedInteger),
 132   DATA_TYPE("[b]", 1, &ValidationTestInputParser::ParseBinarySequence),
 133   DATA_TYPE("[f]", 4, &ValidationTestInputParser::ParseFloat),
 134   DATA_TYPE("[d]", 8, &ValidationTestInputParser::ParseDouble),
 135   DATA_TYPE("[dist4]", 4, &ValidationTestInputParser::ParseDistance),
 136   DATA_TYPE("[dist8]", 8, &ValidationTestInputParser::ParseDistance),
 137   DATA_TYPE("[anchr]", 0, &ValidationTestInputParser::ParseAnchor),
 138   DATA_TYPE("[handles]", 0, &ValidationTestInputParser::ParseHandles)
 139 };
 140
 141 const size_t ValidationTestInputParser::kDataTypeCount =
 142     sizeof(ValidationTestInputParser::kDataTypes) /
 143     sizeof(ValidationTestInputParser::kDataTypes[0]);
 144
 145 ValidationTestInputParser::ValidationTestInputParser(
 146     const std::string& input,
 147     std::vector<uint8_t>* data,
 148     size_t* num_handles,
 149     std::string* error_message)
 150     : input_(input),
 151       input_cursor_(0),
 152       data_(data),
 153       num_handles_(num_handles),
 154       error_message_(error_message) {
 155   assert(data_);
 156   assert(num_handles_);
 157   assert(error_message_);
 158   data_->clear();
 159   *num_handles_ = 0;
 160   error_message_->clear();
 161 }
 162
 163 ValidationTestInputParser::~ValidationTestInputParser() {
 164 }
 165
 166 bool ValidationTestInputParser::Run() {
 167   Range range;
 168   bool result = true;
 169   while (result && GetNextItem(&range))
 170     result = ParseItem(range);
 171
 172   if (!result) {
 173     *error_message_ = "Error occurred when parsing " +
 174         std::string(range.first, range.second);
 175   } else if (!pending_distance_items_.empty()) {
 176     // We have parsed all the contents in |input_| successfully, but there are
 177     // unmatched dist4/8 items.
 178     *error_message_ = "Error occurred when matching [dist4/8] and [anchr].";
 179     result = false;
 180   }
 181   if (!result) {
 182     data_->clear();
 183     *num_handles_ = 0;
 184   } else {
 185     assert(error_message_->empty());
 186   }
 187
 188   return result;
 189 }
 190
 191 bool ValidationTestInputParser::GetNextItem(Range* range) {
 192   const char kWhitespaceChars[] = " \t\n\r";
 193   const char kItemDelimiters[] = " \t\n\r/";
 194   const char kEndOfLineChars[] = "\n\r";
 195   while (true) {
 196     // Skip leading whitespaces.
 197     // If there are no non-whitespace characters left, |input_cursor_| will be
 198     // set to std::npos.
 199     input_cursor_ = input_.find_first_not_of(kWhitespaceChars, input_cursor_);
 200
 201     if (input_cursor_ >= input_.size())
 202       return false;
 203
 204     if (StartsWith(Range(&input_[0] + input_cursor_,
 205                          &input_[0] + input_.size()),
 206                    "//", 2)) {
 207       // Skip contents until the end of the line.
 208       input_cursor_ = input_.find_first_of(kEndOfLineChars, input_cursor_);
 209     } else {
 210       range->first = &input_[0] + input_cursor_;
 211       input_cursor_ = input_.find_first_of(kItemDelimiters, input_cursor_);
 212       range->second = input_cursor_ >= input_.size() ?
 213           &input_[0] + input_.size() : &input_[0] + input_cursor_;
 214       return true;
 215     }
 216   }
 217   return false;
 218 }
 219
 220 bool ValidationTestInputParser::ParseItem(const Range& range) {
 221   for (size_t i = 0; i < kDataTypeCount; ++i) {
 222     if (StartsWith(range, kDataTypes[i].name, kDataTypes[i].name_size)) {
 223       return (this->*kDataTypes[i].parse_data_func)(
 224           kDataTypes[i],
 225           std::string(range.first + kDataTypes[i].name_size, range.second));
 226     }
 227   }
 228
 229   // "[u1]" is optional.
 230   return ParseUnsignedInteger(kDataTypes[0],
 231                               std::string(range.first, range.second));
 232 }
 233
 234 bool ValidationTestInputParser::ParseUnsignedInteger(
 235     const DataType& type, const std::string& value_string) {
 236   unsigned long long int value;
 237   if (!ConvertToUnsignedInteger(value_string, &value))
 238     return false;
 239
 240   switch (type.data_size) {
 241     case 1:
 242       return ConvertAndAppendData<uint8_t>(value);
 243     case 2:
 244       return ConvertAndAppendData<uint16_t>(value);
 245     case 4:
 246       return ConvertAndAppendData<uint32_t>(value);
 247     case 8:
 248       return ConvertAndAppendData<uint64_t>(value);
 249     default:
 250       assert(false);
 251       return false;
 252   }
 253 }
 254
 255 bool ValidationTestInputParser::ParseSignedInteger(
 256     const DataType& type, const std::string& value_string) {
 257   long long int value;
 258   if (sscanf(value_string.c_str(), "%lli", &value) != 1)
 259     return false;
 260
 261   switch (type.data_size) {
 262     case 1:
 263       return ConvertAndAppendData<int8_t>(value);
 264     case 2:
 265       return ConvertAndAppendData<int16_t>(value);
 266     case 4:
 267       return ConvertAndAppendData<int32_t>(value);
 268     case 8:
 269       return ConvertAndAppendData<int64_t>(value);
 270     default:
 271       assert(false);
 272       return false;
 273   }
 274 }
 275
 276 bool ValidationTestInputParser::ParseFloat(
 277     const DataType& type, const std::string& value_string) {
 278   MOJO_COMPILE_ASSERT(sizeof(float) == 4, float_size_is_not_4);
 279
 280   float value;
 281   if (sscanf(value_string.c_str(), "%f", &value) != 1)
 282     return false;
 283
 284   AppendData(value);
 285   return true;
 286 }
 287
 288 bool ValidationTestInputParser::ParseDouble(const DataType& type,
 289                                             const std::string& value_string) {
 290   MOJO_COMPILE_ASSERT(sizeof(double) == 8, double_size_is_not_8);
 291
 292   double value;
 293   if (sscanf(value_string.c_str(), "%lf", &value) != 1)
 294     return false;
 295
 296   AppendData(value);
 297   return true;
 298 }
 299
 300 bool ValidationTestInputParser::ParseBinarySequence(
 301     const DataType& type, const std::string& value_string) {
 302   if (value_string.size() != 8)
 303     return false;
 304
 305   uint8_t value = 0;
 306   for (std::string::const_iterator iter = value_string.begin();
 307        iter != value_string.end();
 308        ++iter) {
 309     value <<= 1;
 310     if (*iter == '1')
 311       value++;
 312     else if (*iter != '0')
 313       return false;
 314   }
 315   AppendData(value);
 316   return true;
 317 }
 318
 319 bool ValidationTestInputParser::ParseDistance(const DataType& type,
 320                                               const std::string& value_string) {
 321   if (pending_distance_items_.find(value_string) !=
 322       pending_distance_items_.end())
 323     return false;
 324
 325   PendingDistanceItem item = {data_->size(), type.data_size};
 326   data_->resize(data_->size() + type.data_size);
 327   pending_distance_items_[value_string] = item;
 328
 329   return true;
 330 }
 331
 332 bool ValidationTestInputParser::ParseAnchor(const DataType& type,
 333                                             const std::string& value_string) {
 334   if (anchors_.find(value_string) != anchors_.end())
 335     return false;
 336   anchors_.insert(value_string);
 337
 338   std::map<std::string, PendingDistanceItem>::iterator iter =
 339       pending_distance_items_.find(value_string);
 340   if (iter == pending_distance_items_.end())
 341     return false;
 342
 343   PendingDistanceItem dist_item = iter->second;
 344   pending_distance_items_.erase(iter);
 345
 346   size_t distance = data_->size() - dist_item.pos;
 347   switch (dist_item.data_size) {
 348     case 4:
 349       return ConvertAndFillData<uint32_t>(dist_item.pos, distance);
 350     case 8:
 351       return ConvertAndFillData<uint64_t>(dist_item.pos, distance);
 352     default:
 353       assert(false);
 354       return false;
 355   }
 356 }
 357
 358 bool ValidationTestInputParser::ParseHandles(const DataType& type,
 359                                              const std::string& value_string) {
 360   // It should be the first item.
 361   if (!data_->empty())
 362     return false;
 363
 364   unsigned long long int value;
 365   if (!ConvertToUnsignedInteger(value_string, &value))
 366     return false;
 367
 368   if (value > std::numeric_limits<size_t>::max())
 369     return false;
 370
 371   *num_handles_ = static_cast<size_t>(value);
 372   return true;
 373 }
 374
 375 bool ValidationTestInputParser::StartsWith(const Range& range,
 376                                            const char* prefix,
 377                                            size_t prefix_length) {
 378   if (static_cast<size_t>(range.second - range.first) < prefix_length)
 379     return false;
 380
 381   return memcmp(range.first, prefix, prefix_length) == 0;
 382 }
 383
 384 bool ValidationTestInputParser::ConvertToUnsignedInteger(
 385     const std::string& value_string,
 386     unsigned long long int* value) {
 387   const char* format = NULL;
 388   if (value_string.find_first_of("xX") != std::string::npos)
 389     format = "%llx";
 390   else
 391     format = "%llu";
 392   return sscanf(value_string.c_str(), format, value) == 1;
 393 }
 394
 395 }  // namespace
 396
 397 bool ParseValidationTestInput(const std::string& input,
 398                               std::vector<uint8_t>* data,
 399                               size_t* num_handles,
 400                               std::string* error_message) {
 401   ValidationTestInputParser parser(input, data, num_handles, error_message);
 402   return parser.Run();
 403 }
 404
 405 }  // namespace test
 406 }  // namespace mojo