LLVMFuzzerTestOneInput:
   62|  2.44k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   63|  2.44k|  if (Size < 1 || Size > kMaxInputLength) {
  ------------------
  |  |   17|  2.44k|#define kMaxInputLength 65536
  ------------------
  |  Branch (63:7): [True: 0, False: 2.44k]
  |  Branch (63:19): [True: 7, False: 2.44k]
  ------------------
   64|      7|    return 0;
   65|      7|  }
   66|       |
   67|  2.44k|  const uint8_t selector = Data[0];
   68|  2.44k|  const char *body = reinterpret_cast<const char *>(Data + 1);
   69|  2.44k|  const size_t bodyLen = Size - 1;
   70|       |
   71|  2.44k|  FuzzRequest request;
   72|  2.44k|  request.in_.write(body, bodyLen);
   73|  2.44k|  request.contentLength_ = static_cast<int64_t>(bodyLen);
   74|       |
   75|  2.44k|  if ((selector & 1) == 0) {
  ------------------
  |  Branch (75:7): [True: 1.17k, False: 1.26k]
  ------------------
   76|  1.17k|    request.contentType_ = "multipart/form-data; boundary=AaB03x";
   77|  1.26k|  } else {
   78|  1.26k|    request.contentType_ = "application/x-www-form-urlencoded";
   79|  1.26k|  }
   80|       |
   81|  2.44k|  try {
   82|  2.44k|    Wt::CgiParser parser(/*maxRequestSize=*/1 << 20, /*maxFormData=*/1 << 20);
   83|  2.44k|    parser.parse(request, Wt::CgiParser::ReadDefault);
   84|  2.44k|  } catch (...) {
   85|  1.16k|  }
   86|       |
   87|  2.44k|  return 0;
   88|  2.44k|}
_ZN11FuzzRequest2inEv:
   26|  5.41k|  std::istream &in() override { return in_; }
_ZNK11FuzzRequest13requestMethodEv:
   42|  2.44k|  const char *requestMethod() const override { return requestMethod_.c_str(); }
_ZNK11FuzzRequest11queryStringB5cxx11Ev:
   43|  2.44k|  const std::string &queryString() const override { return s_; }
_ZNK11FuzzRequest11contentTypeEv:
   33|  2.44k|  const char *contentType() const override { return contentType_.c_str(); }
_ZNK11FuzzRequest13contentLengthEv:
   35|  2.44k|  int64_t contentLength() const override { return contentLength_; }

_ZN2Wt4Http12UploadedFileC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_S9_:
   47|  5.76k|{
   48|  5.76k|  fileInfo_.reset(new Impl());
   49|       |
   50|  5.76k|  fileInfo_->spoolFileName = spoolName;
   51|  5.76k|  fileInfo_->clientFileName = clientFileName;
   52|  5.76k|  fileInfo_->contentType = contentType;
   53|  5.76k|  fileInfo_->isStolen = false;
   54|  5.76k|}
_ZN2Wt4Http12UploadedFile4Impl7cleanupEv:
   57|  5.76k|{
   58|  5.76k|  if (!isStolen)
  ------------------
  |  Branch (58:7): [True: 5.76k, False: 0]
  ------------------
   59|  5.76k|    unlink(spoolFileName.c_str());
   60|  5.76k|}
_ZN2Wt4Http12UploadedFile4ImplD2Ev:
   63|  5.76k|{
   64|  5.76k|  cleanup();
   65|  5.76k|}
_ZN2Wt4Http7Request19parseFormUrlEncodedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERSt3mapIS7_St6vectorIS7_SaIS7_EESt4lessIS7_ESaISt4pairIS8_SD_EEE:
  399|  1.28k|{
  400|   208k|  for (std::size_t pos = 0; pos < s.length();) {
  ------------------
  |  Branch (400:29): [True: 207k, False: 1.28k]
  ------------------
  401|   207k|    std::size_t next = s.find_first_of("&=", pos);
  402|       |
  403|   207k|    if (next == pos && s[next] == '&') {
  ------------------
  |  Branch (403:9): [True: 68.4k, False: 139k]
  |  Branch (403:24): [True: 16.8k, False: 51.5k]
  ------------------
  404|       |      // skip empty
  405|  16.8k|      pos = next + 1;
  406|  16.8k|      continue;
  407|  16.8k|    }
  408|       |
  409|   190k|    if (next == std::string::npos || s[next] == '&') {
  ------------------
  |  Branch (409:9): [True: 877, False: 189k]
  |  Branch (409:38): [True: 105k, False: 83.9k]
  ------------------
  410|   106k|      if (next == std::string::npos)
  ------------------
  |  Branch (410:11): [True: 877, False: 105k]
  ------------------
  411|    877|        next = s.length();
  412|   106k|      std::string key = s.substr(pos, next - pos);
  413|   106k|      Utils::inplaceUrlDecode(key);
  414|   106k|      parameters[key].push_back(std::string());
  415|   106k|      pos = next + 1;
  416|   106k|    } else {
  417|  83.9k|      std::size_t amp = s.find('&', next + 1);
  418|  83.9k|      if (amp == std::string::npos)
  ------------------
  |  Branch (418:11): [True: 303, False: 83.6k]
  ------------------
  419|    303|        amp = s.length();
  420|       |
  421|  83.9k|      std::string key = s.substr(pos, next - pos);
  422|  83.9k|      Utils::inplaceUrlDecode(key);
  423|       |
  424|  83.9k|      std::string value = s.substr(next + 1, amp - (next + 1));
  425|  83.9k|      Utils::inplaceUrlDecode(value);
  426|       |
  427|  83.9k|      parameters[key].push_back(value);
  428|  83.9k|      pos = amp + 1;
  429|  83.9k|    }
  430|   190k|  }
  431|  1.28k|}

_ZN2Wt4Json5ArrayC2Ev:
   15|      2|  : Impl()
   16|      2|{ }

_ZN2Wt4Json6ObjectC2Ev:
   17|      2|{ }

_ZN2Wt4Json5ValueC2Ev:
   87|      2|{ }
_ZN2Wt4Json5ValueC2Eb:
   90|      4|  : v_(value)
   91|      4|{ }

_ZN2Wt10WExceptionC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
   75|  1.15k|  : what_(what)
   76|       |#endif
   77|  1.15k|{ }
_ZN2Wt10WExceptionD2Ev:
   89|  1.15k|{ }

_ZN2WtorENS_11OrientationES0_:
  370|    348|inline Wt::WFlags<EnumType> operator|(EnumType l, EnumType r) {         \
  371|    348|  Wt::WFlags<EnumType> retval(l);                                       \
  372|    348|  retval |= r;                                                          \
  373|    348|  return retval;                                                        \
  374|    348|}                                                                       \
_ZN2Wt6WFlagsINS_11OrientationEEC2ES1_:
  187|    348|  flags_(static_cast<unsigned int>(flag))
  188|    348|{
  189|    348|}
_ZN2Wt6WFlagsINS_11OrientationEEoRES1_:
  327|    348|{
  328|    348|  flags_ |= static_cast<unsigned int>(other);
  329|    348|  return *this;
  330|    348|}
_ZN2WtorENS_4SideES0_:
  370|    348|inline Wt::WFlags<EnumType> operator|(EnumType l, EnumType r) {         \
  371|    348|  Wt::WFlags<EnumType> retval(l);                                       \
  372|    348|  retval |= r;                                                          \
  373|    348|  return retval;                                                        \
  374|    348|}                                                                       \
_ZN2Wt6WFlagsINS_4SideEEC2ES1_:
  187|    348|  flags_(static_cast<unsigned int>(flag))
  188|    348|{
  189|    348|}
_ZN2Wt6WFlagsINS_4SideEEoRES1_:
  327|    348|{
  328|    348|  flags_ |= static_cast<unsigned int>(other);
  329|    348|  return *this;
  330|    348|}
_ZN2WtorENS_13AlignmentFlagES0_:
  370|    696|inline Wt::WFlags<EnumType> operator|(EnumType l, EnumType r) {         \
  371|    696|  Wt::WFlags<EnumType> retval(l);                                       \
  372|    696|  retval |= r;                                                          \
  373|    696|  return retval;                                                        \
  374|    696|}                                                                       \
_ZN2Wt6WFlagsINS_13AlignmentFlagEEC2ES1_:
  187|    696|  flags_(static_cast<unsigned int>(flag))
  188|    696|{
  189|    696|}
_ZN2Wt6WFlagsINS_13AlignmentFlagEEoRES1_:
  327|    696|{
  328|    696|  flags_ |= static_cast<unsigned int>(other);
  329|    696|  return *this;
  330|    696|}
_ZN2WtorENS_9MatchFlagES0_:
  370|    348|inline Wt::WFlags<EnumType> operator|(EnumType l, EnumType r) {         \
  371|    348|  Wt::WFlags<EnumType> retval(l);                                       \
  372|    348|  retval |= r;                                                          \
  373|    348|  return retval;                                                        \
  374|    348|}                                                                       \
_ZN2Wt6WFlagsINS_9MatchFlagEEC2ES1_:
  187|    348|  flags_(static_cast<unsigned int>(flag))
  188|    348|{
  189|    348|}
_ZN2Wt6WFlagsINS_9MatchFlagEEoRES1_:
  327|    348|{
  328|    348|  flags_ |= static_cast<unsigned int>(other);
  329|    348|  return *this;
  330|    348|}
_ZNK2Wt6WFlagsINS_4SideEEorES1_:
  313|    696|{
  314|    696|  return WFlags<EnumType>::createFromInt
  315|    696|    (flags_ | static_cast<unsigned int>(other));
  316|    696|}
_ZN2Wt6WFlagsINS_4SideEE13createFromIntEi:
  173|    696|  inline static WFlags<EnumType> createFromInt(int flags) {
  174|    696|    return WFlags(flags, false);
  175|    696|  }
_ZN2Wt6WFlagsINS_4SideEEC2Eib:
  172|    696|  WFlags(int flags, bool): flags_(flags) {}
_ZNK2Wt6WFlagsINS_13AlignmentFlagEEorES1_:
  313|  2.78k|{
  314|  2.78k|  return WFlags<EnumType>::createFromInt
  315|  2.78k|    (flags_ | static_cast<unsigned int>(other));
  316|  2.78k|}
_ZN2Wt6WFlagsINS_13AlignmentFlagEE13createFromIntEi:
  173|  2.78k|  inline static WFlags<EnumType> createFromInt(int flags) {
  174|  2.78k|    return WFlags(flags, false);
  175|  2.78k|  }
_ZN2Wt6WFlagsINS_13AlignmentFlagEEC2Eib:
  172|  2.78k|  WFlags(int flags, bool): flags_(flags) {}
_ZNK2Wt6WFlagsINS_9MatchFlagEEorES1_:
  313|  1.39k|{
  314|  1.39k|  return WFlags<EnumType>::createFromInt
  315|  1.39k|    (flags_ | static_cast<unsigned int>(other));
  316|  1.39k|}
_ZN2Wt6WFlagsINS_9MatchFlagEE13createFromIntEi:
  173|  1.39k|  inline static WFlags<EnumType> createFromInt(int flags) {
  174|  1.39k|    return WFlags(flags, false);
  175|  1.39k|  }
_ZN2Wt6WFlagsINS_9MatchFlagEEC2Eib:
  172|  1.39k|  WFlags(int flags, bool): flags_(flags) {}
_ZN2WtorENS_19ValidationStyleFlagES0_:
  370|     58|inline Wt::WFlags<EnumType> operator|(EnumType l, EnumType r) {         \
  371|     58|  Wt::WFlags<EnumType> retval(l);                                       \
  372|     58|  retval |= r;                                                          \
  373|     58|  return retval;                                                        \
  374|     58|}                                                                       \
_ZN2Wt6WFlagsINS_19ValidationStyleFlagEEC2ES1_:
  187|     58|  flags_(static_cast<unsigned int>(flag))
  188|     58|{
  189|     58|}
_ZN2Wt6WFlagsINS_19ValidationStyleFlagEEoRES1_:
  327|     58|{
  328|     58|  flags_ |= static_cast<unsigned int>(other);
  329|     58|  return *this;
  330|     58|}
_ZN2WtorENS_7WSlider12TickPositionES1_:
  370|      2|inline Wt::WFlags<EnumType> operator|(EnumType l, EnumType r) {         \
  371|      2|  Wt::WFlags<EnumType> retval(l);                                       \
  372|      2|  retval |= r;                                                          \
  373|      2|  return retval;                                                        \
  374|      2|}                                                                       \
_ZN2Wt6WFlagsINS_7WSlider12TickPositionEEoRES2_:
  327|      2|{
  328|      2|  flags_ |= static_cast<unsigned int>(other);
  329|      2|  return *this;
  330|      2|}
_ZN2Wt6WFlagsINS_7WSlider12TickPositionEEC2ES2_:
  187|      2|  flags_(static_cast<unsigned int>(flag))
  188|      2|{
  189|      2|}
_ZN2Wt6WFlagsINS_7WSlider12TickPositionEEC2ENS_11NoFlagsTypeE:
  193|      2|  : flags_(0)
  194|      2|{ }

_ZN2Wt26WJavaScriptExposableObjectC2Ev:
   17|      2|  : clientBinding_(nullptr)
   18|      2|{ }
_ZNK2Wt26WJavaScriptExposableObject17isJavaScriptBoundEv:
   46|      2|{
   47|      2|  return clientBinding_;
   48|      2|}
_ZNK2Wt26WJavaScriptExposableObject15checkModifiableEv:
   93|      2|{
   94|      2|  if (isJavaScriptBound()) {
  ------------------
  |  Branch (94:7): [True: 0, False: 2]
  ------------------
   95|      0|    throw WException("Trying to modify a JavaScript bound object!");
   96|      0|  }
   97|      2|}

_ZN2Wt7WLengthC2Ev:
   24|      2|  : auto_(true),
   25|      2|    unit_(LengthUnit::Pixel),
   26|      2|    value_(-1)
   27|      2|{ }

_ZN2Wt7WLocaleC2Ev:
   16|      2|  : decimalPoint_("."),
   17|      2|    groupSeparator_(""),
   18|      2|    dateFormat_("yyyy-MM-dd"),
   19|      2|    timeFormat_("HH:mm:ss"),
   20|      2|    dateTimeFormat_("yyyy-MM-dd HH:mm:ss"),
   21|      2|    timeZone_(nullptr)
   22|      2|{ }

_ZN2Wt9WLogEntryD2Ev:
   38|  7.03k|{
   39|  7.03k|  if (impl_) {
  ------------------
  |  Branch (39:7): [True: 7.03k, False: 0]
  ------------------
   40|  7.03k|    impl_->finish();
   41|  7.03k|    if (impl_->logger_)
  ------------------
  |  Branch (41:9): [True: 7.03k, False: 0]
  ------------------
   42|  7.03k|      impl_->logger_->addLine(impl_->type_, impl_->scope_, impl_->line_);
   43|      0|    else if (impl_->customLogger_)
  ------------------
  |  Branch (43:14): [True: 0, False: 0]
  ------------------
   44|      0|      impl_->customLogger_->log(impl_->type_, impl_->scope_, impl_->line_.str());
   45|  7.03k|  }
   46|  7.03k|}
_ZN2Wt9WLogEntrylsEPKc:
   67|  28.3k|{
   68|  28.3k|  return *this << std::string(s);
   69|  28.3k|}
_ZN2Wt9WLogEntrylsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
   79|  28.3k|{
   80|  28.3k|  if (impl_) {
  ------------------
  |  Branch (80:7): [True: 28.3k, False: 0]
  ------------------
   81|  28.3k|    if (impl_->quote()) {
  ------------------
  |  Branch (81:9): [True: 0, False: 28.3k]
  ------------------
   82|      0|      startField();
   83|       |
   84|      0|      std::string ss(s);
   85|      0|      Utils::replace(ss, '"', "\"\"");
   86|       |
   87|      0|      impl_->line_ << ss;
   88|  28.3k|    } else {
   89|  28.3k|      if (!s.empty()) {
  ------------------
  |  Branch (89:11): [True: 28.3k, False: 0]
  ------------------
   90|  28.3k|        startField();
   91|  28.3k|        impl_->line_ << s;
   92|  28.3k|      }
   93|  28.3k|    }
   94|       |
   95|  28.3k|    if ((impl_->customLogger_ ||
  ------------------
  |  Branch (95:10): [True: 0, False: 28.3k]
  ------------------
   96|  28.3k|         impl_->field_ == (int)impl_->logger_->fields().size() - 1)
  ------------------
  |  Branch (96:10): [True: 0, False: 28.3k]
  ------------------
   97|      0|        && impl_->scope_.empty())
  ------------------
  |  Branch (97:12): [True: 0, False: 0]
  ------------------
   98|      0|      impl_->scope_ = s;
   99|  28.3k|  }
  100|       |
  101|  28.3k|  return *this;
  102|  28.3k|}
_ZN2Wt9WLogEntrylsEi:
  115|  4.59k|{
  116|  4.59k|  startField();
  117|       |
  118|  4.59k|  if (impl_)
  ------------------
  |  Branch (118:7): [True: 4.59k, False: 0]
  ------------------
  119|  4.59k|    impl_->line_ << v;
  120|       |
  121|  4.59k|  return *this;
  122|  4.59k|}
_ZN2Wt9WLogEntrylsEd:
  135|  2.44k|{
  136|  2.44k|  startField();
  137|       |
  138|  2.44k|  if (impl_)
  ------------------
  |  Branch (138:7): [True: 2.44k, False: 0]
  ------------------
  139|  2.44k|    impl_->line_ << v;
  140|       |
  141|  2.44k|  return *this;
  142|  2.44k|}
_ZN2Wt9WLogEntryC2ERKNS_7WLoggerERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEb:
  146|  7.03k|{
  147|  7.03k|  if (!mute)
  ------------------
  |  Branch (147:7): [True: 7.03k, False: 0]
  ------------------
  148|  7.03k|    impl_.reset(new Impl(logger, type));
  149|  7.03k|}
_ZN2Wt9WLogEntry10startFieldEv:
  158|  35.5k|{
  159|  35.5k|  if (impl_)
  ------------------
  |  Branch (159:7): [True: 35.5k, False: 0]
  ------------------
  160|  35.5k|    impl_->startField();
  161|  35.5k|}
_ZN2Wt9WLogEntry4ImplC2ERKNS_7WLoggerERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  164|  7.03k|  : logger_(&logger),
  165|  7.03k|    customLogger_(nullptr),
  166|  7.03k|    type_(type),
  167|  7.03k|    field_(0),
  168|  7.03k|    fieldStarted_(false)
  169|  7.03k|{ }
_ZN2Wt9WLogEntry4Impl10startFieldEv:
  181|  35.5k|{
  182|  35.5k|  if (!fieldStarted_) {
  ------------------
  |  Branch (182:7): [True: 7.03k, False: 28.5k]
  ------------------
  183|  7.03k|    if (quote())
  ------------------
  |  Branch (183:9): [True: 0, False: 7.03k]
  ------------------
  184|      0|      line_ << '"';
  185|  7.03k|    fieldStarted_ = true;
  186|  7.03k|  }
  187|  35.5k|}
_ZN2Wt9WLogEntry4Impl11finishFieldEv:
  190|  7.03k|{
  191|  7.03k|  if (fieldStarted_) {
  ------------------
  |  Branch (191:7): [True: 7.03k, False: 0]
  ------------------
  192|  7.03k|    if (quote())
  ------------------
  |  Branch (192:9): [True: 0, False: 7.03k]
  ------------------
  193|      0|      line_ << '"';
  194|  7.03k|  } else
  195|      0|    line_ << '-';
  196|  7.03k|}
_ZN2Wt9WLogEntry4Impl6finishEv:
  208|  7.03k|{
  209|  7.03k|  if (!customLogger_) {
  ------------------
  |  Branch (209:7): [True: 7.03k, False: 0]
  ------------------
  210|  7.03k|    while (field_ < (int)logger_->fields().size() - 1)
  ------------------
  |  Branch (210:12): [True: 0, False: 7.03k]
  ------------------
  211|      0|      nextField();
  212|  7.03k|  }
  213|       |
  214|  7.03k|  finishField();
  215|  7.03k|}
_ZNK2Wt9WLogEntry4Impl5quoteEv:
  218|  42.3k|{
  219|  42.3k|  if (customLogger_)
  ------------------
  |  Branch (219:7): [True: 0, False: 42.3k]
  ------------------
  220|      0|    return false;
  221|  42.3k|  else if (field_ < (int)logger_->fields().size())
  ------------------
  |  Branch (221:12): [True: 0, False: 42.3k]
  ------------------
  222|      0|    return logger_->fields()[field_].isString();
  223|  42.3k|  else
  224|  42.3k|    return false;
  225|  42.3k|}
_ZN2Wt7WLoggerC2Ev:
  236|      2|  : o_(&std::cerr),
  237|      2|    ownStream_(false),
  238|      2|    useLock_(true)
  239|      2|{
  240|      2|  Rule r;
  241|      2|  r.type = "*";
  242|      2|  r.scope = "*";
  243|      2|  r.include = true;
  244|      2|  rules_.push_back(r);
  245|      2|  r.type = "debug";
  246|      2|  r.include = false;
  247|      2|  rules_.push_back(r);
  248|      2|}
_ZNK2Wt7WLogger5entryERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  311|  7.03k|{
  312|  7.03k|  return WLogEntry(*this, type, !logging(type));
  313|  7.03k|}
_ZNK2Wt7WLogger7addLineERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_RKNS_13WStringStreamE:
  317|  7.03k|{
  318|  7.03k|  if (logging(type, scope)) {
  ------------------
  |  Branch (318:7): [True: 7.03k, False: 0]
  ------------------
  319|  7.03k|    std::unique_lock<std::mutex> l;
  320|  7.03k|    if (useLock_) {
  ------------------
  |  Branch (320:9): [True: 7.03k, False: 0]
  ------------------
  321|  7.03k|      l = std::unique_lock<std::mutex>(addLineLock_);
  322|  7.03k|    }
  323|       |
  324|  7.03k|    if (o_) {
  ------------------
  |  Branch (324:9): [True: 7.03k, False: 0]
  ------------------
  325|  7.03k|      *o_ << s.str() << std::endl;
  326|  7.03k|    }
  327|  7.03k|  }
  328|  7.03k|}
_ZNK2Wt7WLogger7loggingERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  363|  7.03k|{
  364|  7.03k|  return logging(type.c_str());
  365|  7.03k|}
_ZNK2Wt7WLogger7loggingEPKc:
  368|  7.03k|{
  369|  7.03k|  bool result = false;
  370|       |
  371|  21.1k|  for (unsigned i = 0; i < rules_.size(); ++i)
  ------------------
  |  Branch (371:24): [True: 14.0k, False: 7.03k]
  ------------------
  372|  14.0k|    if (rules_[i].type == "*" || rules_[i].type == type) {
  ------------------
  |  Branch (372:9): [True: 7.03k, False: 7.03k]
  |  Branch (372:34): [True: 0, False: 7.03k]
  ------------------
  373|  7.03k|      if (rules_[i].scope == "*")
  ------------------
  |  Branch (373:11): [True: 7.03k, False: 0]
  ------------------
  374|  7.03k|        result = rules_[i].include;
  375|      0|      else if (rules_[i].include)
  ------------------
  |  Branch (375:16): [True: 0, False: 0]
  ------------------
  376|      0|        result = true;
  377|  7.03k|    }
  378|       |
  379|  7.03k|  return result;
  380|  7.03k|}
_ZNK2Wt7WLogger7loggingERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_:
  383|  14.0k|{
  384|  14.0k|  bool result = false;
  385|       |
  386|  42.2k|  for (unsigned i = 0; i < rules_.size(); ++i)
  ------------------
  |  Branch (386:24): [True: 28.1k, False: 14.0k]
  ------------------
  387|  28.1k|    if (rules_[i].type == "*" || rules_[i].type == type)
  ------------------
  |  Branch (387:9): [True: 14.0k, False: 14.0k]
  |  Branch (387:34): [True: 0, False: 14.0k]
  ------------------
  388|  14.0k|      if (rules_[i].scope == "*" || rules_[i].scope == scope)
  ------------------
  |  Branch (388:11): [True: 14.0k, False: 0]
  |  Branch (388:37): [True: 0, False: 0]
  ------------------
  389|  14.0k|        result = rules_[i].include;
  390|       |
  391|  14.0k|  return result;
  392|  14.0k|}
_ZN2Wt7loggingERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_:
  421|  7.03k|{
  422|       |#ifdef WT_DBO_LOGGER
  423|       |  if (customLogger_)
  424|       |    return customLogger_->logging(type, scope);
  425|       |
  426|       |  return true;
  427|       |#else // WT_DBO_LOGGER
  428|  7.03k|  WebSession *session = WebSession::instance();
  429|       |
  430|  7.03k|  Wt::WServer *server = session ? session->controller()->server() : WServer::instance();
  ------------------
  |  Branch (430:25): [True: 0, False: 7.03k]
  ------------------
  431|  7.03k|  if (server) {
  ------------------
  |  Branch (431:7): [True: 0, False: 7.03k]
  ------------------
  432|      0|    if (server->customLogger())
  ------------------
  |  Branch (432:9): [True: 0, False: 0]
  ------------------
  433|      0|      return server->customLogger()->logging(type, scope);
  434|      0|    else
  435|      0|      return server->logger().logging(type, scope);
  436|  7.03k|  } else {
  437|  7.03k|    return defaultLogger.logging(type, scope);
  438|  7.03k|  }
  439|  7.03k|#endif // WT_DBO_LOGGER
  440|  7.03k|}
_ZN2Wt3logERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  443|  7.03k|{
  444|       |#ifdef WT_DBO_LOGGER
  445|       |  if (customLogger_) {
  446|       |    return WLogEntry(*customLogger_, type);
  447|       |  }
  448|       |
  449|       |  return defaultLogger.entry(type);
  450|       |#else // WT_DBO_LOGGER
  451|  7.03k|  WebSession *session = WebSession::instance();
  452|       |
  453|  7.03k|  if (session)
  ------------------
  |  Branch (453:7): [True: 0, False: 7.03k]
  ------------------
  454|      0|    return session->log(type);
  455|  7.03k|  else {
  456|  7.03k|    WServer *server = WServer::instance();
  457|       |
  458|  7.03k|    if (server)
  ------------------
  |  Branch (458:9): [True: 0, False: 7.03k]
  ------------------
  459|      0|      return server->log(type);
  460|  7.03k|    else
  461|  7.03k|      return defaultLogger.entry(type);
  462|  7.03k|  }
  463|  7.03k|#endif // WT_DBO_LOGGER
  464|  7.03k|}

_ZN2Wt9WLogEntrylsImEERS0_T_:
  388|    183|  WLogEntry& operator<< (T t) {
  389|    183|    startField();
  390|    183|    if (impl_)
  ------------------
  |  Branch (390:9): [True: 183, False: 0]
  ------------------
  391|    183|    {
  392|    183|      using std::to_string;
  393|    183|      impl_->line_ << to_string(t);
  394|    183|    }
  395|    183|    return *this;
  396|    183|  }
_ZNK2Wt7WLogger6fieldsEv:
  219|  77.7k|  const std::vector<Field>& fields() const { return fields_; }

_ZN2Wt7WServer8instanceEv:
  226|  14.0k|  static WServer *instance() { return instance_; }

_ZN2Wt7WStringC2Ev:
   28|      2|  : impl_(nullptr)
   29|      2|{ }
_ZN2Wt7WStringC2EPKcNS_12CharEncodingE:
   71|      6|  : impl_(nullptr)
   72|      6|{
   73|      6|  if (value) {
  ------------------
  |  Branch (73:7): [True: 6, False: 0]
  ------------------
   74|      6|    if (realEncoding(encoding) == CharEncoding::UTF8)
  ------------------
  |  Branch (74:9): [True: 6, False: 0]
  ------------------
   75|      6|      utf8_ = value;
   76|      0|    else
   77|      0|      utf8_ = Wt::toUTF8(value);
   78|      6|  }
   79|      6|}
_ZN2Wt7WString12realEncodingENS_12CharEncodingE:
  611|      6|{
  612|      6|  return encoding == CharEncoding::Default
  ------------------
  |  Branch (612:10): [True: 6, False: 0]
  ------------------
  613|      6|    ? defaultEncoding_ : encoding;
  614|      6|}

_ZN2Wt13WStringStreamC2Ev:
   34|  7.03k|  : sink_(0),
   35|  7.03k|    buf_(static_buf_),
   36|  7.03k|    buf_i_(0)
   37|  7.03k|{ }
_ZN2Wt13WStringStreamD2Ev:
   53|  7.03k|{
   54|  7.03k|  flushSink();
   55|       |
   56|  7.03k|  clear();
   57|  7.03k|}
_ZN2Wt13WStringStream5clearEv:
   60|  7.03k|{
   61|  7.03k|  buf_i_ = 0;
   62|       |
   63|  7.03k|  for (unsigned int i = 0; i < bufs_.size(); ++i)
  ------------------
  |  Branch (63:28): [True: 0, False: 7.03k]
  ------------------
   64|      0|    if (bufs_[i].first != static_buf_)
  ------------------
  |  Branch (64:9): [True: 0, False: 0]
  ------------------
   65|      0|      delete[] bufs_[i].first;
   66|       |
   67|  7.03k|  bufs_.clear();
   68|       |
   69|  7.03k|  if (buf_ != static_buf_)
  ------------------
  |  Branch (69:7): [True: 0, False: 7.03k]
  ------------------
   70|      0|    delete[] buf_;
   71|       |
   72|  7.03k|  buf_ = static_buf_;
   73|  7.03k|}
_ZNK2Wt13WStringStream6lengthEv:
   81|  7.03k|{
   82|  7.03k|  std::size_t result = buf_i_;
   83|       |
   84|  7.03k|  for (unsigned int i = 0; i < bufs_.size(); ++i)
  ------------------
  |  Branch (84:28): [True: 0, False: 7.03k]
  ------------------
   85|      0|    result += bufs_[i].second;
   86|       |
   87|  7.03k|  return result;
   88|  7.03k|}
_ZN2Wt13WStringStream9flushSinkEv:
   91|  7.03k|{
   92|  7.03k|  if (sink_) {
  ------------------
  |  Branch (92:7): [True: 0, False: 7.03k]
  ------------------
   93|      0|    sink_->write(buf_, buf_i_);
   94|      0|    buf_i_ = 0;
   95|      0|  }
   96|  7.03k|}
_ZN2Wt13WStringStreamlsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  124|  28.5k|{
  125|  28.5k|  append(s.data(), s.length());
  126|       |
  127|  28.5k|  return *this;
  128|  28.5k|}
_ZN2Wt13WStringStreamlsEi:
  131|  4.59k|{
  132|  4.59k|  char buf[20];
  133|  4.59k|  Utils::itoa(v, buf);
  134|  4.59k|  return *this << buf;
  135|  4.59k|}
_ZN2Wt13WStringStreamlsEd:
  160|  2.44k|{
  161|  2.44k|  char buf[50];
  162|  2.44k|  snprintf(buf, 50, "%g", d);
  163|  2.44k|  return *this << buf;
  164|  2.44k|}
_ZN2Wt13WStringStream6appendEPKci:
  167|  35.5k|{
  168|  35.5k|  if (buf_i_ + length > buf_len()) {
  ------------------
  |  Branch (168:7): [True: 0, False: 35.5k]
  ------------------
  169|      0|    pushBuf();
  170|       |
  171|      0|    if (length > buf_len()) {
  ------------------
  |  Branch (171:9): [True: 0, False: 0]
  ------------------
  172|      0|      if (sink_) {
  ------------------
  |  Branch (172:11): [True: 0, False: 0]
  ------------------
  173|      0|        sink_->write(s, length);
  174|      0|        return;
  175|      0|      } else {
  176|      0|        char *buf = new char[length];
  177|      0|        std::memcpy(buf, s, length);
  178|      0|        bufs_.push_back(std::make_pair(buf, length));
  179|      0|        return;
  180|      0|      }
  181|      0|    }
  182|      0|  }
  183|       |
  184|  35.5k|  std::memcpy(buf_ + buf_i_, s, length);
  185|  35.5k|  buf_i_ += length;
  186|  35.5k|}
_ZNK2Wt13WStringStream3strB5cxx11Ev:
  198|  7.03k|{
  199|  7.03k|  std::string result;
  200|  7.03k|  result.reserve(length());
  201|       |
  202|  7.03k|  for (unsigned int i = 0; i < bufs_.size(); ++i)
  ------------------
  |  Branch (202:28): [True: 0, False: 7.03k]
  ------------------
  203|      0|    result.append(bufs_[i].first, bufs_[i].second);
  204|       |
  205|  7.03k|  result.append(buf_, buf_i_);
  206|       |
  207|  7.03k|  return result;
  208|  7.03k|}

_ZN2Wt13WStringStreamlsEPKc:
  119|  7.03k|  {
  120|  7.03k|    append(s, std::strlen(s));
  121|       |
  122|  7.03k|    return *this;
  123|  7.03k|  }
_ZNK2Wt13WStringStream7buf_lenEv:
  219|  35.5k|    { return buf_ == static_buf_ ? static_cast<int>(S_LEN)
  ------------------
  |  Branch (219:14): [True: 35.5k, False: 0]
  ------------------
  220|  35.5k|        : static_cast<int>(D_LEN); }

_ZN2Wt10WTransformC2Ev:
   29|      2|{
   30|      2|  reset();
   31|      2|}
_ZN2Wt10WTransform5resetEv:
  105|      2|{
  106|      2|  checkModifiable();
  107|      2|  m_[M11] = m_[M22] = 1;
  108|      2|  m_[M21] = m_[M12] = m_[M13] = m_[M23] = 0;
  109|      2|}

_ZN4linb3anyC2Ev:
   40|      2|        vtable(nullptr)
   41|      2|    {
   42|      2|    }
_ZN4linb3any15vtable_for_typeIbEEPNS0_11vtable_typeEv:
  285|      4|    {
  286|      4|        using VTableType = typename std::conditional<requires_allocation<T>::value, vtable_dynamic<T>, vtable_stack<T>>::type;
  287|      4|        static vtable_type table = {
  288|      4|            VTableType::type, VTableType::destroy,
  289|      4|            VTableType::copy, VTableType::move,
  290|      4|            VTableType::swap,
  291|      4|        };
  292|      4|        return &table;
  293|      4|    }
_ZN4linb3anyC2IRbvEEOT_:
   78|      4|    {
   79|      4|        static_assert(std::is_copy_constructible<typename std::decay<ValueType>::type>::value,
   80|      4|            "T shall satisfy the CopyConstructible requirements.");
   81|      4|        this->construct(std::forward<ValueType>(value));
   82|      4|    }
_ZN4linb3any9constructIRbEEvOT_:
  362|      4|    {
  363|      4|        using T = typename std::decay<ValueType>::type;
  364|       |
  365|      4|        this->vtable = vtable_for_type<T>();
  366|       |
  367|      4|        do_construct<ValueType, T>(std::forward<ValueType>(value));
  368|      4|    }
_ZN4linb3any12do_constructIRbbEENSt9enable_ifIXntsr19requires_allocationIT0_EE5valueEvE4typeEOT_:
  354|      4|    {
  355|      4|        new (&storage.stack) T(std::forward<ValueType>(value));
  356|      4|    }

_ZN2Wt9CgiParserC2Ell:
  213|  2.44k|  : maxFormData_(maxFormData),
  214|  2.44k|    maxRequestSize_(maxRequestSize)
  215|  2.44k|{ }
_ZN2Wt9CgiParser5parseERNS_10WebRequestENS0_10ReadOptionE:
  218|  2.44k|{
  219|       |  /*
  220|       |   * TODO: optimize this ...
  221|       |   */
  222|  2.44k|  request_ = &request;
  223|       |
  224|  2.44k|  ::int64_t len = request.contentLength();
  225|  2.44k|  const char *type = request.contentType();
  226|  2.44k|  const char *meth = request.requestMethod();
  227|       |
  228|  2.44k|  request.postDataExceeded_ = (len > maxRequestSize_ ? len : 0);
  ------------------
  |  Branch (228:32): [True: 0, False: 2.44k]
  ------------------
  229|       |
  230|  2.44k|  std::string queryString = request.queryString();
  231|       |
  232|  2.44k|  LOG_DEBUG("queryString (len=" << len << "): " << queryString);
  233|       |
  234|  2.44k|  if (!queryString.empty() && request_->parameters_.empty()) {
  ------------------
  |  Branch (234:7): [True: 0, False: 2.44k]
  |  Branch (234:31): [True: 0, False: 0]
  ------------------
  235|      0|    Http::Request::parseFormUrlEncoded(queryString, request_->parameters_);
  236|      0|  }
  237|       |
  238|       |  // XDomainRequest cannot set a contentType header, we therefore pass it
  239|       |  // as a request parameter
  240|  2.44k|  if (readOption != ReadHeadersOnly &&
  ------------------
  |  Branch (240:7): [True: 2.44k, False: 0]
  ------------------
  241|  2.44k|      strcmp(meth, "POST") == 0 &&
  ------------------
  |  Branch (241:7): [True: 2.44k, False: 0]
  ------------------
  242|  2.44k|      ((type && strstr(type, "application/x-www-form-urlencoded") == type) ||
  ------------------
  |  Branch (242:9): [True: 2.44k, False: 0]
  |  Branch (242:17): [True: 1.26k, False: 1.17k]
  ------------------
  243|  1.17k|       (queryString.find("&contentType=x-www-form-urlencoded") !=
  ------------------
  |  Branch (243:8): [True: 0, False: 1.17k]
  ------------------
  244|  1.26k|        std::string::npos))) {
  245|       |    /*
  246|       |     * TODO: parse this stream-based to avoid the malloc here. For now
  247|       |     * we protect the maximum that can be POST'ed as form data.
  248|       |     */
  249|  1.26k|    if (len > maxFormData_)
  ------------------
  |  Branch (249:9): [True: 0, False: 1.26k]
  ------------------
  250|      0|      throw WException("Oversized application/x-www-form-urlencoded ("
  251|      0|                       + std::to_string(len) + ")");
  252|       |
  253|  1.26k|    auto buf = std::unique_ptr<char[]>(new char[len + 1]);
  254|       |
  255|  1.26k|    request.in().read(buf.get(), len);
  256|       |
  257|  1.26k|    if (request.in().gcount() != (int)len) {
  ------------------
  |  Branch (257:9): [True: 0, False: 1.26k]
  ------------------
  258|      0|      throw WException("Unexpected short read.");
  259|      0|    }
  260|       |
  261|  1.26k|    buf[len] = 0;
  262|       |
  263|       |    // This is a special Wt feature, I do not think it standard.
  264|       |    // For POST, parameters in url-encoded URL are still parsed.
  265|       |
  266|  1.26k|    std::string formQueryString = buf.get();
  267|       |
  268|  1.26k|    LOG_DEBUG("formQueryString (len=" << len << "): " << formQueryString);
  269|  1.26k|    if (!formQueryString.empty()) {
  ------------------
  |  Branch (269:9): [True: 1.25k, False: 8]
  ------------------
  270|  1.25k|      Http::Request::parseFormUrlEncoded(formQueryString, request_->parameters_);
  271|  1.25k|    }
  272|  1.26k|    Http::ParameterMap::const_iterator it = request_->parameters_.find("Wt-params");
  273|  1.26k|    if (it != request_->parameters_.end() && it->second.size() == 1) {
  ------------------
  |  Branch (273:9): [True: 43, False: 1.22k]
  |  Branch (273:9): [True: 29, False: 1.23k]
  |  Branch (273:46): [True: 29, False: 14]
  ------------------
  274|       |      // We need a copy here in case of unexpected second "Wt-params"
  275|       |      // see issue#14616.
  276|     29|      std::string wtParams = it->second[0];
  277|     29|      Http::Request::parseFormUrlEncoded(wtParams, request_->parameters_);
  278|     29|    }
  279|  1.26k|  }
  280|       |
  281|  2.44k|  if (readOption != ReadHeadersOnly &&
  ------------------
  |  Branch (281:7): [True: 2.44k, False: 0]
  ------------------
  282|  2.44k|      type && strstr(type, "multipart/form-data") == type) {
  ------------------
  |  Branch (282:7): [True: 2.44k, False: 0]
  |  Branch (282:15): [True: 1.17k, False: 1.26k]
  ------------------
  283|  1.17k|    if (strcmp(meth, "POST") != 0) {
  ------------------
  |  Branch (283:9): [True: 0, False: 1.17k]
  ------------------
  284|      0|      throw WException("Invalid method for multipart/form-data: "
  285|      0|                       + std::string(meth));
  286|      0|    }
  287|       |
  288|  1.17k|    if (!request.postDataExceeded_)
  ------------------
  |  Branch (288:9): [True: 1.17k, False: 0]
  ------------------
  289|  1.17k|      readMultipartData(request, type, len);
  290|      0|    else if (readOption == ReadBodyAnyway) {
  ------------------
  |  Branch (290:14): [True: 0, False: 0]
  ------------------
  291|      0|      for (;len > 0;) {
  ------------------
  |  Branch (291:13): [True: 0, False: 0]
  ------------------
  292|      0|        ::int64_t toRead = std::min(::int64_t(BUFSIZE), len);
  293|      0|        request.in().read(buf_, toRead);
  294|      0|        if (request.in().gcount() != (::int64_t)toRead)
  ------------------
  |  Branch (294:13): [True: 0, False: 0]
  ------------------
  295|      0|          throw WException("CgiParser: short read");
  296|      0|        len -= toRead;
  297|      0|      }
  298|      0|    }
  299|  1.17k|  }
  300|  2.44k|}
_ZN2Wt9CgiParser17readMultipartDataERNS_10WebRequestENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEl:
  304|  1.17k|{
  305|  1.17k|  std::string boundary;
  306|       |
  307|  1.17k|  if (!fishBoundaryValue(type, boundary))
  ------------------
  |  Branch (307:7): [True: 0, False: 1.17k]
  ------------------
  308|      0|    throw WException("Could not find a boundary for multipart data.");
  309|       |
  310|  1.17k|  boundary = "--" + boundary;
  311|       |
  312|  1.17k|  buflen_ = 0;
  313|  1.17k|  left_ = len;
  314|  1.17k|  spoolStream_.reset();
  315|  1.17k|  currentKey_.clear();
  316|       |
  317|  1.17k|  if (!parseBody(request, boundary))
  ------------------
  |  Branch (317:7): [True: 1, False: 1.17k]
  ------------------
  318|      1|    return;
  319|       |
  320|  35.3k|  for (;;) {
  321|  35.3k|    if (!parseHead(request))
  ------------------
  |  Branch (321:9): [True: 0, False: 35.3k]
  ------------------
  322|      0|      break;
  323|  35.3k|    if (!parseBody(request,boundary))
  ------------------
  |  Branch (323:9): [True: 11, False: 35.3k]
  ------------------
  324|     11|      break;
  325|  35.3k|  }
  326|  1.17k|}
_ZN2Wt9CgiParser17readUntilBoundaryERNS_10WebRequestENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiPS8_PSo:
  345|  71.6k|{
  346|  71.6k|  int bpos;
  347|  71.6k|  int totalSaved = 0;
  348|       |
  349|  73.1k|  while ((bpos = index(boundary)) == -1) {
  ------------------
  |  Branch (349:10): [True: 2.59k, False: 70.5k]
  ------------------
  350|       |    /*
  351|       |     * If we couldn't find it. We need to wind the buffer, but only save
  352|       |     * not including the boundary length.
  353|       |     */
  354|  2.59k|    if (left_ == 0)
  ------------------
  |  Branch (354:9): [True: 1.13k, False: 1.46k]
  ------------------
  355|  1.13k|      throw WException("CgiParser: reached end of input while seeking end of "
  356|  1.13k|                       "headers or content. Format of CGI input is wrong");
  357|       |
  358|       |    /* save (up to) BUFSIZE from buffer to file or value string, but
  359|       |     * mind the boundary length */
  360|  1.46k|    int save = std::min((buflen_ - (int)boundary.length()), (int)BUFSIZE);
  361|  1.46k|    totalSaved += save;
  362|  1.46k|    if (maxLength >= 0 && totalSaved > maxLength) {
  ------------------
  |  Branch (362:9): [True: 216, False: 1.24k]
  |  Branch (362:27): [True: 17, False: 199]
  ------------------
  363|     17|      throw WException("CgiParser: maximum length for headers or content exceeded.");
  364|     17|    }
  365|       |
  366|  1.44k|    if (save > 0) {
  ------------------
  |  Branch (366:9): [True: 196, False: 1.24k]
  ------------------
  367|    196|      if (resultString)
  ------------------
  |  Branch (367:11): [True: 129, False: 67]
  ------------------
  368|    129|        *resultString += std::string(buf_, save);
  369|    196|      if (resultFile)
  ------------------
  |  Branch (369:11): [True: 18, False: 178]
  ------------------
  370|     18|        resultFile->write(buf_, save);
  371|       |
  372|       |      /* wind buffer */
  373|    196|      windBuffer(save);
  374|    196|    }
  375|       |
  376|  1.44k|    unsigned amt = static_cast<unsigned>
  377|  1.44k|      (std::min(left_,
  378|  1.44k|                static_cast< ::int64_t >(BUFSIZE + MAXBOUND - buflen_)));
  379|       |
  380|  1.44k|    request.in().read(buf_ + buflen_, amt);
  381|  1.44k|    if (request.in().gcount() != (int)amt)
  ------------------
  |  Branch (381:9): [True: 0, False: 1.44k]
  ------------------
  382|      0|      throw WException("CgiParser: short read");
  383|       |
  384|  1.44k|    left_ -= amt;
  385|  1.44k|    buflen_ += amt;
  386|  1.44k|  }
  387|       |
  388|  70.5k|  if (maxLength >= 0 && totalSaved + bpos - tossAtBoundary > maxLength) {
  ------------------
  |  Branch (388:7): [True: 44.4k, False: 26.0k]
  |  Branch (388:25): [True: 5, False: 44.4k]
  ------------------
  389|      5|    throw WException("CgiParser: maximum length for headers or content exceeded.");
  390|      5|  }
  391|       |
  392|  70.5k|  if (resultString)
  ------------------
  |  Branch (392:7): [True: 38.9k, False: 31.5k]
  ------------------
  393|  38.9k|    *resultString += std::string(buf_, bpos - tossAtBoundary);
  394|  70.5k|  if (resultFile)
  ------------------
  |  Branch (394:7): [True: 5.45k, False: 65.0k]
  ------------------
  395|  5.45k|    resultFile->write(buf_, bpos - tossAtBoundary);
  396|       |
  397|       |  /* wind buffer */
  398|  70.5k|  windBuffer(bpos);
  399|  70.5k|}
_ZN2Wt9CgiParser10windBufferEi:
  402|   141k|{
  403|   141k|  if (offset < buflen_) {
  ------------------
  |  Branch (403:7): [True: 140k, False: 513]
  ------------------
  404|   140k|    memmove(buf_, buf_ + offset, buflen_ - offset);
  405|   140k|    buflen_ -= offset;
  406|   140k|  } else
  407|    513|    buflen_ = 0;
  408|   141k|}
_ZN2Wt9CgiParser5indexENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  411|  73.1k|{
  412|  73.1k|  std::string bufS = std::string(buf_, buflen_);
  413|       |
  414|  73.1k|  std::string::size_type i = bufS.find(search);
  415|       |
  416|  73.1k|  if (i == std::string::npos)
  ------------------
  |  Branch (416:7): [True: 2.59k, False: 70.5k]
  ------------------
  417|  2.59k|    return -1;
  418|  70.5k|  else
  419|  70.5k|    return i;
  420|  73.1k|}
_ZN2Wt9CgiParser9parseHeadERNS_10WebRequestE:
  423|  35.3k|{
  424|  35.3k|  std::string head;
  425|  35.3k|  readUntilBoundary(request, "\r\n\r\n", -2, MAX_HEADER_FIELD_LENGTH, &head, 0);
  426|       |
  427|  35.3k|  std::string name;
  428|  35.3k|  std::string fn;
  429|  35.3k|  std::string ctype;
  430|       |
  431|  87.3k|  for (unsigned current = 0; current < head.length();) {
  ------------------
  |  Branch (431:30): [True: 52.0k, False: 35.3k]
  ------------------
  432|       |    /* read line by line */
  433|  52.0k|    std::string::size_type i = head.find("\r\n", current);
  434|  52.0k|    const std::string text = head.substr(current, (i == std::string::npos
  ------------------
  |  Branch (434:52): [True: 0, False: 52.0k]
  ------------------
  435|  52.0k|                                                   ? std::string::npos
  436|  52.0k|                                                   : i - current));
  437|       |
  438|  52.0k|    if (isHeader("content-disposition:", text)) {
  ------------------
  |  Branch (438:9): [True: 15.5k, False: 36.5k]
  ------------------
  439|       |      // If the name is not found or is too long, we ignore the header.
  440|  15.5k|      if (fishNameValue(text, name)) {
  ------------------
  |  Branch (440:11): [True: 11.0k, False: 4.41k]
  ------------------
  441|  11.0k|        fishFilenameValue(text, fn);
  442|  11.0k|      } else {
  443|  4.41k|        LOG_WARN("Received a Content-Disposition header in a multipart/form-data request without a name parameter, or with a name parameter exceeding maximum of " << MAX_NAME_LENGTH << ". Ignoring header.");
  ------------------
  |  |  501|  4.41k|#   define LOG_WARN(m) do { \
  |  |  502|  4.41k|    if ( WT_LOGGING("warning", WT_LOGGER)) \
  |  |  ------------------
  |  |  |  |  479|  4.41k|#     define WT_LOGGING Wt::logging
  |  |  ------------------
  |  |                   if ( WT_LOGGING("warning", WT_LOGGER)) \
  |  |  ------------------
  |  |  |  |  478|  4.41k|#     define WT_LOGGER Wt::logger
  |  |  ------------------
  |  |  |  Branch (502:10): [True: 4.41k, False: 0]
  |  |  ------------------
  |  |  503|  4.41k|      WT_LOG("warning") << WT_LOGGER << ": " << m; \
  |  |  ------------------
  |  |  |  |  477|  26.4k|#     define WT_LOG Wt::log
  |  |  ------------------
  |  |                     WT_LOG("warning") << WT_LOGGER << ": " << m; \
  |  |  ------------------
  |  |  |  |  478|  4.41k|#     define WT_LOGGER Wt::logger
  |  |  ------------------
  |  |  504|  4.41k|    } while(0)
  |  |  ------------------
  |  |  |  Branch (504:13): [Folded, False: 4.41k]
  |  |  ------------------
  ------------------
  444|  4.41k|      }
  445|  15.5k|    }
  446|       |
  447|  52.0k|    if (isHeader("content-type:", text)) {
  ------------------
  |  Branch (447:9): [True: 3.00k, False: 49.0k]
  ------------------
  448|  3.00k|      fishContentTypeValue(text, ctype);
  449|  3.00k|    }
  450|       |
  451|  52.0k|    current = i + 2;
  452|  52.0k|  }
  453|       |
  454|  35.3k|  LOG_DEBUG("name: " << name << " ct: " << ctype  << " fn: " << fn);
  455|       |
  456|  35.3k|  currentKey_ = name;
  457|       |
  458|  35.3k|  if (!fn.empty()) {
  ------------------
  |  Branch (458:7): [True: 5.76k, False: 29.5k]
  ------------------
  459|  5.76k|    if (!request.postDataExceeded_) {
  ------------------
  |  Branch (459:9): [True: 5.76k, False: 0]
  ------------------
  460|       |      /*
  461|       |       * It is not easy to create a std::ostream pointing to a
  462|       |       * temporary file name.
  463|       |       */
  464|  5.76k|      std::string spool = FileUtils::createTempFileName();
  465|       |
  466|  5.76k|      spoolStream_ = std::make_unique<std::ofstream>(spool.c_str(),
  467|  5.76k|        std::ios::out | std::ios::binary);
  468|       |
  469|  5.76k|      request_->files_.insert
  470|  5.76k|        (std::make_pair(name, Http::UploadedFile(spool, fn, ctype)));
  471|       |
  472|  5.76k|      LOG_DEBUG("spooling file to " << spool.c_str());
  473|       |
  474|  5.76k|    } else {
  475|      0|      spoolStream_.reset();
  476|       |      // Clear currentKey so that file we don't do harm by reading this
  477|       |      // giant blob in memory
  478|      0|      currentKey_ = "";
  479|      0|    }
  480|  5.76k|  }
  481|       |
  482|  35.3k|  windBuffer(4);
  483|       |
  484|  35.3k|  return true;
  485|  35.3k|}
_ZN2Wt9CgiParser9parseBodyERNS_10WebRequestENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  488|  36.3k|{
  489|  36.3k|  std::string value;
  490|  36.3k|  bool writeToMemory = !spoolStream_ && !currentKey_.empty();
  ------------------
  |  Branch (490:24): [True: 30.5k, False: 5.76k]
  |  Branch (490:41): [True: 3.95k, False: 26.5k]
  ------------------
  491|       |
  492|  36.3k|  int maxLength = -1;
  493|  36.3k|  if (writeToMemory) {
  ------------------
  |  Branch (493:7): [True: 3.95k, False: 32.3k]
  ------------------
  494|  3.95k|    maxLength = MAX_MULTIPART_NON_FILE_VALUE_SIZE;
  495|  32.3k|  } else if (spoolStream_) {
  ------------------
  |  Branch (495:14): [True: 5.76k, False: 26.5k]
  ------------------
  496|  5.76k|    maxLength = maxRequestSize_;
  497|  5.76k|  }
  498|       |
  499|  36.3k|  readUntilBoundary(request, boundary, 2,
  500|  36.3k|                    maxLength,
  501|  36.3k|                    writeToMemory ? &value : nullptr,
  ------------------
  |  Branch (501:21): [True: 3.95k, False: 32.3k]
  ------------------
  502|  36.3k|                    spoolStream_.get());
  503|       |
  504|  36.3k|  if (spoolStream_) {
  ------------------
  |  Branch (504:7): [True: 5.45k, False: 30.8k]
  ------------------
  505|  5.45k|    LOG_DEBUG("completed spooling");
  506|  5.45k|    spoolStream_.reset();
  507|  30.8k|  } else {
  508|  30.8k|    if (!currentKey_.empty()) {
  ------------------
  |  Branch (508:9): [True: 3.85k, False: 27.0k]
  ------------------
  509|  3.85k|      LOG_DEBUG("value: \"" << value << "\"");
  510|  3.85k|      request_->parameters_[currentKey_].push_back(value);
  511|  3.85k|    }
  512|  30.8k|  }
  513|       |
  514|  36.3k|  currentKey_.clear();
  515|       |
  516|  36.3k|  if (std::string(buf_ + boundary.length(), 2) == "--")
  ------------------
  |  Branch (516:7): [True: 12, False: 36.3k]
  ------------------
  517|     12|    return false;
  518|       |
  519|  36.3k|  windBuffer(boundary.length() + 2);
  520|       |
  521|  36.3k|  return true;
  522|  36.3k|}
CgiParser.C:_ZN2Wt12_GLOBAL__N_117fishBoundaryValueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS6_:
  162|  1.17k|  {
  163|  1.17k|    std::string lower_line = Wt::Utils::lowerCase(text);
  164|       |
  165|  1.17k|    size_t pos = 0;
  166|       |
  167|  1.17k|    pos = findParam("boundary=", lower_line, pos);
  168|  1.17k|    if (pos == std::string::npos) {
  ------------------
  |  Branch (168:9): [True: 0, False: 1.17k]
  ------------------
  169|      0|      return false;
  170|      0|    }
  171|       |
  172|  1.17k|    return extractParameterValue(text, pos, result, MAX_BOUNDARY_LENGTH, " \t");
  173|  1.17k|  }
CgiParser.C:_ZN2Wt12_GLOBAL__N_19findParamERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_m:
   69|  27.7k|  {
   70|  27.7k|    if (name.empty()) {
  ------------------
  |  Branch (70:9): [True: 0, False: 27.7k]
  ------------------
   71|      0|      return pos;
   72|      0|    }
   73|       |
   74|  27.7k|    std::string stopChars {name[0], '"'};
   75|       |
   76|  96.7k|    while (pos != std::string::npos) {
  ------------------
  |  Branch (76:12): [True: 96.7k, False: 0]
  ------------------
   77|  96.7k|      pos = text.find_first_of(stopChars, pos);
   78|       |
   79|  96.7k|      if (pos == std::string::npos) {
  ------------------
  |  Branch (79:11): [True: 7.22k, False: 89.5k]
  ------------------
   80|  7.22k|        break;
   81|  7.22k|      }
   82|       |
   83|  89.5k|      if (text[pos] == '"') {
  ------------------
  |  Branch (83:11): [True: 11.2k, False: 78.3k]
  ------------------
   84|  11.2k|        pos++;
   85|       |        //ignore everything until the next quote
   86|  11.2k|        pos = text.find('"', pos);
   87|       |
   88|  11.2k|        if (pos == std::string::npos) {
  ------------------
  |  Branch (88:13): [True: 937, False: 10.3k]
  ------------------
   89|    937|          break; // Malformed quotes
   90|    937|        }
   91|       |
   92|  78.3k|      } else if (text.compare(pos, name.length(), name) == 0 &&
  ------------------
  |  Branch (92:18): [True: 21.1k, False: 57.1k]
  ------------------
   93|  21.1k|                 (pos == 0 ||
  ------------------
  |  Branch (93:19): [True: 0, False: 21.1k]
  ------------------
   94|  21.1k|                  (!::isalnum(static_cast<unsigned char>(text[pos - 1])) &&
  ------------------
  |  Branch (94:20): [True: 20.3k, False: 794]
  ------------------
   95|  20.3k|                   text[pos - 1] != '_'))) {
  ------------------
  |  Branch (95:20): [True: 19.6k, False: 718]
  ------------------
   96|       |        // parameter name found
   97|  19.6k|        return pos + name.length();
   98|  19.6k|      }
   99|       |
  100|  69.0k|      pos++;
  101|  69.0k|    }
  102|       |
  103|  8.15k|    return std::string::npos;
  104|  27.7k|  }
CgiParser.C:_ZN2Wt12_GLOBAL__N_121extractParameterValueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmRS6_mS8_:
  109|  22.4k|  {
  110|  22.4k|    size_t end_pos = pos;
  111|  22.4k|    if (text[pos] == '"') {
  ------------------
  |  Branch (111:9): [True: 12.3k, False: 10.0k]
  ------------------
  112|       |      // Handle Quoted Values
  113|  12.3k|      pos++;
  114|  12.3k|      end_pos = text.find('"', pos);
  115|  12.3k|      if (end_pos == std::string::npos) {
  ------------------
  |  Branch (115:11): [True: 693, False: 11.6k]
  ------------------
  116|    693|        return false; // Malformed quotes
  117|    693|      }
  118|  12.3k|    } else {
  119|       |      // Handle Unquoted Values
  120|  10.0k|      end_pos = text.find_first_of(terminators, pos);
  121|  10.0k|      if (end_pos == std::string::npos) {
  ------------------
  |  Branch (121:11): [True: 7.13k, False: 2.89k]
  ------------------
  122|  7.13k|        end_pos = text.length();
  123|  7.13k|      }
  124|  10.0k|    }
  125|       |
  126|  21.7k|    size_t length = end_pos - pos;
  127|       |
  128|  21.7k|    if (length == 0 || (maxLength != 0 && length > maxLength)) {
  ------------------
  |  Branch (128:9): [True: 511, False: 21.2k]
  |  Branch (128:25): [True: 12.5k, False: 8.67k]
  |  Branch (128:43): [True: 268, False: 12.2k]
  ------------------
  129|    779|      return false;
  130|    779|    }
  131|  20.9k|    result = text.substr(pos, end_pos - pos);
  132|  20.9k|    return true;
  133|  21.7k|  }
CgiParser.C:_ZN2Wt12_GLOBAL__N_18isHeaderERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_:
   60|   104k|  {
   61|   104k|    std::string lower_line = Wt::Utils::lowerCase(text);
   62|   104k|    size_t pos = lower_line.find_first_not_of(" \t");
   63|   104k|    return pos != std::string::npos && lower_line.compare(pos, name.length(), name) == 0;
  ------------------
  |  Branch (63:12): [True: 59.5k, False: 44.4k]
  |  Branch (63:40): [True: 18.5k, False: 41.0k]
  ------------------
   64|   104k|  }
CgiParser.C:_ZN2Wt12_GLOBAL__N_113fishNameValueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS6_:
  176|  15.5k|  {
  177|  15.5k|    std::string lower_line = Wt::Utils::lowerCase(text);
  178|       |
  179|  15.5k|    size_t pos = 0;
  180|       |
  181|  15.5k|    pos = findParam("name=", lower_line, pos);
  182|  15.5k|    if (pos == std::string::npos) {
  ------------------
  |  Branch (182:9): [True: 3.70k, False: 11.8k]
  ------------------
  183|  3.70k|      return false;
  184|  3.70k|    }
  185|       |
  186|  11.8k|    return extractParameterValue(text, pos, result, MAX_NAME_LENGTH);
  187|  15.5k|  }
CgiParser.C:_ZN2Wt12_GLOBAL__N_117fishFilenameValueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS6_:
  190|  11.0k|  {
  191|  11.0k|    std::string lower_line = Wt::Utils::lowerCase(text);
  192|       |
  193|  11.0k|    size_t pos = 0;
  194|       |
  195|  11.0k|    pos = findParam("filename=", lower_line, pos);
  196|  11.0k|    if (pos == std::string::npos) {
  ------------------
  |  Branch (196:9): [True: 4.45k, False: 6.63k]
  ------------------
  197|  4.45k|      return false;
  198|  4.45k|    }
  199|       |
  200|  6.63k|    bool success = extractParameterValue(text, pos, result);
  201|       |
  202|  6.63k|    if (success && result.length() > MAX_FILENAME_LENGTH) {
  ------------------
  |  Branch (202:9): [True: 6.41k, False: 225]
  |  Branch (202:20): [True: 183, False: 6.22k]
  ------------------
  203|       |      // We still want a valid filename so that the file is spooled.
  204|    183|      LOG_WARN("Received a multipart/form-data request with filename length " << result.length() << " exceeding maximum of " << MAX_FILENAME_LENGTH << ". Truncating.");
  ------------------
  |  |  501|    183|#   define LOG_WARN(m) do { \
  |  |  502|    183|    if ( WT_LOGGING("warning", WT_LOGGER)) \
  |  |  ------------------
  |  |  |  |  479|    183|#     define WT_LOGGING Wt::logging
  |  |  ------------------
  |  |                   if ( WT_LOGGING("warning", WT_LOGGER)) \
  |  |  ------------------
  |  |  |  |  478|    183|#     define WT_LOGGER Wt::logger
  |  |  ------------------
  |  |  |  Branch (502:10): [True: 183, False: 0]
  |  |  ------------------
  |  |  503|    183|      WT_LOG("warning") << WT_LOGGER << ": " << m; \
  |  |  ------------------
  |  |  |  |  477|  1.46k|#     define WT_LOG Wt::log
  |  |  ------------------
  |  |                     WT_LOG("warning") << WT_LOGGER << ": " << m; \
  |  |  ------------------
  |  |  |  |  478|    183|#     define WT_LOGGER Wt::logger
  |  |  ------------------
  |  |  504|    183|    } while(0)
  |  |  ------------------
  |  |  |  Branch (504:13): [Folded, False: 183]
  |  |  ------------------
  ------------------
  205|    183|      result = result.substr(result.length() - MAX_FILENAME_LENGTH);
  206|    183|    }
  207|       |
  208|  6.63k|    return success;
  209|  11.0k|  }
CgiParser.C:_ZN2Wt12_GLOBAL__N_120fishContentTypeValueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS6_:
  137|  3.00k|  {
  138|  3.00k|    std::string lower_line = Wt::Utils::lowerCase(text);
  139|       |
  140|  3.00k|    size_t pos = text.find_first_not_of(" \t");
  141|  3.00k|    if (pos == std::string::npos) {
  ------------------
  |  Branch (141:9): [True: 0, False: 3.00k]
  ------------------
  142|      0|      return false;
  143|      0|    }
  144|       |
  145|  3.00k|    if (pos != lower_line.find("content-type:", pos)) {
  ------------------
  |  Branch (145:9): [True: 0, False: 3.00k]
  ------------------
  146|      0|      return false;
  147|      0|    }
  148|       |
  149|       |    // Move past "content-type:"
  150|  3.00k|    pos += 13;
  151|       |
  152|       |    // Skip whitespace
  153|  3.00k|    pos = text.find_first_not_of(" \t", pos);
  154|  3.00k|    if (pos == std::string::npos) {
  ------------------
  |  Branch (154:9): [True: 203, False: 2.79k]
  ------------------
  155|    203|      return false;
  156|    203|    }
  157|       |
  158|  2.79k|    return extractParameterValue(text, pos, result);
  159|  3.00k|  }

DomElement.C:_ZN12_GLOBAL__N_117createCssNamesMapB5cxx11Ev:
  117|      2|{
  118|      2|  CssPropertyMap cssNames;
  119|      2|  Wt::Utils::insert(cssNames, Wt::Property::StylePosition, std::string("position"));
  120|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleZIndex,std::string("z-index"));
  121|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleFloat,std::string("float"));
  122|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleClear,std::string("clear"));
  123|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleWidth,std::string("width"));
  124|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleHeight,std::string("height"));
  125|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleLineHeight,std::string("line-height"));
  126|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleMinWidth,std::string("min-width"));
  127|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleMinHeight,std::string("min-height"));
  128|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleMaxWidth,std::string("max-width"));
  129|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleMaxHeight,std::string("max-height"));
  130|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleLeft,std::string("left"));
  131|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleRight,std::string("right"));
  132|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleTop,std::string("top"));
  133|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBottom,std::string("bottom"));
  134|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleVerticalAlign,std::string("vertical-align"));
  135|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleTextAlign,std::string("text-align"));
  136|      2|  Wt::Utils::insert(cssNames, Wt::Property::StylePadding,std::string("padding"));
  137|      2|  Wt::Utils::insert(cssNames, Wt::Property::StylePaddingTop,std::string("padding-top"));
  138|      2|  Wt::Utils::insert(cssNames, Wt::Property::StylePaddingRight,std::string("padding-right"));
  139|      2|  Wt::Utils::insert(cssNames, Wt::Property::StylePaddingBottom,std::string("padding-bottom"));
  140|      2|  Wt::Utils::insert(cssNames, Wt::Property::StylePaddingLeft,std::string("padding-left"));
  141|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleMargin,std::string("margin"));
  142|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleMarginTop,std::string("margin-top"));
  143|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleMarginRight,std::string("margin-right"));
  144|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleMarginBottom,std::string("margin-bottom"));
  145|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleMarginLeft,std::string("margin-left"));
  146|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleCursor,std::string("cursor"));
  147|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderTop,std::string("border-top"));
  148|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderRight,std::string("border-right"));
  149|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderBottom,std::string("border-bottom"));
  150|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderLeft,std::string("border-left"));
  151|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderColorTop,std::string("border-color-top"));
  152|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderColorRight,std::string("border-color-right"));
  153|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderColorBottom,std::string("border-color-bottom"));
  154|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderColorLeft,std::string("border-color-left"));
  155|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderWidthTop,std::string("border-width-top"));
  156|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderWidthRight,std::string("border-width-right"));
  157|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderWidthBottom,std::string("border-width-bottom"));
  158|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderWidthLeft,std::string("border-width-left"));
  159|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleColor,std::string("color"));
  160|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleOverflowX,std::string("overflow-x"));
  161|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleOverflowY,std::string("overflow-y"));
  162|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleOpacity,std::string("opacity"));
  163|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleFontFamily,std::string("font-family"));
  164|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleFontStyle,std::string("font-style"));
  165|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleFontVariant,std::string("font-variant"));
  166|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleFontWeight,std::string("font-weight"));
  167|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleFontSize,std::string("font-size"));
  168|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBackgroundColor,std::string("background-color"));
  169|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBackgroundImage,std::string("background-image"));
  170|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBackgroundRepeat,std::string("background-repeat"));
  171|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBackgroundAttachment,std::string("background-attachment"));
  172|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBackgroundPosition,std::string("background-position"));
  173|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleTextDecoration,std::string("text-decoration"));
  174|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleWhiteSpace,std::string("white-space"));
  175|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleTableLayout,std::string("table-layout"));
  176|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderSpacing,std::string("border-spacing"));
  177|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBorderCollapse,std::string("border-collapse"));
  178|      2|  Wt::Utils::insert(cssNames, Wt::Property::StylePageBreakBefore,std::string("page-break-before"));
  179|      2|  Wt::Utils::insert(cssNames, Wt::Property::StylePageBreakAfter,std::string("page-break-after"));
  180|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleZoom,std::string("zoom"));
  181|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleVisibility,std::string("visibility"));
  182|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleDisplay,std::string("display"));
  183|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleWebkitAppearance,std::string("-webkit-appearance"));
  184|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleBoxSizing,std::string("box-sizing"));
  185|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleFlex,std::string("flex"));
  186|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleFlexDirection,std::string("flex-direction"));
  187|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleFlexFlow,std::string("flex-flow"));
  188|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleAlignSelf,std::string("align-self"));
  189|      2|  Wt::Utils::insert(cssNames, Wt::Property::StyleJustifyContent,std::string("justify-content"));
  190|      2|  return cssNames;
  191|      2|}
DomElement.C:_ZN12_GLOBAL__N_122createCssCamelNamesMapB5cxx11Ev:
  196|      2|{
  197|      2|  CssPropertyMap cssCamelNames;
  198|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::Style,std::string("cssText"));
  199|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StylePosition,std::string("position"));
  200|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleZIndex,std::string("zIndex"));
  201|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleFloat,std::string("cssFloat"));
  202|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleClear,std::string("clear"));
  203|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleWidth,std::string("width"));
  204|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleHeight,std::string("height"));
  205|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleLineHeight,std::string("lineHeight"));
  206|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleMinWidth,std::string("minWidth"));
  207|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleMinHeight,std::string("minHeight"));
  208|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleMaxWidth,std::string("maxWidth"));
  209|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleMaxHeight,std::string("maxHeight"));
  210|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleLeft,std::string("left"));
  211|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleRight,std::string("right"));
  212|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleTop,std::string("top"));
  213|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBottom,std::string("bottom"));
  214|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleVerticalAlign,std::string("verticalAlign"));
  215|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleTextAlign,std::string("textAlign"));
  216|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StylePadding,std::string("padding"));
  217|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StylePaddingTop,std::string("paddingTop"));
  218|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StylePaddingRight,std::string("paddingRight"));
  219|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StylePaddingBottom,std::string("paddingBottom"));
  220|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StylePaddingLeft,std::string("paddingLeft"));
  221|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleMargin,std::string("margin"));
  222|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleMarginTop,std::string("marginTop"));
  223|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleMarginRight,std::string("marginRight"));
  224|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleMarginBottom,std::string("marginBottom"));
  225|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleMarginLeft,std::string("marginLeft"));
  226|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleCursor,std::string("cursor"));
  227|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderTop,std::string("borderTop"));
  228|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderRight,std::string("borderRight"));
  229|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderBottom,std::string("borderBottom"));
  230|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderLeft,std::string("borderLeft"));
  231|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderColorTop,std::string("borderColorTop"));
  232|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderColorRight,std::string("borderColorRight"));
  233|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderColorBottom,std::string("borderColorBottom"));
  234|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderColorLeft,std::string("borderColorLeft"));
  235|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderWidthTop,std::string("borderWidthTop"));
  236|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderWidthRight,std::string("borderWidthRight"));
  237|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderWidthBottom,std::string("borderWidthBottom"));
  238|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderWidthLeft,std::string("borderWidthLeft"));
  239|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleColor,std::string("color"));
  240|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleOverflowX,std::string("overflowX"));
  241|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleOverflowY,std::string("overflowY"));
  242|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleOpacity,std::string("opacity"));
  243|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleFontFamily,std::string("fontFamily"));
  244|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleFontStyle,std::string("fontStyle"));
  245|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleFontVariant,std::string("fontVariant"));
  246|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleFontWeight,std::string("fontWeight"));
  247|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleFontSize,std::string("fontSize"));
  248|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBackgroundColor,std::string("backgroundColor"));
  249|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBackgroundImage,std::string("backgroundImage"));
  250|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBackgroundRepeat,std::string("backgroundRepeat"));
  251|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBackgroundAttachment,std::string("backgroundAttachment"));
  252|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBackgroundPosition,std::string("backgroundPosition"));
  253|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleTextDecoration,std::string("textDecoration"));
  254|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleWhiteSpace,std::string("whiteSpace"));
  255|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleTableLayout,std::string("tableLayout"));
  256|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderSpacing,std::string("borderSpacing"));
  257|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBorderCollapse,std::string("border-collapse"));
  258|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StylePageBreakBefore,std::string("pageBreakBefore"));
  259|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StylePageBreakAfter,std::string("pageBreakAfter"));
  260|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleZoom,std::string("zoom"));
  261|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleVisibility,std::string("visibility"));
  262|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleDisplay,std::string("display"));
  263|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleWebkitAppearance,std::string("webKitAppearance"));
  264|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleBoxSizing,std::string("boxSizing"));
  265|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleFlex,std::string("flex"));
  266|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleFlexDirection,std::string("flexDirection"));
  267|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleFlexFlow,std::string("flexFlow"));
  268|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleAlignSelf,std::string("alignSelf"));
  269|      2|  Wt::Utils::insert(cssCamelNames, Wt::Property::StyleJustifyContent,std::string("justifyContent"));
  270|      2|  return cssCamelNames;
  271|      2|}

_ZN2Wt9FileUtils10getTempDirB5cxx11Ev:
  125|  5.76k|    {
  126|  5.76k|      std::string tempDir;
  127|       |
  128|  5.76k|      char *wtTmpDir = std::getenv("WT_TMP_DIR");
  129|  5.76k|      if (wtTmpDir)
  ------------------
  |  Branch (129:11): [True: 0, False: 5.76k]
  ------------------
  130|      0|      tempDir = wtTmpDir;
  131|  5.76k|      else {
  132|       |#ifdef WT_WIN32
  133|       |        char winTmpDir[MAX_PATH];
  134|       |        if(GetTempPathA(sizeof(winTmpDir), winTmpDir) != 0)
  135|       |          tempDir = winTmpDir;
  136|       |#else
  137|  5.76k|        tempDir = "/tmp";
  138|  5.76k|#endif
  139|  5.76k|      }
  140|       |
  141|  5.76k|      return tempDir;
  142|  5.76k|    }
_ZN2Wt9FileUtils18createTempFileNameB5cxx11Ev:
  145|  5.76k|    {
  146|  5.76k|      std::string tempDir = getTempDir();
  147|       |
  148|       |#ifdef WT_WIN32
  149|       |      char tmpName[MAX_PATH];
  150|       |
  151|       |      if(tempDir == ""
  152|       |         || GetTempFileNameA(tempDir.c_str(), "wt-", 0, tmpName) == 0)
  153|       |        return "";
  154|       |
  155|       |      return tmpName;
  156|       |#else
  157|  5.76k|      char* spool = new char[20 + tempDir.size()];
  158|  5.76k|      strcpy(spool, (tempDir + "/wtXXXXXX").c_str());
  159|       |
  160|  5.76k|      int i = mkstemp(spool);
  161|  5.76k|      close(i);
  162|       |
  163|  5.76k|      std::string returnSpool = spool;
  164|  5.76k|      delete [] spool;
  165|  5.76k|      return returnSpool;
  166|  5.76k|#endif
  167|  5.76k|    }

_ZN2Wt10WebRequestC2Ev:
   79|  2.44k|  : entryPoint_(nullptr),
   80|  2.44k|    extraStartIndex_(0),
   81|  2.44k|    async_(nullptr),
   82|  2.44k|    responseType_(ResponseType::Page),
   83|  2.44k|    webSocketRequest_(false)
   84|  2.44k|{
   85|  2.44k|#ifndef BENCH
   86|  2.44k|  start_ = std::chrono::high_resolution_clock::now();
   87|  2.44k|#endif
   88|  2.44k|}
_ZN2Wt10WebRequestD2Ev:
   91|  2.44k|{
   92|  2.44k|  delete async_;
   93|  2.44k|  log();
   94|  2.44k|}
_ZN2Wt10WebRequest3logEv:
   97|  2.44k|{
   98|  2.44k|#ifndef BENCH
   99|  2.44k|  if (start_.time_since_epoch().count() > 0) {
  ------------------
  |  Branch (99:7): [True: 2.44k, False: 0]
  ------------------
  100|  2.44k|    auto end = std::chrono::high_resolution_clock::now();
  101|  2.44k|    double microseconds
  102|  2.44k|      = std::chrono::duration_cast<std::chrono::microseconds>(end - start_)
  103|  2.44k|      .count();
  104|  2.44k|    LOG_INFO("took " << (microseconds / 1000) << " ms");
  ------------------
  |  |  496|  2.44k|#   define LOG_INFO(m) do { \
  |  |  497|  2.44k|    if ( WT_LOGGING("info", WT_LOGGER)) \
  |  |  ------------------
  |  |  |  |  479|  2.44k|#     define WT_LOGGING Wt::logging
  |  |  ------------------
  |  |                   if ( WT_LOGGING("info", WT_LOGGER)) \
  |  |  ------------------
  |  |  |  |  478|  2.44k|#     define WT_LOGGER Wt::logger
  |  |  ------------------
  |  |  |  Branch (497:10): [True: 2.44k, False: 0]
  |  |  ------------------
  |  |  498|  2.44k|      WT_LOG("info") << WT_LOGGER << ": " << m; \
  |  |  ------------------
  |  |  |  |  477|  14.6k|#     define WT_LOG Wt::log
  |  |  ------------------
  |  |                     WT_LOG("info") << WT_LOGGER << ": " << m; \
  |  |  ------------------
  |  |  |  |  478|  2.44k|#     define WT_LOGGER Wt::logger
  |  |  ------------------
  |  |  499|  2.44k|    }  while(0)
  |  |  ------------------
  |  |  |  Branch (499:14): [Folded, False: 2.44k]
  |  |  ------------------
  ------------------
  105|       |
  106|  2.44k|    start_ = std::chrono::high_resolution_clock::time_point();
  107|  2.44k|  }
  108|  2.44k|#endif
  109|  2.44k|}

_ZN2Wt10WebSession7Handler8instanceEv:
  901|  14.0k|{
  902|       |#ifdef WT_TARGET_JAVA
  903|       |  return threadHandler_.get();
  904|       |#else
  905|  14.0k|  return threadHandler_;
  906|  14.0k|#endif
  907|  14.0k|}
_ZN2Wt10WebSession8instanceEv:
 1172|  14.0k|{
 1173|  14.0k|  Handler *handler = WebSession::Handler::instance();
 1174|  14.0k|  return handler ? handler->session() : nullptr;
  ------------------
  |  Branch (1174:10): [True: 0, False: 14.0k]
  ------------------
 1175|  14.0k|}

_ZN2Wt5Utils9lowerCaseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  102|   134k|{
  103|   134k|  std::string result = s;
  104|  5.81M|  for (unsigned i = 0; i < result.length(); ++i)
  ------------------
  |  Branch (104:24): [True: 5.68M, False: 134k]
  ------------------
  105|  5.68M|    result[i] = tolower(result[i]);
  106|   134k|  return result;
  107|   134k|}
_ZN2Wt5Utils4itoaEiPci:
  157|  4.59k|char *itoa(int value, char *result, int base) {
  158|  4.59k|  char* out = result;
  159|  4.59k|  int quotient = value;
  160|       |
  161|  4.59k|  if (quotient < 0)
  ------------------
  |  Branch (161:7): [True: 0, False: 4.59k]
  ------------------
  162|      0|    quotient = -quotient;
  163|       |
  164|  13.9k|  do {
  165|  13.9k|    *out =
  166|  13.9k|      "0123456789abcdefghijklmnopqrstuvwxyz"[quotient % base];
  167|  13.9k|    ++out;
  168|  13.9k|    quotient /= base;
  169|  13.9k|  } while (quotient);
  ------------------
  |  Branch (169:12): [True: 9.37k, False: 4.59k]
  ------------------
  170|       |
  171|  4.59k|  if (value < 0 && base == 10)
  ------------------
  |  Branch (171:7): [True: 0, False: 4.59k]
  |  Branch (171:20): [True: 0, False: 0]
  ------------------
  172|      0|    *out++ = '-';
  173|       |
  174|  4.59k|  std::reverse(result, out);
  175|  4.59k|  *out = 0;
  176|       |
  177|  4.59k|  return result;
  178|  4.59k|}
_ZN2Wt5Utils16inplaceUrlDecodeERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  376|   274k|{
  377|       |  // Note: there is a Java-too duplicate of this function in Wt/Utils.C
  378|   274k|  std::size_t j = 0;
  379|       |
  380|  3.38M|  for (std::size_t i = 0; i < text.length(); ++i) {
  ------------------
  |  Branch (380:27): [True: 3.10M, False: 274k]
  ------------------
  381|  3.10M|    char c = text[i];
  382|       |
  383|  3.10M|    if (c == '+') {
  ------------------
  |  Branch (383:9): [True: 621, False: 3.10M]
  ------------------
  384|    621|      text[j++] = ' ';
  385|  3.10M|    } else if (c == '%' && i + 2 < text.length()) {
  ------------------
  |  Branch (385:16): [True: 95.8k, False: 3.00M]
  |  Branch (385:28): [True: 94.3k, False: 1.51k]
  ------------------
  386|  94.3k|      std::string h = text.substr(i + 1, 2);
  387|  94.3k|      char *e = 0;
  388|  94.3k|      int hval = std::strtol(h.c_str(), &e, 16);
  389|       |
  390|  94.3k|      if (*e == 0) {
  ------------------
  |  Branch (390:11): [True: 1.09k, False: 93.2k]
  ------------------
  391|  1.09k|        text[j++] = (char)hval;
  392|  1.09k|        i += 2;
  393|  93.2k|      } else {
  394|       |        // not a proper %XX with XX hexadecimal format
  395|  93.2k|        text[j++] = c;
  396|  93.2k|      }
  397|  94.3k|    } else
  398|  3.01M|      text[j++] = c;
  399|  3.10M|  }
  400|       |
  401|   274k|  text.erase(j);
  402|   274k|}

_ZN2Wt5Utils6insertINS_8PropertyENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEvRSt13unordered_mapIT_T0_St4hashISA_ESt8equal_toISA_ESaISt4pairIKSA_SB_EEERSH_RKSB_:
  260|    286|{
  261|    286|#ifndef WT_TARGET_JAVA
  262|    286|  m.insert(std::make_pair(key, value));
  263|    286|#endif // WT_TARGET_JAVA
  264|    286|}