re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/log/log_entry.cc

@@ -1,11 +1,10 @@
-//
-// Copyright 2022 The Abseil Authors.
+// Copyright 2025 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
+//     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,
@@ -15,27 +14,250 @@
 
 #include "absl/log/log_entry.h"
 
+#include <cstddef>
+#include <cstdint>
+#include <iomanip>
+#include <ios>
+#include <ostream>
+
 #include "absl/base/config.h"
+#include "absl/log/internal/proto.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+#include "absl/types/span.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
+namespace {
+// message `logging.proto.Event`
+enum EventTag : uint8_t {
+  kFileName = 2,
+  kFileLine = 3,
+  kTimeNsecs = 4,
+  kSeverity = 5,
+  kThreadId = 6,
+  kValue = 7,
+  kSequenceNumber = 9,
+  kThreadName = 10,
+};
+
+// message `logging.proto.Value`
+enum ValueTag : uint8_t {
+  kString = 1,
+  kStringLiteral = 6,
+};
+
+// enum `logging.proto.Severity`
+enum Severity : int {
+  FINEST = 300,
+  FINER = 400,
+  FINE = 500,
+  VERBOSE_0 = 600,
+  CONFIG = 700,
+  INFO = 800,
+  NOTICE = 850,
+  WARNING = 900,
+  ERROR = 950,
+  SEVERE = 1000,
+  FATAL = 1100,
+};
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr int LogEntry::kNoVerbosityLevel;
-constexpr int LogEntry::kNoVerboseLevel;
-#endif
-
-// https://github.com/abseil/abseil-cpp/issues/1465
-// CMake builds on Apple platforms error when libraries are empty.
-// Our CMake configuration can avoid this error on header-only libraries,
-// but since this library is conditionally empty, including a single
-// variable is an easy workaround.
-#ifdef __APPLE__
-namespace log_internal {
-extern const char kAvoidEmptyLogEntryLibraryWarning;
-const char kAvoidEmptyLogEntryLibraryWarning = 0;
-}  // namespace log_internal
-#endif  // __APPLE__
+void PrintEscapedRangeTo(const absl::string_view str,
+                         const absl::string_view substr, std::ostream* os) {
+  const absl::string_view head =
+      str.substr(0, static_cast<size_t>(substr.data() - str.data()));
+  const char old_fill = os->fill();
+  const auto old_flags = os->flags();
+  *os << std::right
+      << std::setw(static_cast<int>(absl::CHexEscape(head).size())) << "";
+  switch (substr.size()) {
+    case 0:
+      *os << "\\";
+      break;
+    case 1:
+      *os << "^";
+      break;
+    default:
+      *os << "[" << std::setw(static_cast<int>(absl::CHexEscape(substr).size()))
+          << std::setfill('-') << ")";
+      break;
+  }
+  os->fill(old_fill);
+  os->flags(old_flags);
+}
+}  // namespace
+void PrintTo(const LogEntry& entry, std::ostream* os) {
+  auto text_message_with_prefix_and_newline_and_nul = absl::string_view(
+      entry.text_message_with_prefix_and_newline_and_nul_.data(),
+      entry.text_message_with_prefix_and_newline_and_nul_.size());
+  *os << "LogEntry {\n"
+      << "  source_filename: \"" << absl::CHexEscape(entry.source_filename())
+      << "\"\n"
+      << "  source_basename: \"" << absl::CHexEscape(entry.source_basename())
+      << "\"\n"
+      << "  source_line: " << entry.source_line() << "\n"
+      << "  prefix: " << std::boolalpha << entry.prefix() << "\n"
+      << "  log_severity: " << entry.log_severity() << "\n"
+      << "  verbosity: " << entry.verbosity();
+  if (entry.verbosity() == absl::LogEntry::kNoVerbosityLevel) {
+    *os << " (kNoVerbosityLevel)";
+  }
+  *os << "\n"
+      << "  timestamp: " << entry.timestamp() << "\n"
+      << "  tid: " << entry.tid() << "\n"
+      << "  text_message_with_prefix_and_newline_and_nul_: \""
+      << absl::CHexEscape(text_message_with_prefix_and_newline_and_nul)
+      << "\"\n"
+      << "  text_message_with_prefix_and_newline:           ";
+  PrintEscapedRangeTo(text_message_with_prefix_and_newline_and_nul,
+                      entry.text_message_with_prefix_and_newline(), os);
+  *os << "\n"
+      << "  text_message_with_prefix:                       ";
+  PrintEscapedRangeTo(text_message_with_prefix_and_newline_and_nul,
+                      entry.text_message_with_prefix(), os);
+  *os << "\n"
+      << "  text_message_with_newline:                      ";
+  PrintEscapedRangeTo(text_message_with_prefix_and_newline_and_nul,
+                      entry.text_message_with_newline(), os);
+  *os << "\n"
+      << "  text_message:                                   ";
+  PrintEscapedRangeTo(text_message_with_prefix_and_newline_and_nul,
+                      entry.text_message(), os);
+  *os << "\n"
+      << "  text_message_with_prefix_and_newline_c_str:     ";
+  PrintEscapedRangeTo(
+      text_message_with_prefix_and_newline_and_nul,
+      // NOLINTNEXTLINE(bugprone-string-constructor)
+      absl::string_view(entry.text_message_with_prefix_and_newline_c_str(), 0),
+      os);
+  *os << "\n"
+      << "  encoded_message (raw): \""
+      << absl::CHexEscape(entry.encoded_message()) << "\"\n"
+      << "  encoded_message {\n";
+  absl::Span<const char> event = entry.encoded_message();
+  log_internal::ProtoField field;
+  while (field.DecodeFrom(&event)) {
+    switch (field.tag()) {
+      case EventTag::kFileName:
+        *os << "    file_name: \"" << absl::CHexEscape(field.string_value())
+            << "\"\n";
+        break;
+      case EventTag::kFileLine:
+        *os << "    file_line: " << field.int32_value() << "\n";
+        break;
+      case EventTag::kTimeNsecs:
+        *os << "    time_nsecs: " << field.int64_value() << " ("
+            << absl::FromUnixNanos(field.int64_value()) << ")\n";
+        break;
+      case EventTag::kSeverity:
+        *os << "    severity: " << field.int32_value();
+        switch (field.int32_value()) {
+          case Severity::FINEST:
+            *os << " (FINEST)";
+            break;
+          case Severity::FINER:
+            *os << " (FINER)";
+            break;
+          case Severity::FINE:
+            *os << " (FINE)";
+            break;
+          case Severity::VERBOSE_0:
+            *os << " (VERBOSE_0)";
+            break;
+          case Severity::CONFIG:
+            *os << " (CONFIG)";
+            break;
+          case Severity::INFO:
+            *os << " (INFO)";
+            break;
+          case Severity::NOTICE:
+            *os << " (NOTICE)";
+            break;
+          case Severity::WARNING:
+            *os << " (WARNING)";
+            break;
+          case Severity::ERROR:
+            *os << " (ERROR)";
+            break;
+          case Severity::SEVERE:
+            *os << " (SEVERE)";
+            break;
+          case Severity::FATAL:
+            *os << " (FATAL)";
+            break;
+        }
+        *os << "\n";
+        break;
+      case EventTag::kThreadId:
+        *os << "    thread_id: " << field.int64_value() << "\n";
+        break;
+      case EventTag::kValue: {
+        *os << "    value {\n";
+        auto value = field.bytes_value();
+        while (field.DecodeFrom(&value)) {
+          switch (field.tag()) {
+            case ValueTag::kString:
+              *os << "      str: \"" << absl::CHexEscape(field.string_value())
+                  << "\"\n";
+              break;
+            case ValueTag::kStringLiteral:
+              *os << "      literal: \""
+                  << absl::CHexEscape(field.string_value()) << "\"\n";
+              break;
+            default:
+              *os << "      unknown field " << field.tag();
+              switch (field.type()) {
+                case log_internal::WireType::kVarint:
+                  *os << " (VARINT): " << std::hex << std::showbase
+                      << field.uint64_value() << std::dec << "\n";
+                  break;
+                case log_internal::WireType::k64Bit:
+                  *os << " (I64): " << std::hex << std::showbase
+                      << field.uint64_value() << std::dec << "\n";
+                  break;
+                case log_internal::WireType::kLengthDelimited:
+                  *os << " (LEN): \"" << absl::CHexEscape(field.string_value())
+                      << "\"\n";
+                  break;
+                case log_internal::WireType::k32Bit:
+                  *os << " (I32): " << std::hex << std::showbase
+                      << field.uint32_value() << std::dec << "\n";
+                  break;
+              }
+              break;
+          }
+        }
+        *os << "    }\n";
+        break;
+      }
+      default:
+        *os << "    unknown field " << field.tag();
+        switch (field.type()) {
+          case log_internal::WireType::kVarint:
+            *os << " (VARINT): " << std::hex << std::showbase
+                << field.uint64_value() << std::dec << "\n";
+            break;
+          case log_internal::WireType::k64Bit:
+            *os << " (I64): " << std::hex << std::showbase
+                << field.uint64_value() << std::dec << "\n";
+            break;
+          case log_internal::WireType::kLengthDelimited:
+            *os << " (LEN): \"" << absl::CHexEscape(field.string_value())
+                << "\"\n";
+            break;
+          case log_internal::WireType::k32Bit:
+            *os << " (I32): " << std::hex << std::showbase
+                << field.uint32_value() << std::dec << "\n";
+            break;
+        }
+        break;
+    }
+  }
+  *os << "  }\n"
+      << "  stacktrace: \"" << absl::CHexEscape(entry.stacktrace()) << "\"\n"
+      << "}";
+}
 
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/log/log_entry.h

@@ -25,6 +25,7 @@
 #define ABSL_LOG_LOG_ENTRY_H_
 
 #include <cstddef>
+#include <ostream>
 #include <string>
 
 #include "absl/base/attributes.h"
@@ -213,6 +214,7 @@ class LogEntry final {
 
   friend class log_internal::LogEntryTestPeer;
   friend class log_internal::LogMessage;
+  friend void PrintTo(const absl::LogEntry& entry, std::ostream* os);
 };
 
 ABSL_NAMESPACE_END