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

_ZN2Wt4Http12UploadedFileC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_S9_:
   47|  4.38k|{
   48|  4.38k|  fileInfo_.reset(new Impl());
   49|       |
   50|  4.38k|  fileInfo_->spoolFileName = spoolName;
   51|  4.38k|  fileInfo_->clientFileName = clientFileName;
   52|  4.38k|  fileInfo_->contentType = contentType;
   53|  4.38k|  fileInfo_->isStolen = false;
   54|  4.38k|}
_ZN2Wt4Http12UploadedFile4Impl7cleanupEv:
   57|  4.38k|{
   58|  4.38k|  if (!isStolen)
  ------------------
  |  Branch (58:7): [True: 4.38k, False: 0]
  ------------------
   59|  4.38k|    unlink(spoolFileName.c_str());
   60|  4.38k|}
_ZN2Wt4Http12UploadedFile4ImplD2Ev:
   63|  4.38k|{
   64|  4.38k|  cleanup();
   65|  4.38k|}
_ZN2Wt4Http7Request19parseFormUrlEncodedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERSt3mapIS7_St6vectorIS7_SaIS7_EESt4lessIS7_ESaISt4pairIS8_SD_EEE:
  399|  1.16k|{
  400|   234k|  for (std::size_t pos = 0; pos < s.length();) {
  ------------------
  |  Branch (400:29): [True: 233k, False: 1.16k]
  ------------------
  401|   233k|    std::size_t next = s.find_first_of("&=", pos);
  402|       |
  403|   233k|    if (next == pos && s[next] == '&') {
  ------------------
  |  Branch (403:9): [True: 54.7k, False: 178k]
  |  Branch (403:24): [True: 28.2k, False: 26.5k]
  ------------------
  404|       |      // skip empty
  405|  28.2k|      pos = next + 1;
  406|  28.2k|      continue;
  407|  28.2k|    }
  408|       |
  409|   204k|    if (next == std::string::npos || s[next] == '&') {
  ------------------
  |  Branch (409:9): [True: 780, False: 204k]
  |  Branch (409:38): [True: 129k, False: 74.5k]
  ------------------
  410|   130k|      if (next == std::string::npos)
  ------------------
  |  Branch (410:11): [True: 780, False: 129k]
  ------------------
  411|    780|        next = s.length();
  412|   130k|      std::string key = s.substr(pos, next - pos);
  413|   130k|      Utils::inplaceUrlDecode(key);
  414|   130k|      parameters[key].push_back(std::string());
  415|   130k|      pos = next + 1;
  416|   130k|    } else {
  417|  74.5k|      std::size_t amp = s.find('&', next + 1);
  418|  74.5k|      if (amp == std::string::npos)
  ------------------
  |  Branch (418:11): [True: 261, False: 74.2k]
  ------------------
  419|    261|        amp = s.length();
  420|       |
  421|  74.5k|      std::string key = s.substr(pos, next - pos);
  422|  74.5k|      Utils::inplaceUrlDecode(key);
  423|       |
  424|  74.5k|      std::string value = s.substr(next + 1, amp - (next + 1));
  425|  74.5k|      Utils::inplaceUrlDecode(value);
  426|       |
  427|  74.5k|      parameters[key].push_back(value);
  428|  74.5k|      pos = amp + 1;
  429|  74.5k|    }
  430|   204k|  }
  431|  1.16k|}

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

_ZN2Wt4Json6ObjectC2Ev:
   17|      2|{ }

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

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

_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|  2.13k|{
   39|  2.13k|  if (impl_) {
  ------------------
  |  Branch (39:7): [True: 2.13k, False: 0]
  ------------------
   40|  2.13k|    impl_->finish();
   41|  2.13k|    if (impl_->logger_)
  ------------------
  |  Branch (41:9): [True: 2.13k, False: 0]
  ------------------
   42|  2.13k|      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|  2.13k|  }
   46|  2.13k|}
_ZN2Wt9WLogEntrylsEPKc:
   67|  8.55k|{
   68|  8.55k|  return *this << std::string(s);
   69|  8.55k|}
_ZN2Wt9WLogEntrylsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
   79|  8.55k|{
   80|  8.55k|  if (impl_) {
  ------------------
  |  Branch (80:7): [True: 8.55k, False: 0]
  ------------------
   81|  8.55k|    if (impl_->quote()) {
  ------------------
  |  Branch (81:9): [True: 0, False: 8.55k]
  ------------------
   82|      0|      startField();
   83|       |
   84|      0|      std::string ss(s);
   85|      0|      Utils::replace(ss, '"', "\"\"");
   86|       |
   87|      0|      impl_->line_ << ss;
   88|  8.55k|    } else {
   89|  8.55k|      if (!s.empty()) {
  ------------------
  |  Branch (89:11): [True: 8.55k, False: 0]
  ------------------
   90|  8.55k|        startField();
   91|  8.55k|        impl_->line_ << s;
   92|  8.55k|      }
   93|  8.55k|    }
   94|       |
   95|  8.55k|    if ((impl_->customLogger_ ||
  ------------------
  |  Branch (95:10): [True: 0, False: 8.55k]
  ------------------
   96|  8.55k|         impl_->field_ == (int)impl_->logger_->fields().size() - 1)
  ------------------
  |  Branch (96:10): [True: 0, False: 8.55k]
  ------------------
   97|      0|        && impl_->scope_.empty())
  ------------------
  |  Branch (97:12): [True: 0, False: 0]
  ------------------
   98|      0|      impl_->scope_ = s;
   99|  8.55k|  }
  100|       |
  101|  8.55k|  return *this;
  102|  8.55k|}
_ZN2Wt9WLogEntrylsEd:
  135|  2.13k|{
  136|  2.13k|  startField();
  137|       |
  138|  2.13k|  if (impl_)
  ------------------
  |  Branch (138:7): [True: 2.13k, False: 0]
  ------------------
  139|  2.13k|    impl_->line_ << v;
  140|       |
  141|  2.13k|  return *this;
  142|  2.13k|}
_ZN2Wt9WLogEntryC2ERKNS_7WLoggerERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEb:
  146|  2.13k|{
  147|  2.13k|  if (!mute)
  ------------------
  |  Branch (147:7): [True: 2.13k, False: 0]
  ------------------
  148|  2.13k|    impl_.reset(new Impl(logger, type));
  149|  2.13k|}
_ZN2Wt9WLogEntry10startFieldEv:
  158|  10.6k|{
  159|  10.6k|  if (impl_)
  ------------------
  |  Branch (159:7): [True: 10.6k, False: 0]
  ------------------
  160|  10.6k|    impl_->startField();
  161|  10.6k|}
_ZN2Wt9WLogEntry4ImplC2ERKNS_7WLoggerERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  164|  2.13k|  : logger_(&logger),
  165|  2.13k|    customLogger_(nullptr),
  166|  2.13k|    type_(type),
  167|  2.13k|    field_(0),
  168|  2.13k|    fieldStarted_(false)
  169|  2.13k|{ }
_ZN2Wt9WLogEntry4Impl10startFieldEv:
  181|  10.6k|{
  182|  10.6k|  if (!fieldStarted_) {
  ------------------
  |  Branch (182:7): [True: 2.13k, False: 8.55k]
  ------------------
  183|  2.13k|    if (quote())
  ------------------
  |  Branch (183:9): [True: 0, False: 2.13k]
  ------------------
  184|      0|      line_ << '"';
  185|  2.13k|    fieldStarted_ = true;
  186|  2.13k|  }
  187|  10.6k|}
_ZN2Wt9WLogEntry4Impl11finishFieldEv:
  190|  2.13k|{
  191|  2.13k|  if (fieldStarted_) {
  ------------------
  |  Branch (191:7): [True: 2.13k, False: 0]
  ------------------
  192|  2.13k|    if (quote())
  ------------------
  |  Branch (192:9): [True: 0, False: 2.13k]
  ------------------
  193|      0|      line_ << '"';
  194|  2.13k|  } else
  195|      0|    line_ << '-';
  196|  2.13k|}
_ZN2Wt9WLogEntry4Impl6finishEv:
  208|  2.13k|{
  209|  2.13k|  if (!customLogger_) {
  ------------------
  |  Branch (209:7): [True: 2.13k, False: 0]
  ------------------
  210|  2.13k|    while (field_ < (int)logger_->fields().size() - 1)
  ------------------
  |  Branch (210:12): [True: 0, False: 2.13k]
  ------------------
  211|      0|      nextField();
  212|  2.13k|  }
  213|       |
  214|  2.13k|  finishField();
  215|  2.13k|}
_ZNK2Wt9WLogEntry4Impl5quoteEv:
  218|  12.8k|{
  219|  12.8k|  if (customLogger_)
  ------------------
  |  Branch (219:7): [True: 0, False: 12.8k]
  ------------------
  220|      0|    return false;
  221|  12.8k|  else if (field_ < (int)logger_->fields().size())
  ------------------
  |  Branch (221:12): [True: 0, False: 12.8k]
  ------------------
  222|      0|    return logger_->fields()[field_].isString();
  223|  12.8k|  else
  224|  12.8k|    return false;
  225|  12.8k|}
_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|  2.13k|{
  312|  2.13k|  return WLogEntry(*this, type, !logging(type));
  313|  2.13k|}
_ZNK2Wt7WLogger7addLineERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_RKNS_13WStringStreamE:
  317|  2.13k|{
  318|  2.13k|  if (logging(type, scope)) {
  ------------------
  |  Branch (318:7): [True: 2.13k, False: 0]
  ------------------
  319|  2.13k|    std::unique_lock<std::mutex> l;
  320|  2.13k|    if (useLock_) {
  ------------------
  |  Branch (320:9): [True: 2.13k, False: 0]
  ------------------
  321|  2.13k|      l = std::unique_lock<std::mutex>(addLineLock_);
  322|  2.13k|    }
  323|       |
  324|  2.13k|    if (o_) {
  ------------------
  |  Branch (324:9): [True: 2.13k, False: 0]
  ------------------
  325|  2.13k|      *o_ << s.str() << std::endl;
  326|  2.13k|    }
  327|  2.13k|  }
  328|  2.13k|}
_ZNK2Wt7WLogger7loggingERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  363|  2.13k|{
  364|  2.13k|  return logging(type.c_str());
  365|  2.13k|}
_ZNK2Wt7WLogger7loggingEPKc:
  368|  2.13k|{
  369|  2.13k|  bool result = false;
  370|       |
  371|  6.41k|  for (unsigned i = 0; i < rules_.size(); ++i)
  ------------------
  |  Branch (371:24): [True: 4.27k, False: 2.13k]
  ------------------
  372|  4.27k|    if (rules_[i].type == "*" || rules_[i].type == type) {
  ------------------
  |  Branch (372:9): [True: 2.13k, False: 2.13k]
  |  Branch (372:34): [True: 0, False: 2.13k]
  ------------------
  373|  2.13k|      if (rules_[i].scope == "*")
  ------------------
  |  Branch (373:11): [True: 2.13k, False: 0]
  ------------------
  374|  2.13k|        result = rules_[i].include;
  375|      0|      else if (rules_[i].include)
  ------------------
  |  Branch (375:16): [True: 0, False: 0]
  ------------------
  376|      0|        result = true;
  377|  2.13k|    }
  378|       |
  379|  2.13k|  return result;
  380|  2.13k|}
_ZNK2Wt7WLogger7loggingERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_:
  383|  4.27k|{
  384|  4.27k|  bool result = false;
  385|       |
  386|  12.8k|  for (unsigned i = 0; i < rules_.size(); ++i)
  ------------------
  |  Branch (386:24): [True: 8.55k, False: 4.27k]
  ------------------
  387|  8.55k|    if (rules_[i].type == "*" || rules_[i].type == type)
  ------------------
  |  Branch (387:9): [True: 4.27k, False: 4.27k]
  |  Branch (387:34): [True: 0, False: 4.27k]
  ------------------
  388|  4.27k|      if (rules_[i].scope == "*" || rules_[i].scope == scope)
  ------------------
  |  Branch (388:11): [True: 4.27k, False: 0]
  |  Branch (388:37): [True: 0, False: 0]
  ------------------
  389|  4.27k|        result = rules_[i].include;
  390|       |
  391|  4.27k|  return result;
  392|  4.27k|}
_ZN2Wt7loggingERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_:
  421|  2.13k|{
  422|       |#ifdef WT_DBO_LOGGER
  423|       |  if (customLogger_)
  424|       |    return customLogger_->logging(type, scope);
  425|       |
  426|       |  return true;
  427|       |#else // WT_DBO_LOGGER
  428|  2.13k|  WebSession *session = WebSession::instance();
  429|       |
  430|  2.13k|  Wt::WServer *server = session ? session->controller()->server() : WServer::instance();
  ------------------
  |  Branch (430:25): [True: 0, False: 2.13k]
  ------------------
  431|  2.13k|  if (server) {
  ------------------
  |  Branch (431:7): [True: 0, False: 2.13k]
  ------------------
  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|  2.13k|  } else {
  437|  2.13k|    return defaultLogger.logging(type, scope);
  438|  2.13k|  }
  439|  2.13k|#endif // WT_DBO_LOGGER
  440|  2.13k|}
_ZN2Wt3logERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  443|  2.13k|{
  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|  2.13k|  WebSession *session = WebSession::instance();
  452|       |
  453|  2.13k|  if (session)
  ------------------
  |  Branch (453:7): [True: 0, False: 2.13k]
  ------------------
  454|      0|    return session->log(type);
  455|  2.13k|  else {
  456|  2.13k|    WServer *server = WServer::instance();
  457|       |
  458|  2.13k|    if (server)
  ------------------
  |  Branch (458:9): [True: 0, False: 2.13k]
  ------------------
  459|      0|      return server->log(type);
  460|  2.13k|    else
  461|  2.13k|      return defaultLogger.entry(type);
  462|  2.13k|  }
  463|  2.13k|#endif // WT_DBO_LOGGER
  464|  2.13k|}

_ZNK2Wt7WLogger6fieldsEv:
  219|  23.5k|  const std::vector<Field>& fields() const { return fields_; }

_ZN2Wt7WServer8instanceEv:
  226|  4.27k|  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|  2.13k|  : sink_(0),
   35|  2.13k|    buf_(static_buf_),
   36|  2.13k|    buf_i_(0)
   37|  2.13k|{ }
_ZN2Wt13WStringStreamD2Ev:
   53|  2.13k|{
   54|  2.13k|  flushSink();
   55|       |
   56|  2.13k|  clear();
   57|  2.13k|}
_ZN2Wt13WStringStream5clearEv:
   60|  2.13k|{
   61|  2.13k|  buf_i_ = 0;
   62|       |
   63|  2.13k|  for (unsigned int i = 0; i < bufs_.size(); ++i)
  ------------------
  |  Branch (63:28): [True: 0, False: 2.13k]
  ------------------
   64|      0|    if (bufs_[i].first != static_buf_)
  ------------------
  |  Branch (64:9): [True: 0, False: 0]
  ------------------
   65|      0|      delete[] bufs_[i].first;
   66|       |
   67|  2.13k|  bufs_.clear();
   68|       |
   69|  2.13k|  if (buf_ != static_buf_)
  ------------------
  |  Branch (69:7): [True: 0, False: 2.13k]
  ------------------
   70|      0|    delete[] buf_;
   71|       |
   72|  2.13k|  buf_ = static_buf_;
   73|  2.13k|}
_ZNK2Wt13WStringStream6lengthEv:
   81|  2.13k|{
   82|  2.13k|  std::size_t result = buf_i_;
   83|       |
   84|  2.13k|  for (unsigned int i = 0; i < bufs_.size(); ++i)
  ------------------
  |  Branch (84:28): [True: 0, False: 2.13k]
  ------------------
   85|      0|    result += bufs_[i].second;
   86|       |
   87|  2.13k|  return result;
   88|  2.13k|}
_ZN2Wt13WStringStream9flushSinkEv:
   91|  2.13k|{
   92|  2.13k|  if (sink_) {
  ------------------
  |  Branch (92:7): [True: 0, False: 2.13k]
  ------------------
   93|      0|    sink_->write(buf_, buf_i_);
   94|      0|    buf_i_ = 0;
   95|      0|  }
   96|  2.13k|}
_ZN2Wt13WStringStreamlsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  124|  8.55k|{
  125|  8.55k|  append(s.data(), s.length());
  126|       |
  127|  8.55k|  return *this;
  128|  8.55k|}
_ZN2Wt13WStringStreamlsEd:
  160|  2.13k|{
  161|  2.13k|  char buf[50];
  162|  2.13k|  snprintf(buf, 50, "%g", d);
  163|  2.13k|  return *this << buf;
  164|  2.13k|}
_ZN2Wt13WStringStream6appendEPKci:
  167|  10.6k|{
  168|  10.6k|  if (buf_i_ + length > buf_len()) {
  ------------------
  |  Branch (168:7): [True: 0, False: 10.6k]
  ------------------
  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|  10.6k|  std::memcpy(buf_ + buf_i_, s, length);
  185|  10.6k|  buf_i_ += length;
  186|  10.6k|}
_ZNK2Wt13WStringStream3strB5cxx11Ev:
  198|  2.13k|{
  199|  2.13k|  std::string result;
  200|  2.13k|  result.reserve(length());
  201|       |
  202|  2.13k|  for (unsigned int i = 0; i < bufs_.size(); ++i)
  ------------------
  |  Branch (202:28): [True: 0, False: 2.13k]
  ------------------
  203|      0|    result.append(bufs_[i].first, bufs_[i].second);
  204|       |
  205|  2.13k|  result.append(buf_, buf_i_);
  206|       |
  207|  2.13k|  return result;
  208|  2.13k|}

_ZN2Wt13WStringStreamlsEPKc:
  119|  2.13k|  {
  120|  2.13k|    append(s, std::strlen(s));
  121|       |
  122|  2.13k|    return *this;
  123|  2.13k|  }
_ZNK2Wt13WStringStream7buf_lenEv:
  219|  10.6k|    { return buf_ == static_buf_ ? static_cast<int>(S_LEN)
  ------------------
  |  Branch (219:14): [True: 10.6k, False: 0]
  ------------------
  220|  10.6k|        : 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:
   85|  2.13k|  : maxFormData_(maxFormData),
   86|  2.13k|    maxRequestSize_(maxRequestSize)
   87|  2.13k|{ }
_ZN2Wt9CgiParser5parseERNS_10WebRequestENS0_10ReadOptionE:
   90|  2.13k|{
   91|       |  /*
   92|       |   * TODO: optimize this ...
   93|       |   */
   94|  2.13k|  request_ = &request;
   95|       |
   96|  2.13k|  ::int64_t len = request.contentLength();
   97|  2.13k|  const char *type = request.contentType();
   98|  2.13k|  const char *meth = request.requestMethod();
   99|       |
  100|  2.13k|  request.postDataExceeded_ = (len > maxRequestSize_ ? len : 0);
  ------------------
  |  Branch (100:32): [True: 0, False: 2.13k]
  ------------------
  101|       |
  102|  2.13k|  std::string queryString = request.queryString();
  103|       |
  104|  2.13k|  LOG_DEBUG("queryString (len=" << len << "): " << queryString);
  105|       |
  106|  2.13k|  if (!queryString.empty() && request_->parameters_.empty()) {
  ------------------
  |  Branch (106:7): [True: 0, False: 2.13k]
  |  Branch (106:31): [True: 0, False: 0]
  ------------------
  107|      0|    Http::Request::parseFormUrlEncoded(queryString, request_->parameters_);
  108|      0|  }
  109|       |
  110|       |  // XDomainRequest cannot set a contentType header, we therefore pass it
  111|       |  // as a request parameter
  112|  2.13k|  if (readOption != ReadHeadersOnly &&
  ------------------
  |  Branch (112:7): [True: 2.13k, False: 0]
  ------------------
  113|  2.13k|      strcmp(meth, "POST") == 0 &&
  ------------------
  |  Branch (113:7): [True: 2.13k, False: 0]
  ------------------
  114|  2.13k|      ((type && strstr(type, "application/x-www-form-urlencoded") == type) ||
  ------------------
  |  Branch (114:9): [True: 2.13k, False: 0]
  |  Branch (114:17): [True: 1.15k, False: 979]
  ------------------
  115|    979|       (queryString.find("&contentType=x-www-form-urlencoded") !=
  ------------------
  |  Branch (115:8): [True: 0, False: 979]
  ------------------
  116|  1.15k|        std::string::npos))) {
  117|       |    /*
  118|       |     * TODO: parse this stream-based to avoid the malloc here. For now
  119|       |     * we protect the maximum that can be POST'ed as form data.
  120|       |     */
  121|  1.15k|    if (len > maxFormData_)
  ------------------
  |  Branch (121:9): [True: 0, False: 1.15k]
  ------------------
  122|      0|      throw WException("Oversized application/x-www-form-urlencoded ("
  123|      0|                       + std::to_string(len) + ")");
  124|       |
  125|  1.15k|    auto buf = std::unique_ptr<char[]>(new char[len + 1]);
  126|       |
  127|  1.15k|    request.in().read(buf.get(), len);
  128|       |
  129|  1.15k|    if (request.in().gcount() != (int)len) {
  ------------------
  |  Branch (129:9): [True: 0, False: 1.15k]
  ------------------
  130|      0|      throw WException("Unexpected short read.");
  131|      0|    }
  132|       |
  133|  1.15k|    buf[len] = 0;
  134|       |
  135|       |    // This is a special Wt feature, I do not think it standard.
  136|       |    // For POST, parameters in url-encoded URL are still parsed.
  137|       |
  138|  1.15k|    std::string formQueryString = buf.get();
  139|       |
  140|  1.15k|    LOG_DEBUG("formQueryString (len=" << len << "): " << formQueryString);
  141|  1.15k|    if (!formQueryString.empty()) {
  ------------------
  |  Branch (141:9): [True: 1.14k, False: 10]
  ------------------
  142|  1.14k|      Http::Request::parseFormUrlEncoded(formQueryString, request_->parameters_);
  143|  1.14k|    }
  144|  1.15k|    Http::ParameterMap::const_iterator it = request_->parameters_.find("Wt-params");
  145|  1.15k|    if (it != request_->parameters_.end() && it->second.size() == 1) {
  ------------------
  |  Branch (145:9): [True: 21, False: 1.13k]
  |  Branch (145:9): [True: 11, False: 1.14k]
  |  Branch (145:46): [True: 11, False: 10]
  ------------------
  146|     11|      Http::Request::parseFormUrlEncoded(it->second[0], request_->parameters_);
  147|     11|    }
  148|  1.15k|  }
  149|       |
  150|  2.13k|  if (readOption != ReadHeadersOnly &&
  ------------------
  |  Branch (150:7): [True: 2.13k, False: 0]
  ------------------
  151|  2.13k|      type && strstr(type, "multipart/form-data") == type) {
  ------------------
  |  Branch (151:7): [True: 2.13k, False: 0]
  |  Branch (151:15): [True: 979, False: 1.15k]
  ------------------
  152|    979|    if (strcmp(meth, "POST") != 0) {
  ------------------
  |  Branch (152:9): [True: 0, False: 979]
  ------------------
  153|      0|      throw WException("Invalid method for multipart/form-data: "
  154|      0|                       + std::string(meth));
  155|      0|    }
  156|       |
  157|    979|    if (!request.postDataExceeded_)
  ------------------
  |  Branch (157:9): [True: 979, False: 0]
  ------------------
  158|    979|      readMultipartData(request, type, len);
  159|      0|    else if (readOption == ReadBodyAnyway) {
  ------------------
  |  Branch (159:14): [True: 0, False: 0]
  ------------------
  160|      0|      for (;len > 0;) {
  ------------------
  |  Branch (160:13): [True: 0, False: 0]
  ------------------
  161|      0|        ::int64_t toRead = std::min(::int64_t(BUFSIZE), len);
  162|      0|        request.in().read(buf_, toRead);
  163|      0|        if (request.in().gcount() != (::int64_t)toRead)
  ------------------
  |  Branch (163:13): [True: 0, False: 0]
  ------------------
  164|      0|          throw WException("CgiParser: short read");
  165|      0|        len -= toRead;
  166|      0|      }
  167|      0|    }
  168|    979|  }
  169|  2.13k|}
_ZN2Wt9CgiParser17readMultipartDataERNS_10WebRequestENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEl:
  173|    979|{
  174|    979|  std::string boundary;
  175|       |
  176|    979|  if (!fishValue(type, boundary_e, boundary))
  ------------------
  |  Branch (176:7): [True: 0, False: 979]
  ------------------
  177|      0|    throw WException("Could not find a boundary for multipart data.");
  178|       |
  179|    979|  boundary = "--" + boundary;
  180|       |
  181|    979|  buflen_ = 0;
  182|    979|  left_ = len;
  183|    979|  spoolStream_ = 0;
  184|    979|  currentKey_.clear();
  185|       |
  186|    979|  if (!parseBody(request, boundary))
  ------------------
  |  Branch (186:7): [True: 1, False: 978]
  ------------------
  187|      1|    return;
  188|       |
  189|  38.3k|  for (;;) {
  190|  38.3k|    if (!parseHead(request))
  ------------------
  |  Branch (190:9): [True: 0, False: 38.3k]
  ------------------
  191|      0|      break;
  192|  38.3k|    if (!parseBody(request,boundary))
  ------------------
  |  Branch (192:9): [True: 44, False: 38.3k]
  ------------------
  193|     44|      break;
  194|  38.3k|  }
  195|    978|}
_ZN2Wt9CgiParser17readUntilBoundaryERNS_10WebRequestENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiPS8_PSo:
  209|  77.5k|{
  210|  77.5k|  int bpos;
  211|       |
  212|  78.8k|  while ((bpos = index(boundary)) == -1) {
  ------------------
  |  Branch (212:10): [True: 2.20k, False: 76.6k]
  ------------------
  213|       |    /*
  214|       |     * If we couldn't find it. We need to wind the buffer, but only save
  215|       |     * not including the boundary length.
  216|       |     */
  217|  2.20k|    if (left_ == 0)
  ------------------
  |  Branch (217:9): [True: 927, False: 1.27k]
  ------------------
  218|    927|      throw WException("CgiParser: reached end of input while seeking end of "
  219|    927|                       "headers or content. Format of CGI input is wrong");
  220|       |
  221|       |    /* save (up to) BUFSIZE from buffer to file or value string, but
  222|       |     * mind the boundary length */
  223|  1.27k|    int save = std::min((buflen_ - (int)boundary.length()), (int)BUFSIZE);
  224|       |
  225|  1.27k|    if (save > 0) {
  ------------------
  |  Branch (225:9): [True: 225, False: 1.04k]
  ------------------
  226|    225|      if (resultString)
  ------------------
  |  Branch (226:11): [True: 152, False: 73]
  ------------------
  227|    152|        *resultString += std::string(buf_, save);
  228|    225|      if (resultFile)
  ------------------
  |  Branch (228:11): [True: 23, False: 202]
  ------------------
  229|     23|        resultFile->write(buf_, save);
  230|       |
  231|       |      /* wind buffer */
  232|    225|      windBuffer(save);
  233|    225|    }
  234|       |
  235|  1.27k|    unsigned amt = static_cast<unsigned>
  236|  1.27k|      (std::min(left_,
  237|  1.27k|                static_cast< ::int64_t >(BUFSIZE + MAXBOUND - buflen_)));
  238|       |
  239|  1.27k|    request.in().read(buf_ + buflen_, amt);
  240|  1.27k|    if (request.in().gcount() != (int)amt)
  ------------------
  |  Branch (240:9): [True: 0, False: 1.27k]
  ------------------
  241|      0|      throw WException("CgiParser: short read");
  242|       |
  243|  1.27k|    left_ -= amt;
  244|  1.27k|    buflen_ += amt;
  245|  1.27k|  }
  246|       |
  247|  76.6k|  if (resultString)
  ------------------
  |  Branch (247:7): [True: 43.9k, False: 32.6k]
  ------------------
  248|  43.9k|    *resultString += std::string(buf_, bpos - tossAtBoundary);
  249|  76.6k|  if (resultFile)
  ------------------
  |  Branch (249:7): [True: 4.16k, False: 72.4k]
  ------------------
  250|  4.16k|    resultFile->write(buf_, bpos - tossAtBoundary);
  251|       |
  252|       |  /* wind buffer */
  253|  76.6k|  windBuffer(bpos);
  254|  76.6k|}
_ZN2Wt9CgiParser10windBufferEi:
  257|   153k|{
  258|   153k|  if (offset < buflen_) {
  ------------------
  |  Branch (258:7): [True: 153k, False: 183]
  ------------------
  259|   153k|    memmove(buf_, buf_ + offset, buflen_ - offset);
  260|   153k|    buflen_ -= offset;
  261|   153k|  } else
  262|    183|    buflen_ = 0;
  263|   153k|}
_ZN2Wt9CgiParser5indexENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  266|  78.8k|{
  267|  78.8k|  std::string bufS = std::string(buf_, buflen_);
  268|       |
  269|  78.8k|  std::string::size_type i = bufS.find(search);
  270|       |
  271|  78.8k|  if (i == std::string::npos)
  ------------------
  |  Branch (271:7): [True: 2.20k, False: 76.6k]
  ------------------
  272|  2.20k|    return -1;
  273|  76.6k|  else
  274|  76.6k|    return i;
  275|  78.8k|}
_ZN2Wt9CgiParser9parseHeadERNS_10WebRequestE:
  278|  38.3k|{
  279|  38.3k|  std::string head;
  280|  38.3k|  readUntilBoundary(request, "\r\n\r\n", -2, &head, 0);
  281|       |
  282|  38.3k|  std::string name;
  283|  38.3k|  std::string fn;
  284|  38.3k|  std::string ctype;
  285|       |
  286|   106k|  for (unsigned current = 0; current < head.length();) {
  ------------------
  |  Branch (286:30): [True: 67.6k, False: 38.3k]
  ------------------
  287|       |    /* read line by line */
  288|  67.6k|    std::string::size_type i = head.find("\r\n", current);
  289|  67.6k|    const std::string text = head.substr(current, (i == std::string::npos
  ------------------
  |  Branch (289:52): [True: 0, False: 67.6k]
  ------------------
  290|  67.6k|                                                   ? std::string::npos
  291|  67.6k|                                                   : i - current));
  292|       |
  293|  67.6k|    if (regexMatch(text, content_disposition_e)) {
  ------------------
  |  Branch (293:9): [True: 14.1k, False: 53.4k]
  ------------------
  294|  14.1k|      fishValue(text, name_e, name);
  295|  14.1k|      fishValue(text, filename_e, fn);
  296|  14.1k|    }
  297|       |
  298|  67.6k|    if (regexMatch(text, content_type_e)) {
  ------------------
  |  Branch (298:9): [True: 4.79k, False: 62.8k]
  ------------------
  299|  4.79k|      fishValue(text, content_e, ctype);
  300|  4.79k|    }
  301|       |
  302|  67.6k|    current = i + 2;
  303|  67.6k|  }
  304|       |
  305|  38.3k|  LOG_DEBUG("name: " << name << " ct: " << ctype  << " fn: " << fn);
  306|       |
  307|  38.3k|  currentKey_ = name;
  308|       |
  309|  38.3k|  if (!fn.empty()) {
  ------------------
  |  Branch (309:7): [True: 4.38k, False: 34.0k]
  ------------------
  310|  4.38k|    if (!request.postDataExceeded_) {
  ------------------
  |  Branch (310:9): [True: 4.38k, False: 0]
  ------------------
  311|       |      /*
  312|       |       * It is not easy to create a std::ostream pointing to a
  313|       |       * temporary file name.
  314|       |       */
  315|  4.38k|      std::string spool = FileUtils::createTempFileName();
  316|       |
  317|  4.38k|      spoolStream_ = new std::ofstream(spool.c_str(),
  318|  4.38k|        std::ios::out | std::ios::binary);
  319|       |
  320|  4.38k|      request_->files_.insert
  321|  4.38k|        (std::make_pair(name, Http::UploadedFile(spool, fn, ctype)));
  322|       |
  323|  4.38k|      LOG_DEBUG("spooling file to " << spool.c_str());
  324|       |
  325|  4.38k|    } else {
  326|      0|      spoolStream_ = 0;
  327|       |      // Clear currentKey so that file we don't do harm by reading this
  328|       |      // giant blob in memory
  329|      0|      currentKey_ = "";
  330|      0|    }
  331|  4.38k|  }
  332|       |
  333|  38.3k|  windBuffer(4);
  334|       |
  335|  38.3k|  return true;
  336|  38.3k|}
_ZN2Wt9CgiParser9parseBodyERNS_10WebRequestENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  339|  39.1k|{
  340|  39.1k|  std::string value;
  341|       |
  342|  39.1k|  readUntilBoundary(request, boundary, 2,
  343|  39.1k|                    spoolStream_ ? 0 : (!currentKey_.empty() ? &value : 0),
  ------------------
  |  Branch (343:21): [True: 4.38k, False: 34.7k]
  |  Branch (343:41): [True: 5.92k, False: 28.8k]
  ------------------
  344|  39.1k|                    spoolStream_);
  345|       |
  346|  39.1k|  if (spoolStream_) {
  ------------------
  |  Branch (346:7): [True: 4.16k, False: 34.9k]
  ------------------
  347|  4.16k|    LOG_DEBUG("completed spooling");
  348|  4.16k|    delete spoolStream_;
  349|  4.16k|    spoolStream_ = 0;
  350|  34.9k|  } else {
  351|  34.9k|    if (!currentKey_.empty()) {
  ------------------
  |  Branch (351:9): [True: 5.77k, False: 29.2k]
  ------------------
  352|  5.77k|      LOG_DEBUG("value: \"" << value << "\"");
  353|  5.77k|      request_->parameters_[currentKey_].push_back(value);
  354|  5.77k|    }
  355|  34.9k|  }
  356|       |
  357|  39.1k|  currentKey_.clear();
  358|       |
  359|  39.1k|  if (std::string(buf_ + boundary.length(), 2) == "--")
  ------------------
  |  Branch (359:7): [True: 45, False: 39.0k]
  ------------------
  360|     45|    return false;
  361|       |
  362|  39.0k|  windBuffer(boundary.length() + 2);
  363|       |
  364|  39.0k|  return true;
  365|  39.1k|}
CgiParser.C:_ZN12_GLOBAL__N_19fishValueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_11basic_regexIcNS0_12regex_traitsIcEEEERS5_:
   64|  34.1k|  {
   65|  34.1k|    std::smatch what;
   66|       |
   67|  34.1k|    if (std::regex_search(text, what, e)) {
  ------------------
  |  Branch (67:9): [True: 22.6k, False: 11.5k]
  ------------------
   68|  22.6k|      result = std::string(what[1]) + std::string(what[2]);
   69|  22.6k|      return true;
   70|  22.6k|    } else
   71|  11.5k|      return false;
   72|  34.1k|  }
CgiParser.C:_ZN12_GLOBAL__N_110regexMatchERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_11basic_regexIcNS0_12regex_traitsIcEEEE:
   75|   135k|  {
   76|   135k|    return std::regex_search(text, e);
   77|   135k|  }

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|  4.38k|    {
  126|  4.38k|      std::string tempDir;
  127|       |
  128|  4.38k|      char *wtTmpDir = std::getenv("WT_TMP_DIR");
  129|  4.38k|      if (wtTmpDir)
  ------------------
  |  Branch (129:11): [True: 0, False: 4.38k]
  ------------------
  130|      0|      tempDir = wtTmpDir;
  131|  4.38k|      else {
  132|       |#ifdef WT_WIN32
  133|       |        char winTmpDir[MAX_PATH];
  134|       |        if(GetTempPathA(sizeof(winTmpDir), winTmpDir) != 0)
  135|       |          tempDir = winTmpDir;
  136|       |#else
  137|  4.38k|        tempDir = "/tmp";
  138|  4.38k|#endif
  139|  4.38k|      }
  140|       |
  141|  4.38k|      return tempDir;
  142|  4.38k|    }
_ZN2Wt9FileUtils18createTempFileNameB5cxx11Ev:
  145|  4.38k|    {
  146|  4.38k|      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|  4.38k|      char* spool = new char[20 + tempDir.size()];
  158|  4.38k|      strcpy(spool, (tempDir + "/wtXXXXXX").c_str());
  159|       |
  160|  4.38k|      int i = mkstemp(spool);
  161|  4.38k|      close(i);
  162|       |
  163|  4.38k|      std::string returnSpool = spool;
  164|  4.38k|      delete [] spool;
  165|  4.38k|      return returnSpool;
  166|  4.38k|#endif
  167|  4.38k|    }

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

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

_ZN2Wt5Utils16inplaceUrlDecodeERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
  376|   279k|{
  377|       |  // Note: there is a Java-too duplicate of this function in Wt/Utils.C
  378|   279k|  std::size_t j = 0;
  379|       |
  380|  2.09M|  for (std::size_t i = 0; i < text.length(); ++i) {
  ------------------
  |  Branch (380:27): [True: 1.81M, False: 279k]
  ------------------
  381|  1.81M|    char c = text[i];
  382|       |
  383|  1.81M|    if (c == '+') {
  ------------------
  |  Branch (383:9): [True: 1.06k, False: 1.81M]
  ------------------
  384|  1.06k|      text[j++] = ' ';
  385|  1.81M|    } else if (c == '%' && i + 2 < text.length()) {
  ------------------
  |  Branch (385:16): [True: 14.6k, False: 1.79M]
  |  Branch (385:28): [True: 13.9k, False: 646]
  ------------------
  386|  13.9k|      std::string h = text.substr(i + 1, 2);
  387|  13.9k|      char *e = 0;
  388|  13.9k|      int hval = std::strtol(h.c_str(), &e, 16);
  389|       |
  390|  13.9k|      if (*e == 0) {
  ------------------
  |  Branch (390:11): [True: 1.58k, False: 12.4k]
  ------------------
  391|  1.58k|        text[j++] = (char)hval;
  392|  1.58k|        i += 2;
  393|  12.4k|      } else {
  394|       |        // not a proper %XX with XX hexadecimal format
  395|  12.4k|        text[j++] = c;
  396|  12.4k|      }
  397|  13.9k|    } else
  398|  1.79M|      text[j++] = c;
  399|  1.81M|  }
  400|       |
  401|   279k|  text.erase(j);
  402|   279k|}

_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|}