raw_ostream.cpp | Explore in Territory

//===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This implements support for bulk buffered stream output.
//
//===----------------------------------------------------------------------===//

#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Config/config.h"
#include "llvm/Support/AutoConvert.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Duration.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/NativeFormatting.h"
#include "llvm/Support/Process.h"
#include "llvm/Support/Program.h"
#include <algorithm>
#include <cerrno>
#include <cstdio>
#include <sys/stat.h>

// <fcntl.h> may provide O_BINARY.
#if defined(HAVE_FCNTL_H)
# include <fcntl.h>
#endif

#if defined(HAVE_UNISTD_H)
# include <unistd.h>
#endif

#if defined(__CYGWIN__)
#include <io.h>
#endif

#if defined(_MSC_VER)
#include <io.h>
#ifndef STDIN_FILENO
#define STDIN_FILENO …
#endif
#ifndef STDOUT_FILENO
#define STDOUT_FILENO …
#endif
#ifndef STDERR_FILENO
#define STDERR_FILENO …
#endif
#endif

#ifdef _WIN32
#include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/Signals.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#endif

usingnamespacellvm;

constexpr raw_ostream::Colors raw_ostream::BLACK;
constexpr raw_ostream::Colors raw_ostream::RED;
constexpr raw_ostream::Colors raw_ostream::GREEN;
constexpr raw_ostream::Colors raw_ostream::YELLOW;
constexpr raw_ostream::Colors raw_ostream::BLUE;
constexpr raw_ostream::Colors raw_ostream::MAGENTA;
constexpr raw_ostream::Colors raw_ostream::CYAN;
constexpr raw_ostream::Colors raw_ostream::WHITE;
constexpr raw_ostream::Colors raw_ostream::SAVEDCOLOR;
constexpr raw_ostream::Colors raw_ostream::RESET;

raw_ostream::~raw_ostream() { … }

size_t raw_ostream::preferred_buffer_size() const { … }

void raw_ostream::SetBuffered() { … }

void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
                                   BufferKind Mode) { … }

raw_ostream &raw_ostream::operator<<(unsigned long N) { … }

raw_ostream &raw_ostream::operator<<(long N) { … }

raw_ostream &raw_ostream::operator<<(unsigned long long N) { … }

raw_ostream &raw_ostream::operator<<(long long N) { … }

raw_ostream &raw_ostream::write_hex(unsigned long long N) { … }

raw_ostream &raw_ostream::operator<<(Colors C) { … }

raw_ostream &raw_ostream::write_uuid(const uuid_t UUID) { … }


raw_ostream &raw_ostream::write_escaped(StringRef Str,
                                        bool UseHexEscapes) { … }

raw_ostream &raw_ostream::operator<<(const void *P) { … }

raw_ostream &raw_ostream::operator<<(double N) { … }

void raw_ostream::flush_nonempty() { … }

raw_ostream &raw_ostream::write(unsigned char C) { … }

raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) { … }

void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) { … }

// Formatted output.
raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) { … }

raw_ostream &raw_ostream::operator<<(const formatv_object_base &Obj) { … }

raw_ostream &raw_ostream::operator<<(const FormattedString &FS) { … }

raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) { … }

raw_ostream &raw_ostream::operator<<(const FormattedBytes &FB) { … }

template <char C>
static raw_ostream &write_padding(raw_ostream &OS, unsigned NumChars) { … }

/// indent - Insert 'NumSpaces' spaces.
raw_ostream &raw_ostream::indent(unsigned NumSpaces) { … }

/// write_zeros - Insert 'NumZeros' nulls.
raw_ostream &raw_ostream::write_zeros(unsigned NumZeros) { … }

bool raw_ostream::prepare_colors() { … }

raw_ostream &raw_ostream::changeColor(enum Colors colors, bool bold, bool bg) { … }

raw_ostream &raw_ostream::resetColor() { … }

raw_ostream &raw_ostream::reverseColor() { … }

void raw_ostream::anchor() { … }

//===----------------------------------------------------------------------===//
//  Formatted Output
//===----------------------------------------------------------------------===//

// Out of line virtual method.
void format_object_base::home() { … }

//===----------------------------------------------------------------------===//
//  raw_fd_ostream
//===----------------------------------------------------------------------===//

static int getFD(StringRef Filename, std::error_code &EC,
                 sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
                 sys::fs::OpenFlags Flags) { … }

raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC)
    : … { … }

raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
                               sys::fs::CreationDisposition Disp)
    : … { … }

raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
                               sys::fs::FileAccess Access)
    : … { … }

raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
                               sys::fs::OpenFlags Flags)
    : … { … }

raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
                               sys::fs::CreationDisposition Disp,
                               sys::fs::FileAccess Access,
                               sys::fs::OpenFlags Flags)
    : … { … }

/// FD is the file descriptor that this writes to.  If ShouldClose is true, this
/// closes the file when the stream is destroyed.
raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered,
                               OStreamKind K)
    : … { … }

raw_fd_ostream::~raw_fd_ostream() { … }

#if defined(_WIN32)
// The most reliable way to print unicode in a Windows console is with
// WriteConsoleW. To use that, first transcode from UTF-8 to UTF-16. This
// assumes that LLVM programs always print valid UTF-8 to the console. The data
// might not be UTF-8 for two major reasons:
// 1. The program is printing binary (-filetype=obj -o -), in which case it
// would have been gibberish anyway.
// 2. The program is printing text in a semi-ascii compatible codepage like
// shift-jis or cp1252.
//
// Most LLVM programs don't produce non-ascii text unless they are quoting
// user source input. A well-behaved LLVM program should either validate that
// the input is UTF-8 or transcode from the local codepage to UTF-8 before
// quoting it. If they don't, this may mess up the encoding, but this is still
// probably the best compromise we can make.
static bool write_console_impl(int FD, StringRef Data) {
  SmallVector<wchar_t, 256> WideText;

  // Fall back to ::write if it wasn't valid UTF-8.
  if (auto EC = sys::windows::UTF8ToUTF16(Data, WideText))
    return false;

  // On Windows 7 and earlier, WriteConsoleW has a low maximum amount of data
  // that can be written to the console at a time.
  size_t MaxWriteSize = WideText.size();
  if (!RunningWindows8OrGreater())
    MaxWriteSize = 32767;

  size_t WCharsWritten = 0;
  do {
    size_t WCharsToWrite =
        std::min(MaxWriteSize, WideText.size() - WCharsWritten);
    DWORD ActuallyWritten;
    bool Success =
        ::WriteConsoleW((HANDLE)::_get_osfhandle(FD), &WideText[WCharsWritten],
                        WCharsToWrite, &ActuallyWritten,
                        /*Reserved=*/nullptr);

    // The most likely reason for WriteConsoleW to fail is that FD no longer
    // points to a console. Fall back to ::write. If this isn't the first loop
    // iteration, something is truly wrong.
    if (!Success)
      return false;

    WCharsWritten += ActuallyWritten;
  } while (WCharsWritten != WideText.size());
  return true;
}
#endif

void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) { … }

void raw_fd_ostream::close() { … }

uint64_t raw_fd_ostream::seek(uint64_t off) { … }

void raw_fd_ostream::pwrite_impl(const char *Ptr, size_t Size,
                                 uint64_t Offset) { … }

size_t raw_fd_ostream::preferred_buffer_size() const { … }

bool raw_fd_ostream::is_displayed() const { … }

bool raw_fd_ostream::has_colors() const { … }

Expected<sys::fs::FileLocker> raw_fd_ostream::lock() { … }

Expected<sys::fs::FileLocker>
raw_fd_ostream::tryLockFor(Duration const& Timeout) { … }

void raw_fd_ostream::anchor() { … }

//===----------------------------------------------------------------------===//
//  outs(), errs(), nulls()
//===----------------------------------------------------------------------===//

raw_fd_ostream &llvm::outs() { … }

raw_fd_ostream &llvm::errs() { … }

/// nulls() - This returns a reference to a raw_ostream which discards output.
raw_ostream &llvm::nulls() { … }

//===----------------------------------------------------------------------===//
// File Streams
//===----------------------------------------------------------------------===//

raw_fd_stream::raw_fd_stream(StringRef Filename, std::error_code &EC)
    : … { … }

raw_fd_stream::raw_fd_stream(int fd, bool shouldClose)
    : … { … }

ssize_t raw_fd_stream::read(char *Ptr, size_t Size) { … }

bool raw_fd_stream::classof(const raw_ostream *OS) { … }

//===----------------------------------------------------------------------===//
//  raw_string_ostream
//===----------------------------------------------------------------------===//

void raw_string_ostream::write_impl(const char *Ptr, size_t Size) { … }

//===----------------------------------------------------------------------===//
//  raw_svector_ostream
//===----------------------------------------------------------------------===//

uint64_t raw_svector_ostream::current_pos() const { … }

void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) { … }

void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size,
                                      uint64_t Offset) { … }

bool raw_svector_ostream::classof(const raw_ostream *OS) { … }

//===----------------------------------------------------------------------===//
//  raw_null_ostream
//===----------------------------------------------------------------------===//

raw_null_ostream::~raw_null_ostream() { … }

void raw_null_ostream::write_impl(const char *Ptr, size_t Size) { … }

uint64_t raw_null_ostream::current_pos() const { … }

void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size,
                                   uint64_t Offset) { … }

void raw_pwrite_stream::anchor() { … }

void buffer_ostream::anchor() { … }

void buffer_unique_ostream::anchor() { … }

Error llvm::writeToOutput(StringRef OutputFileName,
                          std::function<Error(raw_ostream &)> Write) { … }
llvm/llvm/lib/Support/raw_ostream.cpp
