//===-- Terminal.h ----------------------------------------------*- C++ -*-===//

//

// 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

//

//===----------------------------------------------------------------------===//

#ifndef LLDB_HOST_TERMINAL_H

#define LLDB_HOST_TERMINAL_H

#include "lldb/lldb-private.h"

#include "llvm/Support/Error.h"

namespace lldb_private {

class TerminalState;

class Terminal {

public:

  enum class Parity {

    No,

    Even,

    Odd,

    Space,

    Mark,

  };

  enum class ParityCheck {

    // No parity checking

    No,

    // Replace erraneous bytes with NUL

    ReplaceWithNUL,

    // Ignore erraneous bytes

    Ignore,

    // Mark erraneous bytes by prepending them with \xFF\x00; real \xFF

    // is escaped to \xFF\xFF

    Mark,

  };

  Terminal(int fd = -1) : m_fd(fd) {}

  ~Terminal() = default;

  bool IsATerminal() const;

  int GetFileDescriptor() const { return m_fd; }

  void SetFileDescriptor(int fd) { m_fd = fd; }

  bool FileDescriptorIsValid() const { return m_fd != -1; }

  void Clear() { m_fd = -1; }

  llvm::Error SetEcho(bool enabled);

  llvm::Error SetCanonical(bool enabled);

  llvm::Error SetRaw();

  llvm::Error SetBaudRate(unsigned int baud_rate);

  llvm::Error SetStopBits(unsigned int stop_bits);

  llvm::Error SetParity(Parity parity);

  llvm::Error SetParityCheck(ParityCheck parity_check);

  llvm::Error SetHardwareFlowControl(bool enabled);

protected:

  struct Data;

  int m_fd; // This may or may not be a terminal file descriptor

  llvm::Expected<Data> GetData();

  llvm::Error SetData(const Data &data);

  friend class TerminalState;

};

/// \class TerminalState Terminal.h "lldb/Host/Terminal.h"

/// A RAII-friendly terminal state saving/restoring class.

///

/// This class can be used to remember the terminal state for a file

/// descriptor and later restore that state as it originally was.

class TerminalState {

public:

  /// Construct a new instance and optionally save terminal state.

  ///

  /// \param[in] term

  ///     The Terminal instance holding the file descriptor to save the state

  ///     of.  If the instance is not associated with a fd, no state will

  ///     be saved.

  ///

  /// \param[in] save_process_group

  ///     If \b true, save the process group settings, else do not

  ///     save the process group settings for a TTY.

  TerminalState(Terminal term = -1, bool save_process_group = false);

  /// Destroy the instance, restoring terminal state if saved.  If restoring

  /// state is undesirable, the instance needs to be reset before destruction.

  ~TerminalState();

  /// Save the TTY state for \a fd.

  ///

  /// Save the current state of the TTY for the file descriptor "fd" and if

  /// "save_process_group" is true, attempt to save the process group info for

  /// the TTY.

  ///

  /// \param[in] term

  ///     The Terminal instance holding fd to save.

  ///

  /// \param[in] save_process_group

  ///     If \b true, save the process group settings, else do not

  ///     save the process group settings for a TTY.

  ///

  /// \return

  ///     Returns \b true if \a fd describes a TTY and if the state

  ///     was able to be saved, \b false otherwise.

  bool Save(Terminal term, bool save_process_group);

  /// Restore the TTY state to the cached state.

  ///

  /// Restore the state of the TTY using the cached values from a previous

  /// call to TerminalState::Save(int,bool).

  ///

  /// \return

  ///     Returns \b true if the TTY state was successfully restored,

  ///     \b false otherwise.

  bool Restore() const;

  /// Test for valid cached TTY state information.

  ///

  /// \return

  ///     Returns \b true if this object has valid saved TTY state

  ///     settings that can be used to restore a previous state,

  ///     \b false otherwise.

  bool IsValid() const;

  void Clear();

protected:

  /// Test if tflags is valid.

  ///

  /// \return

  ///     Returns \b true if \a m_tflags is valid and can be restored,

  ///     \b false otherwise.

  bool TFlagsIsValid() const;

  /// Test if ttystate is valid.

  ///

  /// \return

  ///     Returns \b true if \a m_ttystate is valid and can be

  ///     restored, \b false otherwise.

  bool TTYStateIsValid() const;

  /// Test if the process group information is valid.

  ///

  /// \return

  ///     Returns \b true if \a m_process_group is valid and can be

  ///     restored, \b false otherwise.

  bool ProcessGroupIsValid() const;

  // Member variables

  Terminal m_tty;                         ///< A terminal

  int m_tflags = -1;                      ///< Cached tflags information.

  std::unique_ptr<Terminal::Data> m_data; ///< Platform-specific implementation.

  lldb::pid_t m_process_group = -1;       ///< Cached process group information.

};

} // namespace lldb_private

#endif // LLDB_HOST_TERMINAL_H