Terminal.h   [plain text]

//===-- Terminal.h ----------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef liblldb_Terminal_h_
#define liblldb_Terminal_h_
#if defined(__cplusplus)

#include "lldb/lldb-private.h"

struct termios;

namespace lldb_private {

class Terminal
{
public:

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

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

    bool
    SetEcho (bool enabled);

    bool
    SetCanonical (bool enabled);

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


//----------------------------------------------------------------------
/// @class State Terminal.h "lldb/Host/Terminal.h"
/// @brief A 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:
    //------------------------------------------------------------------
    /// Default constructor
    //------------------------------------------------------------------
    TerminalState();

    //------------------------------------------------------------------
    /// Destructor
    //------------------------------------------------------------------
    ~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] fd
    ///     The file descriptor to save the state of.
    ///
    /// @param[in] save_process_group
    ///     If \b true, save the process group settings, else do not
    ///     save the process group setttings 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 (int fd, 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;

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;       ///< Cached tflags information.
    std::auto_ptr<struct termios> m_termios_ap; ///< Cached terminal state information.
    lldb::pid_t     m_process_group;///< Cached process group information.

};

//----------------------------------------------------------------------
/// @class TerminalStateSwitcher Terminal.h "lldb/Host/Terminal.h"
/// @brief A TTY state switching class.
///
/// This class can be used to remember 2 TTY states for a given file
/// descriptor and switch between the two states.
//----------------------------------------------------------------------
class TerminalStateSwitcher
{
public:
    //------------------------------------------------------------------
    /// Constructor
    //------------------------------------------------------------------
    TerminalStateSwitcher();

    //------------------------------------------------------------------
    /// Destructor
    //------------------------------------------------------------------
    ~TerminalStateSwitcher();

    //------------------------------------------------------------------
    /// Get the number of possible states to save.
    ///
    /// @return
    ///     The number of states that this TTY switcher object contains.
    //------------------------------------------------------------------
    uint32_t
    GetNumberOfStates() const;

    //------------------------------------------------------------------
    /// Restore the TTY state for state at index \a idx.
    ///
    /// @return
    ///     Returns \b true if the TTY state was successfully restored,
    ///     \b false otherwise.
    //------------------------------------------------------------------
    bool
    Restore (uint32_t idx) const;

    //------------------------------------------------------------------
    /// Save the TTY state information for the state at index \a idx.
    /// The TTY state is saved for the file descriptor \a fd and
    /// the process group information will also be saved if requested
    /// by \a save_process_group.
    ///
    /// @param[in] idx
    ///     The index into the state array where the state should be
    ///     saved.
    ///
    /// @param[in] fd
    ///     The file descriptor for which to save the settings.
    ///
    /// @param[in] save_process_group
    ///     If \b true, save the process group information for the TTY.
    ///
    /// @return
    ///     Returns \b true if the save was successful, \b false
    ///     otherwise.
    //------------------------------------------------------------------
    bool
    Save (uint32_t idx, int fd, bool save_process_group);

protected:
    //------------------------------------------------------------------
    // Member variables
    //------------------------------------------------------------------
    mutable uint32_t m_currentState; ///< The currently active TTY state index.
    TerminalState m_ttystates[2]; ///< The array of TTY states that holds saved TTY info.
};

} // namespace lldb_private

#endif  // #if defined(__cplusplus)
#endif  // #ifndef liblldb_Terminal_h_