//===----------------------------------------------------------------------===//
#include <climits>
+#include <codecvt>
#include <iomanip>
#include "lldb/Host/Editline.h"
#define ANSI_UP_N_ROWS ESCAPE "[%dA"
#define ANSI_DOWN_N_ROWS ESCAPE "[%dB"
-#if LLDB_EDITLINE_USE_WCHAR
-
-#define EditLineConstString(str) L##str
-#define EditLineStringFormatSpec "%ls"
-
-#else
-
#define EditLineConstString(str) str
#define EditLineStringFormatSpec "%s"
-// use #defines so wide version functions and structs will resolve to old
-// versions for case of libedit not built with wide char support
-#define history_w history
-#define history_winit history_init
-#define history_wend history_end
-#define HistoryW History
-#define HistEventW HistEvent
-#define LineInfoW LineInfo
-
-#define el_wgets el_gets
-#define el_wgetc el_getc
-#define el_wpush el_push
-#define el_wparse el_parse
-#define el_wset el_set
-#define el_wget el_get
-#define el_wline el_line
-#define el_winsertstr el_insertstr
-#define el_wdeletestr el_deletestr
-
-#endif // #if LLDB_EDITLINE_USE_WCHAR
-
-bool IsOnlySpaces(const EditLineStringType &content) {
- for (wchar_t ch : content) {
- if (ch != EditLineCharType(' '))
+bool IsOnlySpaces(const std::string &content) {
+ for (char ch : content) {
+ if (ch != ' ')
return false;
}
return true;
llvm_unreachable("Fully covered switch!");
}
-
-EditLineStringType CombineLines(const std::vector<EditLineStringType> &lines) {
- EditLineStringStreamType combined_stream;
- for (EditLineStringType line : lines) {
+std::string CombineLines(const std::vector<std::string> &lines) {
+ std::stringstream combined_stream;
+ for (const std::string &line : lines) {
combined_stream << line.c_str() << "\n";
}
return combined_stream.str();
}
-std::vector<EditLineStringType> SplitLines(const EditLineStringType &input) {
- std::vector<EditLineStringType> result;
+std::vector<std::string> SplitLines(const std::string &input) {
+ std::vector<std::string> result;
size_t start = 0;
while (start < input.length()) {
size_t end = input.find('\n', start);
return result;
}
-EditLineStringType FixIndentation(const EditLineStringType &line,
- int indent_correction) {
+std::string FixIndentation(const std::string &line, int indent_correction) {
if (indent_correction == 0)
return line;
if (indent_correction < 0)
return line.substr(-indent_correction);
- return EditLineStringType(indent_correction, EditLineCharType(' ')) + line;
+ return std::string(indent_correction, ' ') + line;
}
-int GetIndentation(const EditLineStringType &line) {
- int space_count = 0;
- for (EditLineCharType ch : line) {
- if (ch != EditLineCharType(' '))
- break;
- ++space_count;
- }
- return space_count;
+int GetIndentation(const std::string &line) {
+ auto firstNonSpace = std::find_if(line.begin(), line.end(),
+ [](const char ch) { return ch != ' '; });
+ return firstNonSpace - line.begin();
}
bool IsInputPending(FILE *file) {
// these objects
EditlineHistory(const std::string &prefix, uint32_t size, bool unique_entries)
: m_history(nullptr), m_event(), m_prefix(prefix), m_path() {
- m_history = history_winit();
- history_w(m_history, &m_event, H_SETSIZE, size);
+ m_history = history_init();
+ history(m_history, &m_event, H_SETSIZE, size);
if (unique_entries)
- history_w(m_history, &m_event, H_SETUNIQUE, 1);
+ history(m_history, &m_event, H_SETUNIQUE, 1);
}
const char *GetHistoryFilePath() {
// LLDB stores its history in ~/.lldb/. If for some reason this directory
// isn't writable or cannot be created, history won't be available.
if (!llvm::sys::fs::create_directory(lldb_history_file)) {
-#if LLDB_EDITLINE_USE_WCHAR
- std::string filename = m_prefix + "-widehistory";
-#else
std::string filename = m_prefix + "-history";
-#endif
llvm::sys::path::append(lldb_history_file, filename);
m_path = std::string(lldb_history_file.str());
}
Save();
if (m_history) {
- history_wend(m_history);
+ history_end(m_history);
m_history = nullptr;
}
}
bool IsValid() const { return m_history != nullptr; }
- HistoryW *GetHistoryPtr() { return m_history; }
+ History *GetHistoryPtr() { return m_history; }
- void Enter(const EditLineCharType *line_cstr) {
+ void Enter(const char *line_cstr) {
if (m_history)
- history_w(m_history, &m_event, H_ENTER, line_cstr);
+ history(m_history, &m_event, H_ENTER, line_cstr);
}
bool Load() {
if (m_history) {
const char *path = GetHistoryFilePath();
if (path) {
- history_w(m_history, &m_event, H_LOAD, path);
+ history(m_history, &m_event, H_LOAD, path);
return true;
}
}
if (m_history) {
const char *path = GetHistoryFilePath();
if (path) {
- history_w(m_history, &m_event, H_SAVE, path);
+ history(m_history, &m_event, H_SAVE, path);
return true;
}
}
}
protected:
- HistoryW *m_history; // The history object
- HistEventW m_event; // The history event needed to contain all history events
+ History *m_history; // The history object
+ HistEvent m_event; // The history event needed to contain all history events
std::string m_prefix; // The prefix name (usually the editline program name)
// to use when loading/saving history
std::string m_path; // Path to the history file
}
bool Editline::IsOnlySpaces() {
- const LineInfoW *info = el_wline(m_editline);
- for (const EditLineCharType *character = info->buffer;
- character < info->lastchar; character++) {
+ const LineInfo *info = el_line(m_editline);
+ for (const char *character = info->buffer; character < info->lastchar;
+ character++) {
if (*character != ' ')
return false;
}
}
void Editline::MoveCursor(CursorLocation from, CursorLocation to) {
- const LineInfoW *info = el_wline(m_editline);
+ const LineInfo *info = el_line(m_editline);
int editline_cursor_position =
(int)((info->cursor - info->buffer) + GetPromptWidth());
int editline_cursor_row = editline_cursor_position / m_terminal_width;
const char *unfaint = m_color_prompts ? ANSI_UNFAINT : "";
for (int index = firstIndex; index < line_count; index++) {
- fprintf(m_output_file, "%s"
- "%s"
- "%s" EditLineStringFormatSpec " ",
+ fprintf(m_output_file,
+ "%s"
+ "%s"
+ "%s%s ",
faint, PromptForIndex(index).c_str(), unfaint,
m_input_lines[index].c_str());
if (index < line_count - 1)
}
}
-int Editline::CountRowsForLine(const EditLineStringType &content) {
+int Editline::CountRowsForLine(const std::string &content) {
std::string prompt =
PromptForIndex(0); // Prompt width is constant during an edit session
int line_length = (int)(content.length() + prompt.length());
}
void Editline::SaveEditedLine() {
- const LineInfoW *info = el_wline(m_editline);
+ const LineInfo *info = el_line(m_editline);
m_input_lines[m_current_line_index] =
- EditLineStringType(info->buffer, info->lastchar - info->buffer);
+ std::string(info->buffer, info->lastchar - info->buffer);
}
StringList Editline::GetInputAsStringList(int line_count) {
StringList lines;
- for (EditLineStringType line : m_input_lines) {
+ for (std::string line : m_input_lines) {
if (line_count == 0)
break;
-#if LLDB_EDITLINE_USE_WCHAR
- lines.AppendString(m_utf8conv.to_bytes(line));
-#else
lines.AppendString(line);
-#endif
--line_count;
}
return lines;
if (!m_history_sp || !m_history_sp->IsValid())
return CC_ERROR;
- HistoryW *pHistory = m_history_sp->GetHistoryPtr();
- HistEventW history_event;
- std::vector<EditLineStringType> new_input_lines;
+ History *pHistory = m_history_sp->GetHistoryPtr();
+ HistEvent history_event;
+ std::vector<std::string> new_input_lines;
// Treat moving from the "live" entry differently
if (!m_in_history) {
case HistoryOperation::Newer:
return CC_ERROR; // Can't go newer than the "live" entry
case HistoryOperation::Older: {
- if (history_w(pHistory, &history_event,
- GetOperation(HistoryOperation::Newest)) == -1)
+ if (history(pHistory, &history_event,
+ GetOperation(HistoryOperation::Newest)) == -1)
return CC_ERROR;
// Save any edits to the "live" entry in case we return by moving forward
// in history (it would be more bash-like to save over any current entry,
llvm_unreachable("unsupported history direction");
}
} else {
- if (history_w(pHistory, &history_event, GetOperation(op)) == -1) {
+ if (history(pHistory, &history_event, GetOperation(op)) == -1) {
switch (op) {
case HistoryOperation::Older:
// Can't move earlier than the earliest entry.
return CC_NEWLINE;
}
-int Editline::GetCharacter(EditLineGetCharType *c) {
- const LineInfoW *info = el_wline(m_editline);
+int Editline::GetCharacter(wchar_t *c) {
+ const LineInfo *info = el_line(m_editline);
// Paint a faint version of the desired prompt over the version libedit draws
// (will only be requested if colors are supported)
unsigned char Editline::BreakLineCommand(int ch) {
// Preserve any content beyond the cursor, truncate and save the current line
- const LineInfoW *info = el_wline(m_editline);
- auto current_line =
- EditLineStringType(info->buffer, info->cursor - info->buffer);
+ const LineInfo *info = el_line(m_editline);
+ auto current_line = std::string(info->buffer, info->cursor - info->buffer);
auto new_line_fragment =
- EditLineStringType(info->cursor, info->lastchar - info->cursor);
+ std::string(info->cursor, info->lastchar - info->cursor);
m_input_lines[m_current_line_index] = current_line;
// Ignore whitespace-only extra fragments when breaking a line
if (::IsOnlySpaces(new_line_fragment))
- new_line_fragment = EditLineConstString("");
+ new_line_fragment = "";
// Establish the new cursor position at the start of a line when inserting a
// line break
// Apply smart indentation
if (m_fix_indentation_callback) {
StringList lines = GetInputAsStringList(m_current_line_index + 1);
-#if LLDB_EDITLINE_USE_WCHAR
- lines.AppendString(m_utf8conv.to_bytes(new_line_fragment));
-#else
lines.AppendString(new_line_fragment);
-#endif
int indent_correction = m_fix_indentation_callback(this, lines, 0);
new_line_fragment = FixIndentation(new_line_fragment, indent_correction);
// If this is the end of the last line, consider whether to add a line
// instead
- const LineInfoW *info = el_wline(m_editline);
+ const LineInfo *info = el_line(m_editline);
if (m_current_line_index == m_input_lines.size() - 1 &&
info->cursor == info->lastchar) {
if (m_is_input_complete_callback) {
// The completion test is allowed to change the input lines when complete
m_input_lines.clear();
for (unsigned index = 0; index < lines.GetSize(); index++) {
-#if LLDB_EDITLINE_USE_WCHAR
- m_input_lines.insert(m_input_lines.end(),
- m_utf8conv.from_bytes(lines[index]));
-#else
m_input_lines.insert(m_input_lines.end(), lines[index]);
-#endif
}
}
}
}
unsigned char Editline::DeleteNextCharCommand(int ch) {
- LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
+ LineInfo *info = const_cast<LineInfo *>(el_line(m_editline));
// Just delete the next character normally if possible
if (info->cursor < info->lastchar) {
MoveCursor(CursorLocation::EditingCursor, CursorLocation::EditingPrompt);
// Insert the next line of text at the cursor and restore the cursor position
- const EditLineCharType *cursor = info->cursor;
- el_winsertstr(m_editline, m_input_lines[m_current_line_index + 1].c_str());
+ const char *cursor = info->cursor;
+ el_insertstr(m_editline, m_input_lines[m_current_line_index + 1].c_str());
info->cursor = cursor;
SaveEditedLine();
}
unsigned char Editline::DeletePreviousCharCommand(int ch) {
- LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
+ const LineInfo *info = el_line(m_editline);
// Just delete the previous character normally when not at the start of a
// line
// Put the cursor back where libedit expects it to be before returning to
// editing by telling libedit about the newly inserted text
MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
- el_winsertstr(m_editline, priorLine.c_str());
+ el_insertstr(m_editline, priorLine.c_str());
return CC_REDISPLAY;
}
lines.AppendString("");
indentation = m_fix_indentation_callback(this, lines, 0);
}
- m_input_lines.insert(
- m_input_lines.end(),
- EditLineStringType(indentation, EditLineCharType(' ')));
+ m_input_lines.insert(m_input_lines.end(), std::string(indentation, ' '));
}
// Move down past the current line using newlines to force scrolling if
// needed
SetCurrentLine(m_current_line_index + 1);
- const LineInfoW *info = el_wline(m_editline);
+ const LineInfo *info = el_line(m_editline);
int cursor_position = (int)((info->cursor - info->buffer) + GetPromptWidth());
int cursor_row = cursor_position / m_terminal_width;
for (int line_count = 0; line_count < m_current_line_rows - cursor_row;
return CC_NORM;
// Insert the character typed before proceeding
- EditLineCharType inserted[] = {(EditLineCharType)ch, 0};
- el_winsertstr(m_editline, inserted);
- LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
+ char inserted[] = {(char)ch, 0};
+ el_insertstr(m_editline, inserted);
+ const LineInfo *info = el_line(m_editline);
int cursor_position = info->cursor - info->buffer;
// Save the edits and determine the correct indentation level
} else {
currentLine = currentLine.erase(0, -indent_correction);
}
-#if LLDB_EDITLINE_USE_WCHAR
- m_input_lines[m_current_line_index] = m_utf8conv.from_bytes(currentLine);
-#else
m_input_lines[m_current_line_index] = currentLine;
-#endif
// Update the display to reflect the change
MoveCursor(CursorLocation::EditingCursor, CursorLocation::EditingPrompt);
}
unsigned char Editline::RevertLineCommand(int ch) {
- el_winsertstr(m_editline, m_input_lines[m_current_line_index].c_str());
+ el_insertstr(m_editline, m_input_lines[m_current_line_index].c_str());
if (m_revert_cursor_index >= 0) {
- LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
+ LineInfo *info = const_cast<LineInfo *>(el_line(m_editline));
info->cursor = info->buffer + m_revert_cursor_index;
if (info->cursor > info->lastchar) {
info->cursor = info->lastchar;
return CC_REDISPLAY;
}
-void Editline::AddFunctionToEditLine(const EditLineCharType *command,
- const EditLineCharType *helptext,
+void Editline::AddFunctionToEditLine(const char *command, const char *helptext,
EditlineCommandCallbackType callbackFn) {
- el_wset(m_editline, EL_ADDFN, command, helptext, callbackFn);
+ el_set(m_editline, EL_ADDFN, command, helptext, callbackFn);
}
void Editline::SetEditLinePromptCallback(
if (!m_history_sp->Load()) {
fputs("Could not load history file\n.", m_output_file);
}
- el_wset(m_editline, EL_HIST, history, m_history_sp->GetHistoryPtr());
+ el_set(m_editline, EL_HIST, history, m_history_sp->GetHistoryPtr());
}
el_set(m_editline, EL_CLIENTDATA, this);
el_set(m_editline, EL_SIGNAL, 0);
el_set(m_editline, EL_EDITOR, "emacs");
- SetGetCharacterFunction([](EditLine *editline, EditLineGetCharType *c) {
+ SetGetCharacterFunction([](EditLine *editline, wchar_t *c) {
return Editline::InstanceFor(editline)->GetCharacter(c);
});
// Commands used for multiline support, registered whether or not they're
// used
AddFunctionToEditLine(
- EditLineConstString("lldb-break-line"),
- EditLineConstString("Insert a line break"),
- [](EditLine *editline, int ch) {
+ "lldb-break-line", "Insert a line break", [](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->BreakLineCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-end-or-add-line"),
- EditLineConstString("End editing or continue when incomplete"),
+ "lldb-end-or-add-line", "End editing or continue when incomplete",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->EndOrAddLineCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-delete-next-char"),
- EditLineConstString("Delete next character"),
+ "lldb-delete-next-char", "Delete next character",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->DeleteNextCharCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-delete-previous-char"),
- EditLineConstString("Delete previous character"),
+ "lldb-delete-previous-char", "Delete previous character",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->DeletePreviousCharCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-previous-line"),
- EditLineConstString("Move to previous line"),
+ "lldb-previous-line", "Move to previous line",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->PreviousLineCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-next-line"),
- EditLineConstString("Move to next line"), [](EditLine *editline, int ch) {
+ "lldb-next-line", "Move to next line", [](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->NextLineCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-previous-history"),
- EditLineConstString("Move to previous history"),
+ "lldb-previous-history", "Move to previous history",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->PreviousHistoryCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-next-history"),
- EditLineConstString("Move to next history"),
+ "lldb-next-history", "Move to next history",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->NextHistoryCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-buffer-start"),
- EditLineConstString("Move to start of buffer"),
+ "lldb-buffer-start", "Move to start of buffer",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->BufferStartCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-buffer-end"),
- EditLineConstString("Move to end of buffer"),
+ "lldb-buffer-end", "Move to end of buffer",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->BufferEndCommand(ch);
});
AddFunctionToEditLine(
- EditLineConstString("lldb-fix-indentation"),
- EditLineConstString("Fix line indentation"),
+ "lldb-fix-indentation", "Fix line indentation",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->FixIndentationCommand(ch);
});
int ch) {
return Editline::InstanceFor(editline)->TabCommand(ch);
};
- AddFunctionToEditLine(EditLineConstString("lldb-complete"),
- EditLineConstString("Invoke completion"),
+ AddFunctionToEditLine("lldb-complete", "Invoke completion",
complete_callback);
- AddFunctionToEditLine(EditLineConstString("lldb_complete"),
- EditLineConstString("Invoke completion"),
+ AddFunctionToEditLine("lldb_complete", "Invoke completion",
complete_callback);
// General bindings we don't mind being overridden
if (m_suggestion_callback) {
AddFunctionToEditLine(
- EditLineConstString("lldb-apply-complete"),
- EditLineConstString("Adopt autocompletion"),
+ "lldb-apply-complete", "Adopt autocompletion",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->ApplyAutosuggestCommand(ch);
});
NULL); // Apply a part that is suggested automatically
AddFunctionToEditLine(
- EditLineConstString("lldb-typed-character"),
- EditLineConstString("Typed character"),
+ "lldb-typed-character", "Typed character",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->TypedCharacter(ch);
});
// Register an internal binding that external developers shouldn't use
AddFunctionToEditLine(
- EditLineConstString("lldb-revert-line"),
- EditLineConstString("Revert line to saved state"),
+ "lldb-revert-line", "Revert line to saved state",
[](EditLine *editline, int ch) {
return Editline::InstanceFor(editline)->RevertLineCommand(ch);
});
if (el_get(m_editline, EL_GETTC, "co", &columns, nullptr) == 0) {
m_terminal_width = columns;
if (m_current_line_rows != -1) {
- const LineInfoW *info = el_wline(m_editline);
+ const LineInfo *info = el_line(m_editline);
int lineLength =
(int)((info->lastchar - info->buffer) + GetPromptWidth());
m_current_line_rows = (lineLength / columns) + 1;
bool Editline::GetLine(std::string &line, bool &interrupted) {
ConfigureEditor(false);
- m_input_lines = std::vector<EditLineStringType>();
- m_input_lines.insert(m_input_lines.begin(), EditLineConstString(""));
+ m_input_lines = std::vector<std::string>();
+ m_input_lines.insert(m_input_lines.begin(), "");
std::lock_guard<std::mutex> guard(m_output_mutex);
m_revert_cursor_index = -1;
int count;
- auto input = el_wgets(m_editline, &count);
+ auto input = el_gets(m_editline, &count);
interrupted = m_editor_status == EditorStatus::Interrupted;
if (!interrupted) {
m_editor_status = EditorStatus::EndOfInput;
} else {
m_history_sp->Enter(input);
-#if LLDB_EDITLINE_USE_WCHAR
- line = m_utf8conv.to_bytes(SplitLines(input)[0]);
-#else
line = SplitLines(input)[0];
-#endif
m_editor_status = EditorStatus::Complete;
}
}
// Print the initial input lines, then move the cursor back up to the start
// of input
SetBaseLineNumber(first_line_number);
- m_input_lines = std::vector<EditLineStringType>();
- m_input_lines.insert(m_input_lines.begin(), EditLineConstString(""));
+ m_input_lines = std::vector<std::string>();
+ m_input_lines.insert(m_input_lines.begin(), "");
std::lock_guard<std::mutex> guard(m_output_mutex);
// Begin the line editing loop
while (m_editor_status == EditorStatus::Editing) {
int count;
m_current_line_rows = -1;
- el_wpush(m_editline, EditLineConstString(
- "\x1b[^")); // Revert to the existing line content
- el_wgets(m_editline, &count);
+ el_push(m_editline, "\x1b[^"); // Revert to the existing line content
+ el_gets(m_editline, &count);
}
interrupted = m_editor_status == EditorStatus::Interrupted;
}
}
-bool Editline::CompleteCharacter(char ch, EditLineGetCharType &out) {
-#if !LLDB_EDITLINE_USE_WCHAR
- if (ch == (char)EOF)
- return false;
-
- out = (unsigned char)ch;
- return true;
-#else
+bool Editline::CompleteCharacter(char ch, wchar_t &out) {
std::codecvt_utf8<wchar_t> cvt;
llvm::SmallString<4> input;
for (;;) {
break;
}
}
-#endif
}
projects / platform / upstream / llvm.git / commitdiff