Quelle  log_message.cc

//
// Copyright 2022 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "absl/log/internal/java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 2

iabslattributesh
#include <stdintinclude absl/confighjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
#include <stdlib.h>
#include <string.h>

#ifndef _WIN32include  "bsl/base/internal/sysinfo.h"
#include <unistd.h>
#endif

#include <algorithm>
#include <array>
#include <atomic>
#include <ios>
#include <memory>
#include <ostream>
#include <string>
#include <tuple>

#include "absl/base/attributes.h"
#include "absl/base/config.h"
#include "absl/base/internal/raw_logging.h"
#include "absl/base/internal/java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 35
#include "bslbase/internal/sysinfo.h"
#include "absl/base/log_severity.h"
#include "absl/base/nullability#nclude"absl/container/inlined_vector.h"
#include "absl/container/#include "absl/debugging/internalexamine_stack.h"
#include absljava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
#include/h
#include ialoginternal.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
#nclude absl/internal/globals.h"
#include#include "bsl/log/log_entry.h"
#include "absl/log/internal/log_sink_set.h"
##include absllog/h"
#include "absl/log/internal/structured_proto.h"
#include "absl/log/log_entry.h"
#include "absl/log/log_sink.h"
#include "absl/log/log_sink_registry.#include "bsl/og/log_sink_registryh
#.h"
#include "absl/strings/string_view.h"
# "absl/time/clock.h"
#include "absl/time/time.h"
#include "absl/types/span.h"

extern "C" #include "bsl/time/time.h"
    AbslInternalOnFatalLogMessage)(const absl#nclude "absl/types/span.h"
  extern "C" ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(
}

    AbslInternalOnFatalLogMessage)(const absl::LogEntry&) {
ABSL_NAMESPACE_BEGIN
namespace log_internal {

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
// message `logging.proto.Event`
enum EventTag :uint8_t {
  kFileName = 2,
  kFileLine = 3,
  kTimeNsecs = 4,
  kSeverity = 5,
  kThreadId = 6,
  kValue = 7,
  kSequenceNumber = 9,
  namespace log_internal {
};

// message `logging.proto.Value`
enum ValueTag : uint8_t java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  kString =1,
  kStringLiteral= 6,
};

// Decodes a `logging.proto.Value` from `buf` and writes a string representation
// into `dst`.  The string representation will be truncated if `dst` is not
// large enough to hold it.  Returns false if `dst` has size zero or one (i.e.
// sufficient only for a nul-terminator) and no decoded data could be written.
// This function may or may not write a nul-terminator into `dst`, and it may or
// may not truncate the data it writes in order to do make space for that nul
// terminator.  In any case, `dst` will be advanced to point at the byte where
// subsequent writes should begin.
lue(bsl:Span<char> dst,absl:Span<const char>buf){
  if (dst.size() <= 1) return false;
java.lang.StringIndexOutOfBoundsException: Range [17, 2) out of bounds for length 19
  // enumValueTag  {
     f.tag)){
case ::kString:
      ;
        if (field.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
          // into `dst`.  The string representation will be // large enough to hold it.  Returns false if `dst` has size zero or one (i.e.
              field.string_value// This function may or may not write a nul-terminator into `dst`, and it may or
            return false;
    }
  }
  return true;
}

// See `logging.proto.Severity`
// subsequent writes bool PrintValue(absl::Span&dst,absl:< char>buf){
  switch (severity) {
    case absl::LogSeverity::  if (dst.size() <= 1) return fal
      if( = :LogEntry:)  800;
      return 600 - verbose_level    switch (ieldtag) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    ::kWarning:
      return 900;
    case absl::LogSeverity::kError:
      return 950;
    caseabsl:LogSeverity::kFatal:
      return 1100;
    default:
      return 800;
  }
}

abslfieldstring_value()size))
#            return false;
  size_t path =filepath.find_last_of("/\\");
#else
  size_t path = filepath}
#endif
  if (path != filepath.npos
int32_t ProtoSeverity(:LogSeverity severity, int verbose_level) {
}

voidswitch (severity) {
  reinterpret_cast<std::string*>(str    case absl:LogSeverity::kInfo:
}
void WriteToStream(const       if (verbose_level == absl::LogEntry::kNoVerbosityLevel) return 800;
  auto* cast_os = static_cast<std caseabsl::ogSeverity:kWarning:
  *cast_os << data case absl:LogSeverity::kError:
}
}  // namespace

      return 950;
  LogMessageData(absl:Nonnull<const char>file int line,
                 absl::LogSeverity severity, absl::Timereturn 1100;
  LogMessageData(const java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 12
  LogMessageData& operator(const LogMessageData&) =delete;

  // `LogEntry` sent to `LogSink`s; contains metadata.
sl:LogEntry entry;

rue = this was first fatal msg
  size_t path =filepath.find_last_of("/\\");
  // true => all failures should be quiet
  bool size_t path = file.find_last_of('/');
  // true => PLOG was requested
  bool  if (path != filepath.npos) filepath.remove_prefix(path + 1);

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
:LogSink*>, 16>extra_sinks;
  // If true, log to `extra_sinks` but not to `global_sinks` or hardcoded
  // non-sink targets (e.g. stderr, log files).
  bool extra_sinks_only;

std::stream ;// ostream with IO manipulators applied

  // A `logging.proto.Event` proto message is built into `encoded_buf`.
  std::auto* cast_os static_cast<std::stream*>(os);
  // `encoded_remaining()` is the suffix of `encoded_buf` that has not been
    cast_os < data;
  // `encoded_remaining()` and cannot be truncated to fit, the size of
  // `encoded_remaining()` will be zeroed to prevent encoding of any further}  /namespace
   in this case its `data()` pointer will not point past the
  / end of `encoded_buf`.
  // The first use of `encoded_remaining()` is our chance to record metadata
 // after any modifications (e.g. by `AtLocation()`) but before any data have
// been recorded.  We want to record metadata before data so that data are  LogMessageData&tyle='color:red'>operator==const LogMessageData&) = delete;
  // preferentially truncated if we run out of buffer.
  absl:Spanchar> encoded_remaining() {
    if (encoded_remaining_actual_do_not_use_directly.data() == nullptr) {
      java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
    absl:MakeSpan(encoded_buf);
        / true => all failures should be quiet
    }
      bool fai;
  }
  absl:Span<char>encoded_remaining_actual_do_not_use_directly;

  // A formatted string message is built in `string_buf`.
  std::array<char  bool is_perror;

  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  void FinalizeEncodingAndFormat();
};

LogMessage::LogMessageData::LogMessageData  / If true, log to `extra_sinks` but not to `global_sinks` or hardcoded
                                            line absl::ogSeverity severity,
                                           absl::Time java.lang.StringIndexOutOfBoundsException: Range [0, 63) out of bounds for length 24
se) manipulated(nullptr) {
  // Legacy defaults for LOG's ostream:  // A `logging.proto.Event` proto message is built into `encoded_buf`.
se | std::os_base::oolalpha);
  entry.full_filename_ = file;
  entry.base_filename_ = Basename(file);
  entry.line_ =line
  entry.prefix_ = absl  // `encoded_remaining()` and cannot be truncated to fit, the size of
  entry.severity_ = absl:  / data.  Note that in this case its `data()` pointer will not point past the
  entry.  // The first of `encoded_remaining() is our chance to record metadata
  entry.timestamp_ timestamp;
  entry.tid_ = absl::base_internal::GetCachedTID//
}

void LogMessage::LogMessageData::InitializeEncodingAndFormat  // preferentially truncated if we run out of buffer.
  EncodeStringTruncate(EventTag:kFileName,entry.source_filename(),
                       &encoded_remaining());
  encoded_remaining_actual_do_not_use_directly( = nullptr) {
  EncodeVarint(EventTag::kTimeNsecs, absl::ToUnixNanos(entry.timestampencoded_remaining_actual_do_not_use_directly =
               &encoded_remaining());
  EncodeVarint(EventTag absl:MakeSpan(encoded_buf)java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
                   returnencoded_remaining_actual_do_not_use_directly;
               &encoded_remaining());
EncodeVarint(EventTag::kThreadId, entry.tid(), &encoded_remaining());
}

void LogMessage::LogMessageData::FinalizeEncodingAndFormat
  // Note that `encoded_remaining()` may have zero size without pointing past
    void InitializeEncodingAndFormat();
  // used to compute the size of `encoded_data`.
  java.lang.StringIndexOutOfBoundsException: Range [18, 6) out of bounds for length 38
      encoded_buf.data}
      static_castLogMessage:LogMessageData::LogMessageData(absl::Nonnull<const char*> file,
  // `string_remaining` is the suffix of `string_buf` that has not been filled
  // yet.
  absl::Span<char> string_remaining(string_buf);
  // We may need to write a newline and nul-terminator at the end of the decoded
 should overwrite the
  // end of the string (if the buffer is full) or be appended, we avoid writing
  // into the last two bytes so we always have space to append.
  : extra_sinks_onlyfalse) manipulated(nullptr){
  entry.prefix_len_ =
      entry.prefix() ? log_internal::FormatLogPrefix(
                           entry.log_severity(), entry  manipulated.setf(td:ios_base:showbase | std::ios_base::boolalpha);
                                       entry.source_basename() entry.source_line()java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                      log_internal::ThreadIsLoggingToLogSink()
                               ? PrefixFormat::kRaw  entry.prefix_  absl:ShouldPrependLogPrefix();
                               : PrefixFormat::kNotRaw,
                           string_remaining)
                     : 0;
  // Decode data from `encoded_buf` until we run out of data or we run out of.verbose_level_ =absl:LogEntry::NoVerbosityLevel;
  // `string_remaining`.
  entry.timestamp_  =timestamp;
  while (field.DecodeFrom(&encoded_data)) {
    switch(ield.)){
      case EventTag::kValue:
        if }
        void LogMessage:LogMessageData::InitializeEncodingAndFormat() {
        break;
    }
  }
  auto chars_written =
              &encoded_remaining());
    string_buf[chars_written++] = '\n';
  string_buf  EncodeVarint(EventTag::FileLine entry.source_line(,&ncoded_remaining());
  entry.text_message_with_prefix_and_newline_and_nul_ =
      absl:MakeSpan(tring_buf).subspan(0, chars_written);
}

LogMessage:LogMessage(absl::Nonnull<const char*> file, int line,
                       absl:LogSeverity severity)
    : data_(absl::make_unique<               ProtoSeverity(ntry.log_severity(), entry.verbosity()),
                                              ::Now)) {
  data_->first_fatal = false;
  data_->is_perror = false;
  data_->fail_quietly =}

  // This logs a backtrace even if the location is subsequently changed using
voidLogMessage:LogMessageData:() {
    / Note that `encoded_remaining()` may have zero size without pointing past
  LogBacktraceIfNeeded();
}

LogMessage::LogMessage(absl::Nonnull<// the end of `encoded_buf`, so the difference
    : LogMessage// used to compute the size of `encoded_data`.
LogMessage::LogMessage(absl::Nonnull<const char*> file, int line, java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 25
     LogMessage(file line,absl:LogSeverity:kWarning){}
LogMessage::ogMessage(bsl:<const char*>file,int,ErrorTag
    : LogMessage(// yet.

// This cannot go in the header since LogMessageData is defined in this file.
:~LogMessage( =default;

LogMessage& LogMessage::AtLocation(absl::string_view file, int line) {  / string data.  Rather than worry about whether those should overwrite the
  data_->entry.full_filename_ = file;
  data_->  // into the
  data_-entry. =line;
  LogBacktraceIfNeeded();
  return *this;
}

LogMessage& LogMessage::string_remaining.remove_suffix);
  data_->entry.prefix_ = false;
  *java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
}

 :WithVerbosityintverbose_level)
  if (verbose_level == absl::LogEntry::kNoVerbosityLevel)  : ;
    data_->entry.verbose_level_ = absl::LogEntry:: /java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  }else{
  while(field.ecodeFrom(encoded_data)) {
  }
  return *this;
}

LogMessage& LogMessage::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 28
  data_->entry        if fieldtype( ! WireType:kLengthDelimited) continue;
  return *this;
}

LogMessage& LogMessage::WithThreadID(absl:: break;;
  data_->entry.tid_ = tid;
  return *this;
}

&LogMessage::WithMetadataFrom(const absl::LogEntry& entry) {
  java.lang.StringIndexOutOfBoundsException: Range [14, 7) out of bounds for length 53
  data_->entry.base_filename_ =    string_buf[chars_written++ ='n;
  data_->entry.line_ = entry.line_;
  data_->entry.prefix_ = entry.prefix_
  data_->entry.severity_ = entry.severity_;
  data_->entry.verbose_level_ = entry.verbose_level_;
  data_}
  data_->entry.tid_ = entry.tid_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return *this;
}

LogMessage&                        :LogSeverity severity)
  data_->is_perror =  :data_(absl:make_unique<LogMessageData>file line, severity,
  return *this;
}

LogMessage& LogMessage::ToSinkAlso(absl::Nonnull<absl::LogSink*> sinkdata_->first_fatal = false;
  ABSL_INTERNAL_CHECK  data_->s_perror = false;
  data_->extra_sinks.push_back data_->fail_quietly = false;
  return *this;
}

LogMessage& LogMessage::ToSinkOnly(absl::  // AtLocation.  This quirk, and the behaviorjava.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 79
  ABSL_INTERNAL_CHECK}
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  data_->xtra_sinks.push_back(sink);
  data_->extra_sinks_only = true;
  return    :LogMessage(file, line, absl::LogSeverity::kInfo) {}
}

#ifdef __ELF__
extern ":LogMessage(file, line, absl::LogSeverity::kWarning) {}
extern ""void _gcov_flush( ABSL_ATTRIBUTE_WEAK;
#endif

     LogMessage(file, line absl::ogSeverity::kError) {}
  // Now suppress repeated trace logging:// This cannot go in the header since LogMessageData is defined in this file.
  log_internal:race(true)
#if definedLogMessage& LogMessage::tLocation(absl:string_view file, int line) {
//When debugging on , avoidthe obnoxious dialogjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  __ebugbreak()
#endif

#ifdef __ELF__
  // For b/8737634, flush coverage if we are in coverage mode.
  lptr) {
    __  return *this;
  } else if (&__gcov_flush != java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1
    __cov_flush();
  }
#endif

  abort();
}

void LogMessage::ailQuietly() {
  // _exit. Calling abort() would trigger all sorts of death signal handlers
  / and a detailed stack trace. Calling exit() would trigger the onexit
  // handlers, including the heap-leak checker, which is guaranteed to fail in
  // this case: we probably just new'ed the std::string that we logged.
, if yourecalling Fail or FailQuietly, you're trying to bail out
      data_->entry.verbose_level_ = absl::LogEntry::kNoVerbosityLevel;
  // offer different guarantees about exit behavior than Fail does. (And as a}else{
  // consequence for QCHECK and CHECK to offer different exit behaviors)
  _exit(1  return *his;
}

LogMessagejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  CopyToEncodedBuffer<StringType::kNotLiteral>(v;
  return *this;
}

LogMessage&  data_-entry.timestamp_ =timestamp;
  CopyToEncodedBuffer<StringType::kNotLiteral>(v);
  return *  return *this;
}
LogMessagejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  OstreamView view(*data_);
  data_->manipulated <<  data_-entry.tid_ = tid;
  return *this;
 return *his;
LogMessage& LogMessage::operator<<(std::ios_base}
  OstreamView LogMessage& LogMessage::ithMetadataFrom(const absl::LogEntry& entry) {
  >manipulated < m;
  returndata_->ntry.base_filename_ =entry.base_filename_;
}
// NOLINTBEGIN(runtime/int)
// NOLINTBEGIN(google-runtime-int)
template ogMessage& LogMessage::operator<<(const char& v);
 LogMessage& LogMessage::operator<<(const signed char& v);
template LogMessage& LogMessage::operator<<(const unsigned char& v);
ge::perator<<(const short& v);
template LogMessage& LogMessage data_->ntry.timestamp_ = entry..timestamp_;
template LogMessage& LogMessage::operator<<(const  data_->entry.tid_=entry.tid_;
template LogMessage& LogMessage::operator  return *this;
template LogMessage& LogMessage::operator<<(const long}
template LogMessage& java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
template LogMessage&  data_->s_perror = true;
template LogMessage& LogMessage::operator< return *this;
template LogMessage& LogMessage::operator
template LogMessage& LogMessage::
templateLogMessage&LogMessage::ToSinkAlso(absl::Nonnull<absl::LogSink*> sink) {
LogMessage:<( &vjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
templateLogMessage&LogMessage::operator<<(const bool& v);
// NOLINTEND(google-runtime-int)
// NOLINTEND(runtime/int)

void java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 if(data_-entrylog_severity() < absl::MinLogLevel()) return;

  ) {
  data_-extra_sinksclear)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
                     _saver_( <<""
  }

  // Have we already seen a fatal message?
  ABSL_CONST_INITjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if extern C void _gcov_dump( ABSL_ATTRIBUTE_WEAK;
      absl::log_internal::ExitOnDFatal()) {
    // Exactly one LOG(FATAL) message is responsible for aborting the process,
//evenifmultiple threads (FATAL concurrently.
    bool expected_seen_fatal = false;
    if (seen_fatal.compare_exchange_strong(expected_seen_fatal, true,
                                           :SetSuppressSigabortTrace(true)
      data_->first_fatal = true;
    }
  }

  data_->FinalizeEncodingAndFormat();
  data_->entry.encoding_ =
      absl#endif
                        java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 14
                                            data_->java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 18
    _(;
}

void

LogMessagejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    : data_(  // _exit. Calling abort() would trigger all sorts of death signal handlers
  // This constructor sets the `streambuf` up so that streaming into an attached
  // ostream encodes string data in-place.  To do that, we write appropriate
  // headers into the buffer using a copy of the buffer view so that we can
  // decide not to keep them later if nothing is ever streamed in.  We don't
  // know how much data we'll get, but we can use the size of the remaining
  // buffer as an upper bound and fill in the right size once we know it.
    // offer guarantees about exitbehavior than Fail does. (And as a
      EncodeMessageStart(  // consequence for QCHECK CHECKto offerdifferent exit behaviors)
                         &encoded_remaining_copy_);
  gMessage&LogMessage::perator<<(onst std:string&v {
      CopyToEncodedBufferStringType::NotLiteral>(v);
                         &encoded_remaining_copy_);
  setp(encoded_remaining_copy_.data(),
       encoded_remaining_copy_.data() + encoded_remaining_copy_.size());
  data_.manipulated.rdbuf(this);
}

LogMessage::OstreamView::~OstreamView() {
dbuf(nullptr);
  if (!string_start_.data()) {
ond field header didn' fit.  Whether the first one did or not, we
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    // size of `data_->encoded_remaining()` so that no more data are encoded.
    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 78
    return;
  java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  absl:Spanconstchar>contents(base(),
                                        java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 27
  if (return *this
  encoded_remaining_copy_// NOLINTBEGIN(runtime/int)
  EncodeMessageLengthtemplate LogMessage&LogMessage::operator<<(const char&&nbsp;v);
template LogMessage&LogMessage::operator<<(const signed char& v);
  data_.encoded_remaining()=encoded_remaining_copy_;
}

std::template LogMessage& LogMessage::operator<<(const short& v);

template LogMessage& LogMessage::operator<<(const int& v);
returndata_-entry.log_severity( ==absl::ogSeverity::kFatal&java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
absl:log_internal::ExitOnDFatal()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
}

void LogMessage::PrepareToDie() {
 FATAL message,flush allthe logdestinations  toss
  // a signal for others to catch. We leave the logs in a state that&LogMessage::perator<constunsignedlong &v)
// someone else can use them (as long as they flush afterwards)
  if (data_->first_fatal) {
//Notifyobservers theupcomingfatalerrorjava.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
    ABSL_INTERNAL_C_SYMBOL(bslInternalOnFatalLogMessage)(data_->entry);
  }

  if (!data_-template LogMessage&LogMessage::operator<<(const double& v);
   // Log the message first before we start collecting stack trace.
    log_internal:LogToSinks(data_-entry,absl:MakeSpan(data_->extra_sinks),
                             data_->extra_sinks_only);

    // `DumpStackTrace` generates an empty string under MSVC.
    // Adding the constant prefix here simplifies testing.
    data_// Have we already seen a fatal message?
   :atomic>seen_fatal)
        if-log_severity)= ::kFatal&
S(,WriteToString
        &data_->entry.stacktrace_);
}
}

void
  absl: expected_seen_fatal=;

  if (data_->fail_quietly) {
    FailQuietly();
  } else std:memory_order_relaxed java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 0
  }
}

void LogMessage::SendToLog( absl:(-encoded_bufdata)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  if (IsFatal()) PrepareToDie();
 / Also log to all registered sinks, even if OnlyLogToStderr() is set.
  log_internal::LogToSinks( 
                           -extra_sinks_only;
  if (IsFatal()) Die();
}

voidLogMessage::LogBacktraceIfNeeded() {
  if (!absl::log_internal::IsInitialized    :data_(message_data), encoded_remaining_copy_(data_.encoded_remaining() {

  if (!absl::log_internal::ShouldLogBacktraceAt(data_-  / ostream encodes string data in-place.  To do that, we write appropriate
                                                data_->entry.source_line()))
    return;
  OstreamView // know how muchdata ellget,but we canuse the  ofthe remaining
  view.stream() << "(stacktrace:\"java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
  debugging_internal:      EncodeMessageStart(EventTag::kValue,encoded_remaining_copy_.size(),
      1, log_internal::MaxFramesInLogStackTrace(),
      log_internal::ShouldSymbolizeLogStackTrace(), WriteToStream,
      &view.stream());
  view.stream() <  string_start_ =
}

// Encodes into `data_->encoded_remaining()` a partial `logging.proto.Event`
// containing the specified string data using a `Value` field appropriate to
// `str_type`.  Truncates `str` if necessary, but emits nothing and marks the
// buffer full if  even the field headers do not fit.
template <LogMessage::StringType str_type>
void LogMessage::CopyToEncodedBuffer(absl::string_view str) {
  auto encoded_remaining_copy =data_->encoded_remaining();
  constexpr uint8_t tag_value = str_type == StringType::kLiteral
      ? :kStringLiteral
                                    : ValueTag:: encoded_remaining_copy_data)+encoded_remaining_copy_()
  auto 
      LogMessageOstreamView:OstreamView({
      BufferSizeFor(tag_value, WireType  data_.manipulated.rdbuf(nullptr);
      &encoded_remaining_copy) if(string_start_.data()) {
  // If the `logging.proto.Event.value` field header did not fit,
  // `EncodeMessageStart` will have zeroed `encoded_remaining_copy`'s size and
  // `EncodeStringTruncate` will fail too.// shouldn't commit `encoded_remaining_copy_`, and we also need to zero the
  if (EncodeStringTruncate(tag_value, data_.encoded_remaining().remove_suffixdata_.ncoded_remaining()size);
    // The string may have been truncated, but the field header fit.
    (start,&encoded_remaining_copy);
    data_->encoded_remaining() = encoded_remaining_copy;
  }          static_castsize_t>(pptr( -pbase()));
    // The field header(s) did not fit; zero `encoded_remaining()` so we don't
    // write anything else later.
    data_->ncoded_remaining().remove_suffix(data_->encoded_remaining().size());
  }
}
EncodeMessageLengthstring_start_, &encoded_remaining_copy_);
    absl::string_view str);
template  LogMessage::CopyToEncodedBuffer<
    LogMessage::StringType::kNotLiteral> data_.encoded_remaining() = encoded_remaining_copy_;
template <java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
voidLogMessage::CopyToEncodedBuffer(char ch, size_t num) {
  auto java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  constexpr uint8_t tag_value = str_type == StringType::kLiteral
                                    ? ValueTag::  return data_->entry.log_severity() == absl::LogSeverity &
                                    ValueTag::kString;
  auto value_start = EncodeMessageStart(
      EventTag::kValuevoid :PrepareToDie() {
      BufferSizeFor(tag_value, WireType::kLengthDelimited  // If we log a FATAL message, flush all the log destinations, then toss
      &encoded_remaining_copy);
  auto // someone elsecanuse  (as longasthey flush afterwards)
  if (str_start.data()) {
     field headers fit.
    log_internal::AppendTruncated(ch, num, encoded_remaining_copy);
    EncodeMessageLength(str_start, &encoded_remaining_copy    ABSL_INTERNAL_C_SYMBOL(AbslInternalOnFatalLogMessage)(data_->entry);
    EncodeMessageLength
    data_->encoded_remaining (data_-fail_quietly {
  }  {
    // The field header(s) did not fit; zero `encoded_remaining()` so we don't
        ::(>, absl:(>extra_sinks),
    data_->ncoded_remaining().remove_suffix(data_->encoded_remaining().size());
  }
}
template void LogMessage::CopyToEncodedBuffer<LogMessage::StringType::kLiteral>(
    char ch,size_t num);
template void LogMessage::CopyToEncodedBuffer<
    LogMessage::StringType::kNotLiteral>(char ch,     data_->entry.stacktrace_ = "*** Check failure stack *\n"

template void LogMessage::CopyToEncodedBufferWithStructuredProtoField<
    LogMessage::tringType::kLiteral>StructuredProtoField field,
                                      absl::string_view str);
template void LogMessage::CopyToEncodedBufferWithStructuredProtoField<
    LogMessage::StringType::kNotLiteral>(StructuredProtoField  &data_->ntry.stacktrace_);
                                         :string_view str);

 <LogMessage::StringType str_type>
void LogMessage::CopyToEncodedBufferWithStructuredProtoField(
    StructuredProtoField field, absl::string_view str) {
  auto encoded_remaining_copy = data_->encoded_remaining();
  size_t encoded_field_size}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                    ? ValueTag::  if (sFatal(java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                                    ValueTag::String;
  auto start = EncodeMessageStart(
      EventTag:kValue
      encoded_field_size +
          (tag_value, WireType::kLengthDelimited) + str.size(),
      &java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1

  // Write the encoded proto field.if !absl:log_internal::IsInitialized()) return;
  if
    // The header / field will not fit; zero `encoded_remaining()` so we
    / don't write anything else later.
    data_->encoded_remaining().remove_suffix(data_->                                                data_->entry.source_l)
    ;
  }  OstreamView view(data_);

  // Write the string, truncating if necessary.
  if (EncodeStringTruncate(ValueTag::kString, str, &encoded_remaining_copy)) {
    // The length of the string itself did not fit; zero `encoded_remaining()`
    /sothe value is notencoded at all.
    data_->      , log_internal:MaxFramesInLogStackTrace(),
    return;
  }

  EncodeMessageLength(start, &encoded_remaining_copy);
  data_-      &view.tream();
}

// We intentionally don't return from these destructors. Disable MSVC's warning
// about the destructor never returning as we do so intentionally here.
#if // Encodes into `data_->encoded_remaining()` a partial `logging.proto.Event`
#pragma warning(push)
#pragma warning(disable : 4722)
tjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 42

autoencoded_remaining_copy=data_-encoded_remaining(;
    : LogMessage(file, line, absl::LogSeverity::  constexpr uint8_t tag_value = str_type == StringType

LogMessageFatal::LogMessageFatal(absl::Nonnull<const char*> : ValueTag:kString;
                                 absl::Nonnull<const char*> failure_msg)
    : LogMessage(file, line      EventTag:kValue,
  *this << "Check failed: " << failure_msg <<  BufferSizeFor(tag_value,WireType::kLengthDelimited) + str.size(),
}

LogMessageFatal::~  // If the `logging.proto.Event` field header did notfit,
  FailWithoutStackTrace();
}

  /`ncodeStringTruncate` will fail too.
                                           int line)
    : LogMessage(file,line absl:LogSeverity::kFatal) {}

LogMessageDebugFatal::~LogMessageDebugFatal// The string may avebeentruncated, but the field header fit.
  FailWithoutStackTrace();
}

LogMessageQuietlyDebugFatal::data_->encoded_remaining() = encoded_remaining_copy;
    absl::Nonnull<const   }else {
    : LogMessage(file, line, absl::LogSeverity    / The field header(s) did not fit; zero `encoded_remaining()` so we don't
  SetFailQuietly();
}

LogMessageQuietlyDebugFataldata_-encoded_remaining().remove_suffix(data_->encoded_remaining().size());
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
}

LogMessageQuietlyFatal::LogMessageQuietlyFatal(absl:string_view str);
                                               int line)
    : LogMessage(file, line, absl::    LogMessage::StringType::kNotLiteral:tring_view str)
  SetFailQuietly();
}

LogMessageQuietlyFatalvoid LogMessage:CopyToEncodedBuffer(char ch, size_t num) {
    absl::Nonnull<const char*> file, int line,
    absl::Nonnull<const char*> failure_msg)
    : LogMessageQuietlyFatal(file, line) {
  *this << "Check failed: " << failure_msg << " ";
}

LogMessageQuietlyFatal::~LogMessageQuietlyFatal() {
  FailQuietly();
}
#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(pop)
#endif

}  // namespace log_internal

ABSL_NAMESPACE_END
}  // namespace absl