Readline interface: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|REXX}}: changed/added comments and whitespace, changed indentations.) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (24 intermediate revisions by 11 users not shown) | |||
Line 1:
{{draft task|
A readline interface is a line editing facility that provides auto completion facilities and the ability to recall previously typed lines. Build a simple application that accepts at least two commands and uses a readline style interface.
Line 16:
__TOC__
=={{header|11l}}==
{{trans|D}}
<syntaxhighlight lang="11l">[String] histArr
F hello()
print(‘Hello World!’)
:histArr [+]= ‘hello’
F hist()
I :histArr.empty
print(‘No history’)
E
L(cmd) :histArr
print(‘ - ’cmd)
:histArr [+]= ‘hist’
F help()
print(‘Available commands:’)
print(‘ hello’)
print(‘ hist’)
print(‘ exit’)
print(‘ help’)
:histArr [+]= ‘help’
[String = (() -> N)] aa
aa[‘help’] = help
aa[‘hist’] = hist
aa[‘hello’] = hello
print(‘Enter a command, type help for a listing.’)
L
V line = input(‘>’)
I line == ‘exit’
L.break
aa.get(line, help)()</syntaxhighlight>
=={{header|C}}==
A program that does absolutely nothing. Type 'help' for help.
<
#include <readline/history.h>
#include <string.h>
Line 43 ⟶ 81:
puts("Yes...?");
}
}</
=={{header|C sharp|C#}}==
{{trans|D}}
<syntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace ReadlineInterface {
class Program {
static LinkedList<string> histArr = new LinkedList<string>();
static void AppendHistory([CallerMemberName] string name = "unknown") {
histArr.AddLast(name);
}
static void Hist() {
if (histArr.Count == 0) {
Console.WriteLine("No history");
}
else {
foreach (string cmd in histArr) {
Console.WriteLine(" - {0}", cmd);
}
}
AppendHistory();
}
static void Hello() {
Console.WriteLine("Hello World!");
AppendHistory();
}
static void Help() {
Console.WriteLine("Available commands:");
Console.WriteLine(" hello");
Console.WriteLine(" hist");
Console.WriteLine(" exit");
Console.WriteLine(" help");
AppendHistory();
}
static void Main(string[] args) {
Dictionary<string, Action> cmdDict = new Dictionary<string, Action>();
cmdDict.Add("help", Help);
cmdDict.Add("hist", Hist);
cmdDict.Add("hello", Hello);
Console.WriteLine("Enter a command, type help for a listing.");
while (true) {
Console.Write(">");
string line = Console.ReadLine();
if (line=="exit") {
break;
}
Action action;
if (cmdDict.TryGetValue(line, out action)) {
action.Invoke();
} else {
Help();
}
}
}
}
}</syntaxhighlight>
=={{header|C++}}==
{{trans|D}}
<syntaxhighlight lang="cpp">#include <iostream>
#include <string>
#include <vector>
std::vector<std::string> hist;
std::ostream& operator<<(std::ostream& os, const std::string& str) {
return os << str.c_str();
}
void appendHistory(const std::string& name) {
hist.push_back(name);
}
void hello() {
std::cout << "Hello World!\n";
appendHistory(__func__);
}
void history() {
if (hist.size() == 0) {
std::cout << "No history\n";
} else {
for (auto& str : hist) {
std::cout << " - " << str << '\n';
}
}
appendHistory(__func__);
}
void help() {
std::cout << "Available commands:\n";
std::cout << " hello\n";
std::cout << " hist\n";
std::cout << " exit\n";
std::cout << " help\n";
appendHistory(__func__);
}
int main() {
bool done = false;
std::string cmd;
do {
std::cout << "Enter a command, type help for a listing.\n";
std::cin >> cmd;
for (size_t i = 0; i < cmd.size(); ++i) {
cmd[i] = toupper(cmd[i]);
}
if (strcmp(cmd.c_str(), "HELLO") == 0) {
hello();
} else if (strcmp(cmd.c_str(), "HIST") == 0) {
history();
} else if (strcmp(cmd.c_str(), "EXIT") == 0) {
done = true;
} else {
help();
}
} while (!done);
return 0;
}</syntaxhighlight>
=={{header|D}}==
<syntaxhighlight lang="d">module readline_interface;
import std.stdio;
import std.string;
alias VOIDF = void function();
void hello() {
writeln("Hello World!");
histArr ~= __FUNCTION__;
}
string[] histArr;
void hist() {
if (histArr.length == 0) {
writeln("No history");
} else {
foreach(cmd; histArr) {
writeln(" - ", cmd);
}
}
histArr ~= __FUNCTION__;
}
void help() {
writeln("Available commands:");
writeln(" hello");
writeln(" hist");
writeln(" exit");
writeln(" help");
histArr ~= __FUNCTION__;
}
void main() {
VOIDF[string] aa;
aa["help"] = &help;
aa["hist"] = &hist;
aa["hello"] = &hello;
writeln("Enter a command, type help for a listing.");
string line;
write(">");
while ((line = readln()) !is null) {
line = chomp(line);
if (line == "exit") {
break;
}
aa.get(line, &help)();
write(">");
}
}</syntaxhighlight>
{{out}}
<pre>Enter a command, type help for a listing.
>hist
No history
>help
Available commands:
hello
hist
exit
help
>hello
Hello World!
>hist
- readline_interface.hist
- readline_interface.help
- readline_interface.hello
>exit</pre>
=={{header|Go}}==
{{trans|D}}
<syntaxhighlight lang="go">package main
import (
"bufio"
"fmt"
"log"
"os"
"strings"
)
type vf = func()
var history []string
func hello() {
fmt.Println("Hello World!")
history = append(history, "hello")
}
func hist() {
if len(history) == 0 {
fmt.Println("No history")
} else {
for _, cmd := range history {
fmt.Println(" -", cmd)
}
}
history = append(history, "hist")
}
func help() {
fmt.Println("Available commands:")
fmt.Println(" hello")
fmt.Println(" hist")
fmt.Println(" exit")
fmt.Println(" help")
history = append(history, "help")
}
func main() {
scanner := bufio.NewScanner(os.Stdin)
vfs := map[string]vf{"help": help, "hist": hist, "hello": hello}
fmt.Println("Enter a command, type help for a listing.")
for {
fmt.Print(">")
scanner.Scan()
if scerr := scanner.Err(); scerr != nil {
log.Fatal(scerr)
}
line := strings.TrimSpace(scanner.Text())
if line == "exit" {
return
}
cmd, ok := vfs[line]
if !ok {
fmt.Println("Unknown command, try again")
} else {
cmd()
}
}
}</syntaxhighlight>
{{out}}
Sample session:
<pre>
Enter a command, type help for a listing.
>hit
Unknown command, try again
>hist
No history
>help
Available commands:
hello
hist
exit
help
>hello
Hello World!
>hist
- hist
- help
- hello
>exit
</pre>
=={{header|Java}}==
{{trans|C#}}
<syntaxhighlight lang="java">import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
public class ReadlineInterface {
private static LinkedList<String> histArr = new LinkedList<>();
private static void hist() {
if (histArr.isEmpty()) {
System.out.println("No history");
} else {
histArr.forEach(cmd -> System.out.printf(" - %s\n", cmd));
}
class Crutch {}
histArr.add(Crutch.class.getEnclosingMethod().getName());
}
private static void hello() {
System.out.println("Hello World!");
class Crutch {}
histArr.add(Crutch.class.getEnclosingMethod().getName());
}
private static void help() {
System.out.println("Available commands:");
System.out.println(" hello");
System.out.println(" hist");
System.out.println(" exit");
System.out.println(" help");
class Crutch {}
histArr.add(Crutch.class.getEnclosingMethod().getName());
}
public static void main(String[] args) throws IOException {
Map<String, Runnable> cmdMap = new HashMap<>();
cmdMap.put("help", ReadlineInterface::help);
cmdMap.put("hist", ReadlineInterface::hist);
cmdMap.put("hello", ReadlineInterface::hello);
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter a command, type help for a listing.");
while (true) {
System.out.print(">");
String line = in.readLine();
if ("exit".equals(line)) {
break;
}
cmdMap.getOrDefault(line, ReadlineInterface::help).run();
}
}
}</syntaxhighlight>
=={{header|Julia}}==
{{works with|Julia|0.6}}
Simple program that does nothing (copy of [[#C | C]]).
<syntaxhighlight lang="julia">function input(prompt::AbstractString)
print(prompt)
r = readline(STDIN)
if isempty(r) || r == "quit"
println("bye.")
elseif r == "help"
println("commands: ls, cat, quit")
elseif r ∈ ("ls", "cat")
println("command `$r` not implemented yet")
else
println("Yes...?")
end
end
input("This is a common prompt> ")</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.0.6
var range = intArrayOf() // empty initially
val history = mutableListOf<String>()
fun greeting() {
ProcessBuilder("cmd", "/c", "cls").inheritIO().start().waitFor() // clears console in windows 10
println("** Welcome to the Ranger readline interface **")
println("** which performs operations on a range of integers **\n")
println("Commands available:")
println(" range [i] [j], help, show, square, cube, add [n], sub [n]")
println(" mul [n], prev, hist, quit")
println()
}
fun setRange(start: Int, end: Int) {
range = IntArray(end - start + 1) { it + start }
show()
}
fun help() {
println(" range [i] [j] - sets the current range to [i, j] and shows them")
println(" - if i > j, sets the current range to the single value [i]")
println(" help - displays help for each command")
println(" show - displays a maximum of 10 values from the current range")
println(" square - sets the current range to their squares and shows them")
println(" cube - sets the current range to their cubes and shows them")
println(" add [i] - adds [i] to the current range and shows them")
println(" sub [i] - subtracts [i] from the current range and shows them")
println(" mul [i] - multiplies the current range by [i] and shows them")
println(" prev - displays previous command entered")
println(" hist - displays a maximum of last 10 commands entered, newest first")
println(" quit - quits Ranger")
println()
println(" < items in square brackets denote integers to be supplied e.g. range 1 5 >")
println(" < right/left arrow keys can be used to scroll through previous commands >")
}
fun show() {
val max = if (range.size > 10) 10 else range.size
val more = range.size - max
for (i in 0 until max) println(" ${range[i]}")
if (more > 0) println(" plus $more more")
}
fun square() {
for (i in 0 until range.size) range[i] *= range[i]
show()
}
fun cube() {
for (i in 0 until range.size) range[i] *= range[i] * range[i]
show()
}
fun add(n: Int) {
for (i in 0 until range.size) range[i] += n
show()
}
fun sub(n: Int) {
for (i in 0 until range.size) range[i] -= n
show()
}
fun mul(n: Int) {
for (i in 0 until range.size) range[i] *= n
show()
}
fun prev() {
if (history.size == 0) println("- No history yet") else println("- ${history.last()}")
}
fun showHistory() {
val size = history.size
if (size == 0) {println("- No history yet"); return}
val max = if (size > 10) 10 else size
val more = size - max
for (i in size - 1 downTo size - max) println("- ${history[i]}")
if (more > 0) println("- plus $more more")
}
fun main(args: Array<String>) {
val r = Regex ("\\s+")
val rangeCommands = arrayOf("show", "square", "cube", "add", "sub", "mul")
greeting()
while (true) {
var command = readLine()!!.trim().toLowerCase()
if (command == "") continue
var i: Int = 0
var j: Int = 0
var addToHistory = true
if (command.startsWith("range")) {
if (command == "range") { println("- Parameters required, try again\n"); continue}
val splits = command.split(r)
if (splits.size == 3) {
try {
i = splits[1].toInt()
j = splits[2].toInt()
if (i > j) j = i
command = "range"
history.add("$command $i $j")
addToHistory = false
}
catch(ex: NumberFormatException) {
}
}
}
else if (command.startsWith("add") || command.startsWith("sub") || command.startsWith("mul")) {
if (command.length == 3) { println("- Parameter required, try again\n"); continue}
val splits2 = command.split(r)
if (splits2.size == 2) {
try {
i = splits2[1].toInt()
command = command.take(3)
history.add("$command $i")
addToHistory = false
}
catch(ex: NumberFormatException) {
}
}
}
if (range.size == 0 && command in rangeCommands) {
println("- Range has not yet been set\n")
if (addToHistory) history.add(command)
continue
}
when (command) {
"range" -> setRange(i, j)
"help" -> help()
"show" -> show()
"square" -> square()
"cube" -> cube()
"add" -> add(i)
"sub" -> sub(i)
"mul" -> mul(i)
"prev" -> prev()
"hist" -> showHistory()
"quit" -> return
else -> {addToHistory = false; println("- Invalid command, try again")}
}
if (addToHistory) history.add(command)
println()
}
}</syntaxhighlight>
{{out}}
<pre>
** Welcome to the Ranger readline interface **
** which performs operations on a range of integers **
Commands available:
range [i] [j], help, show, square, cube, add [n], sub [n]
mul [n], prev, hist, quit
help
range [i] [j] - sets the current range to [i, j] and shows them
- if i > j, sets the current range to the single value [i]
help - displays help for each command
show - displays a maximum of 10 values from the current range
square - sets the current range to their squares and shows them
cube - sets the current range to their cubes and shows them
add [i] - adds [i] to the current range and shows them
sub [i] - subtracts [i] from the current range and shows them
mul [i] - multiplies the current range by [i] and shows them
prev - displays previous command entered
hist - displays a maximum of last 10 commands entered, newest first
quit - quits Ranger
< items in square brackets denote integers to be supplied e.g. range 1 5 >
< right/left arrow keys can be used to scroll through previous commands >
range 1 3
1
2
3
add 1
2
3
4
mul 2
4
6
8
sub 3
1
3
5
square
1
9
25
cube
1
729
15625
hist
- cube
- square
- sub 3
- mul 2
- add 1
- range 1 3
- help
prev
- hist
show
1
729
15625
quit
</pre>
=={{header|Nim}}==
{{trans|Go}}
Nim provides a module <code>rdstdin</code> to read form standard input file. This modules provides navigation in history of previous commands using the up and down keys.
<syntaxhighlight lang="nim">import rdstdin, strutils, tables
var history: seq[string]
proc hello =
echo "Hello World!"
history.add "hello"
proc hist =
if history.len == 0:
echo "no history"
else:
for cmd in history:
echo " -", cmd
history.add "hist"
proc help =
echo "Available commands:"
echo " hello"
echo " hist"
echo " exit"
echo " help"
history.add "help"
const Vfs = {"help": help, "hist": hist, "hello": hello}.toTable
echo "Enter a command, type help for a listing."
while true:
let line = try:
readLineFromStdin(">").strip()
except IOError:
echo "EOF encountered. Bye."
break
if line == "exit": break
if line notin Vfs:
echo "Unknown command, try again."
else:
Vfs[line]()</syntaxhighlight>
{{out}}
Sample session.
<pre>Enter a command, type help for a listing.
>help
Available commands:
hello
hist
exit
help
>hello
Hello World!
>hist
-help
-hello
>quit
Unknown command, try again.
>exit</pre>
=={{header|PARI/GP}}==
Line 49 ⟶ 750:
gp uses readline, but it can also be used directly in PARI:
<
#include <pari/pari.h>
#include <readline/readline.h>
Line 93 ⟶ 794:
}
return 0;
}</
<small>Code thanks to [http://pari.math.u-bordeaux.fr/archives/pari-dev-1002/msg00023.html Bill Allombert]</small>
=={{header|Perl}}==
A Perl shell with command history, line-editing and variable-name completion. Simplified from the example supplied with the CPAN module <code>Term::Readline::Gnu</code>.
<syntaxhighlight lang="perl">use strict;
use warnings;
use Term::ReadLine;
use POSIX;
my $term = Term::ReadLine->new( 'simple Perl shell' );
my $attribs = $term->Attribs;
$attribs->{completion_append_character} = ' ';
$attribs->{attempted_completion_function} = \&attempt_perl_completion;
$attribs->{completion_display_matches_hook} = \&perl_symbol_display_match_list;
while (defined(my $command = &reader)) {
my @result = eval ("package main; $command");
print "$_\n" for @result;
}
sub reader {
my $command = $term->readline('> ');
$term->addhistory($command) if $command;
$command;
}
sub perl_symbol_display_match_list {
my($matches, $num_matches, $max_length) = @_;
map { $_ =~ s/^((\$#|[\@\$%&])?).*::(.+)/$3/; }(@{$matches});
$term->display_match_list($matches);
$term->forced_update_display;
}
sub attempt_perl_completion {
my ($text, $line, $start, $end) = @_;
$term->completion_matches($text, \&perl_symbol_completion_function);
}
use vars qw($i @matches $prefix);
sub perl_symbol_completion_function {
my($text, $state) = @_;
my %type = ('$' => 'SCALAR', '*' => 'SCALAR', '@' => 'ARRAY', '$#' => 'ARRAY', '%' => 'HASH', '&' => 'CODE');
if ($state) {
$i++;
} else {
my ($pre, $pkg, $sym);
$i = 0;
no strict qw(refs);
($prefix, $pre, $pkg) = ($text =~ m/^((\$#|[\@\$%&])?(.*::)?)/);
@matches = grep /::$/, $pkg ? keys %$pkg : keys %::;
$pkg = '::' unless $pkg;
@matches = (@matches, grep (/^\w+$/ && ($sym = $pkg . $_, defined *$sym{$type{$pre}}), keys %$pkg));
}
my $entry;
for (; $i <= $#matches; $i++) {
$entry = $prefix . $matches[$i];
return $entry if ($entry =~ /^\Q$text/);
}
undef;
}</syntaxhighlight>
=={{header|Phix}}==
The phix interpreter has a readline interface, however the code involved is far too much to replicate here
(see p.exw, processCommandLine() which opens p.ini and populates default_commandlines, then invokes gets0()
from pgets0.ew with keyHandler() as a callback. Currently only tested/working on Windows, not linux.)
There are no "application specific commands", however you could init default_commandlines with some.
While the lack of code may disappoint, I think this is a closer match to the task intention than most.
A snapshot of running the interpreter: first I pressed ?, then F7, then "ed": keying "e" did little,
but "ed" auto-completed the "ix" part as that was then the only match.
<pre>
Phix hybrid interpreter/compiler.
Version 0.7.9 (32 bit Windows) Copyright Pete Lomax 2006..2016
Enter ? for options or filename to execute:?
<snip>
Press F7 to list prompt history, up/down to select.
Enter ? for options or filename to execute:
demo\pGUI\tee
demo\edix\edix
demo\win32demo\generic.exw
t61
p7
demo\win32demo\generic
-d! t01
-d! test/t01type.exw
edix
test\trace
p64
-c p64
-cp
-test
-c -test
-c e01
pgui
-d e01
pdemo
e01
use (pg) up/down to select:edix
</pre>
=={{header|Pike}}==
Line 101 ⟶ 908:
watch.pike is the solution from [[Simple database#Pike]]. this solution demonstrates how to retrofit an application with a readline interface by inheriting the original and overriding specific functions.
<
inherit "watch.pike";
Line 166 ⟶ 973:
}
}
}</
Sample session:
Line 190 ⟶ 997:
> save
> quit
=={{header|Python}}==
Python readline interface is enabled by default in the interpreter REPL, and can be enabled in user code simply by importing the readline module
<syntaxhighlight lang="python">#!/usr/bin/env python3
#
# A simple readline demo that does nothing.
# Interactive line editing and history active
#
import readline
while True:
try:
print(input('> '))
except:
break
</syntaxhighlight>
=={{header|Racket}}==
Racket's has a readline interface which is not used by default due to its license. This includes the usual readline-style editing, and tab-completion for Racket bindings. It is possible to use it as a library, or as a REPL convenience (both uses described [http://docs.racket-lang.org/readline/ in the documentation]) -- but it is better to use [http://docs.racket-lang.org/xrepl/ xrepl] which provides an enhanced command-line REPL and includes the readline interaction.
=={{header|Raku}}==
(formerly Perl 6)
Raku has a built in REPL that can be initiated by running the Raku executable without any parameters. It is fairly basic on its own but here are bindings available in the Raku ecosystem for [https://tiswww.case.edu/php/chet/readline/rltop.html GNU Readline] and/or [https://github.com/antirez/linenoise Linenoise] either of which will automatically provide command history, tab completion and more advance command line editing capability if installed. They are not included in the Raku distribution directly. There are incompatible licensing requirements and providing hooks for third party tools allows for more customization options.
Linenoise is generally the preferred option unless you really want the emacs compatible command line editing key bindings. Readline is arguably more powerful but is somewhat fiddly to set up.
If you are not inclined to install Readline ''or'' Linenoise, the REPL also works fairly well with 3rd party tools like rlwrap.
=={{header|REXX}}==
This REXX programs supports a '''REDO''' (re-do) with very limited editing to keep the program simple.
<br>It has a history (which can be interrogated) and some of the simple (MS) DOS commands.
<br>The HELP (or '''?'''), REDO, error checking, and abbreviations took up most of the program.
<br>"User" commands (subroutines) are identified with a leading period ('''.''') to make it easier to understand what's what.
<
trace off /*suppress echoing of non-zero retCodes*/
signal on syntax; signal on noValue /*handle REXX program errors. */
Line 327 ⟶ 1,161:
end /*select*/
return ccc
</syntaxhighlight>
This REXX program makes use of '''LINESIZE''' REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).
<br>The '''LINESIZE.REX''' REXX program is included here ──► [[LINESIZE.REX]].<br>
Some older REXXes don't have a '''changestr''' BIF, so one is included here ──► [[CHANGESTR.REX]].
<br><br>
'''output''' showing a sample session:
Line 484 ⟶ 1,318:
<br>A history of the commands is navigated by the up- and down-keys. All commands are just echoed, except "quit" which exits.
<br>It uses the Ruby 2.3 method Hash#to_proc.
<
require "abbrev"
Line 493 ⟶ 1,327:
exit if buf.strip == "quit"
p buf
end</
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">require('Term::ReadLine')
var term = %O<Term::ReadLine>.new('Example')
term.addhistory('foo')
term.addhistory('bar')
loop {
var cmd = term.readline("Prompt: ") \\ break
if (cmd ~~ %w[q quit]) {
break
}
say "You inserted <<#{cmd}>>"
}</syntaxhighlight>
=={{header|Wren}}==
{{trans|Go}}
<syntaxhighlight lang="wren">import "io" for Stdin, Stdout
class ReadLine {
static start {
__hist = []
System.print("Enter a command, type help for a listing.")
while (true) {
System.write(">")
Stdout.flush()
var cmd = Stdin.readLine().trim()
if (cmd == "exit") {
return
} else if (cmd == "hello") {
hello_
} else if (cmd == "hist") {
hist_
} else if (cmd == "help") {
help_
} else {
System.print("Unknown command, try again")
}
}
}
static hello_ {
System.print("Hello World!")
__hist.add("hello")
}
static hist_ {
if (__hist.count == 0) {
System.print("No history")
} else {
for (cmd in __hist) System.print(" - %(cmd)")
}
__hist.add("hist")
}
static help_ {
System.print("Available commands:")
System.print(" hello")
System.print(" hist")
System.print(" exit")
System.print(" help")
__hist.add("help")
}
}
ReadLine.start</syntaxhighlight>
{{out}}
Sample session (as Go):
<pre>
Enter a command, type help for a listing.
>hit
Unknown command, try again
>hist
No history
>help
Available commands:
hello
hist
exit
help
>hello
Hello World!
>hist
- hist
- help
- hello
>exit
</pre>
| |||