Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===-- llvm/LineEditor/LineEditor.h - line editor --------------*- 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 LLVM_LINEEDITOR_LINEEDITOR_H

#define LLVM_LINEEDITOR_LINEEDITOR_H

#include "llvm/ADT/StringRef.h"

#include <cstdio>

#include <memory>

#include <optional>

#include <string>

#include <utility>

#include <vector>

namespace llvm {

class LineEditor {

public:

  /// Create a LineEditor object.

  ///

  /// \param ProgName The name of the current program. Used to form a default

  /// prompt.

  /// \param HistoryPath Path to the file in which to store history data, if

  /// possible.

  /// \param In The input stream used by the editor.

  /// \param Out The output stream used by the editor.

  /// \param Err The error stream used by the editor.

  LineEditor(StringRef ProgName, StringRef HistoryPath = "", FILE *In = stdin,

             FILE *Out = stdout, FILE *Err = stderr);

  ~LineEditor();

  /// Reads a line.

  ///

  /// \return The line, or std::optional<std::string>() on EOF.

  std::optional<std::string> readLine() const;

  void saveHistory();

  void loadHistory();

  static std::string getDefaultHistoryPath(StringRef ProgName);

  /// The action to perform upon a completion request.

  struct CompletionAction {

    enum ActionKind {

      /// Insert Text at the cursor position.

      AK_Insert,

      /// Show Completions, or beep if the list is empty.

      AK_ShowCompletions

    };

    ActionKind Kind;

    /// The text to insert.

    std::string Text;

    /// The list of completions to show.

    std::vector<std::string> Completions;

  };

  /// A possible completion at a given cursor position.

  struct Completion {

    Completion() = default;

    Completion(const std::string &TypedText, const std::string &DisplayText)

        : TypedText(TypedText), DisplayText(DisplayText) {}

    /// The text to insert. If the user has already input some of the

    /// completion, this should only include the rest of the text.

    std::string TypedText;

    /// A description of this completion. This may be the completion itself, or

    /// maybe a summary of its type or arguments.

    std::string DisplayText;

  };

  /// Set the completer for this LineEditor. A completer is a function object

  /// which takes arguments of type StringRef (the string to complete) and

  /// size_t (the zero-based cursor position in the StringRef) and returns a

  /// CompletionAction.

  template <typename T> void setCompleter(T Comp) {

    Completer.reset(new CompleterModel<T>(Comp));

  }

  /// Set the completer for this LineEditor to the given list completer.

  /// A list completer is a function object which takes arguments of type

  /// StringRef (the string to complete) and size_t (the zero-based cursor

  /// position in the StringRef) and returns a std::vector<Completion>.

  template <typename T> void setListCompleter(T Comp) {

    Completer.reset(new ListCompleterModel<T>(Comp));

  }

  /// Use the current completer to produce a CompletionAction for the given

  /// completion request. If the current completer is a list completer, this

  /// will return an AK_Insert CompletionAction if each completion has a common

  /// prefix, or an AK_ShowCompletions CompletionAction otherwise.

  ///

  /// \param Buffer The string to complete

  /// \param Pos The zero-based cursor position in the StringRef

  CompletionAction getCompletionAction(StringRef Buffer, size_t Pos) const;

  const std::string &getPrompt() const { return Prompt; }

  void setPrompt(const std::string &P) { Prompt = P; }

  // Public so callbacks in LineEditor.cpp can use it.

  struct InternalData;

private:

  std::string Prompt;

  std::string HistoryPath;

  std::unique_ptr<InternalData> Data;

  struct CompleterConcept {

    virtual ~CompleterConcept();

    virtual CompletionAction complete(StringRef Buffer, size_t Pos) const = 0;

  };

  struct ListCompleterConcept : CompleterConcept {

    ~ListCompleterConcept() override;

    CompletionAction complete(StringRef Buffer, size_t Pos) const override;

    static std::string getCommonPrefix(const std::vector<Completion> &Comps);

    virtual std::vector<Completion> getCompletions(StringRef Buffer,

                                                   size_t Pos) const = 0;

  };

  template <typename T>

  struct CompleterModel : CompleterConcept {

    CompleterModel(T Value) : Value(Value) {}

    CompletionAction complete(StringRef Buffer, size_t Pos) const override {

      return Value(Buffer, Pos);

    }

    T Value;

  };

  template <typename T>

  struct ListCompleterModel : ListCompleterConcept {

    ListCompleterModel(T Value) : Value(std::move(Value)) {}

    std::vector<Completion> getCompletions(StringRef Buffer,

                                           size_t Pos) const override {

      return Value(Buffer, Pos);

    }

    T Value;

  };

  std::unique_ptr<const CompleterConcept> Completer;

};

}

#endif