* Set the echo character. For example, to have "*" entered when a password * is typed: *
* *
* myConsoleReader.setEchoCharacter(new Character('*'));
*
*
* * Setting the character to * *
* null
*
*
* will restore normal character echoing. Setting the character to
*
*
* new Character(0)
*
*
* will cause nothing to be echoed.
*
*
* @param echoCharacter
* the character to echo to the console in place of the typed
* character.
*/
public void setEchoCharacter(final Character echoCharacter) {
this.echoCharacter = echoCharacter;
}
/**
* Returns the echo character.
*/
public Character getEchoCharacter() {
return this.echoCharacter;
}
/**
* No-op for exceptions we want to silently consume.
*/
private void consumeException(final Throwable e) {
}
/**
* Checks to see if the specified character is a delimiter. We consider a
* character a delimiter if it is anything but a letter or digit.
*
* @param c
* the character to test
* @return true if it is a delimiter
*/
private boolean isDelimiter(char c) {
return !Character.isLetterOrDigit(c);
}
private void printANSISequence(String sequence) throws IOException {
printCharacter(27);
printCharacter('[');
printString(sequence);
flushConsole();
}
/*
private int currentCol, currentRow;
private void getCurrentPosition() {
// check for ByteArrayInputStream to disable for unit tests
if (terminal.isANSISupported() && !(in instanceof ByteArrayInputStream)) {
try {
printANSISequence("[6n");
flushConsole();
StringBuffer b = new StringBuffer(8);
// position is sent as
* mode description
* ----------------------------------------
* 0 40 x 148 x 25 monochrome (text)
* 1 40 x 148 x 25 color (text)
* 2 80 x 148 x 25 monochrome (text)
* 3 80 x 148 x 25 color (text)
* 4 320 x 148 x 200 4-color (graphics)
* 5 320 x 148 x 200 monochrome (graphics)
* 6 640 x 148 x 200 monochrome (graphics)
* 7 Enables line wrapping
* 13 320 x 148 x 200 color (graphics)
* 14 640 x 148 x 200 color (16-color graphics)
* 15 640 x 148 x 350 monochrome (2-color graphics)
* 16 640 x 148 x 350 color (16-color graphics)
* 17 640 x 148 x 480 monochrome (2-color graphics)
* 18 640 x 148 x 480 color (16-color graphics)
* 19 320 x 148 x 200 color (256-color graphics)
*
*/
public static String setmode(final int mode) {
return ESC + "[=" + mode + "h";
}
/**
* Same as setmode () except for mode = 7, which disables line
* wrapping (useful for writing the right-most column without
* scrolling to the next line).
*/
public static String resetmode(final int mode) {
return ESC + "[=" + mode + "l";
}
/**
* Clears the screen and moves the cursor to the home postition.
*/
public static String clrscr() {
return ESC + "[2J";
}
/**
* Removes all characters from the current cursor position until
* the end of the line.
*/
public static String clreol() {
return ESC + "[K";
}
/**
* Moves the cursor n positions to the left. If n is greater or
* equal to the current cursor column, the cursor is moved to the
* first column.
*/
public static String left(final int n) {
return ESC + "[" + n + "D";
}
/**
* Moves the cursor n positions to the right. If n plus the current
* cursor column is greater than the rightmost column, the cursor
* is moved to the rightmost column.
*/
public static String right(final int n) {
return ESC + "[" + n + "C";
}
/**
* Moves the cursor n rows up without changing the current column.
* If n is greater than or equal to the current row, the cursor is
* placed in the first row.
*/
public static String up(final int n) {
return ESC + "[" + n + "A";
}
/**
* Moves the cursor n rows down. If n plus the current row is greater
* than the bottom row, the cursor is moved to the bottom row.
*/
public static String down(final int n) {
return ESC + "[" + n + "B";
}
/*
* Moves the cursor to the given row and column. (1,1) represents
* the upper left corner. The lower right corner of a usual DOS
* screen is (25, 80).
*/
public static String gotoxy(final int row, final int column) {
return ESC + "[" + row + ";" + column + "H";
}
/**
* Saves the current cursor position.
*/
public static String save() {
return ESC + "[s";
}
/**
* Restores the saved cursor position.
*/
public static String restore() {
return ESC + "[u";
}
/**
* Sets the character attribute. It will be
* one of the following character attributes:
*
*
* Text attributes
* 0 All attributes off
* 1 Bold on
* 4 Underscore (on monochrome display adapter only)
* 5 Blink on
* 7 Reverse video on
* 8 Concealed on
*
* Foreground colors
* 30 Black
* 31 Red
* 32 Green
* 33 Yellow
* 34 Blue
* 35 Magenta
* 36 Cyan
* 37 White
*
* Background colors
* 40 Black
* 41 Red
* 42 Green
* 43 Yellow
* 44 Blue
* 45 Magenta
* 46 Cyan
* 47 White
*
*
* The attributes remain in effect until the next attribute command
* is sent.
*/
public static String attrib(final int attr) {
return ESC + "[" + attr + "m";
}
/**
* Sets the key with the given code to the given value. code must be
* derived from the following table, value must
* be any semicolon-separated
* combination of String (enclosed in double quotes) and numeric values.
* For example, to set F1 to the String "Hello F1", followed by a CRLF
* sequence, one can use: ANSI.setkey ("0;59", "\"Hello F1\";13;10").
* Heres's the table of key values:
*
* Key Code SHIFT+code CTRL+code ALT+code
* ---------------------------------------------------------------
* F1 0;59 0;84 0;94 0;104
* F2 0;60 0;85 0;95 0;105
* F3 0;61 0;86 0;96 0;106
* F4 0;62 0;87 0;97 0;107
* F5 0;63 0;88 0;98 0;108
* F6 0;64 0;89 0;99 0;109
* F7 0;65 0;90 0;100 0;110
* F8 0;66 0;91 0;101 0;111
* F9 0;67 0;92 0;102 0;112
* F10 0;68 0;93 0;103 0;113
* F11 0;133 0;135 0;137 0;139
* F12 0;134 0;136 0;138 0;140
* HOME (num keypad) 0;71 55 0;119 --
* UP ARROW (num keypad) 0;72 56 (0;141) --
* PAGE UP (num keypad) 0;73 57 0;132 --
* LEFT ARROW (num keypad) 0;75 52 0;115 --
* RIGHT ARROW (num keypad) 0;77 54 0;116 --
* END (num keypad) 0;79 49 0;117 --
* DOWN ARROW (num keypad) 0;80 50 (0;145) --
* PAGE DOWN (num keypad) 0;81 51 0;118 --
* INSERT (num keypad) 0;82 48 (0;146) --
* DELETE (num keypad) 0;83 46 (0;147) --
* HOME (224;71) (224;71) (224;119) (224;151)
* UP ARROW (224;72) (224;72) (224;141) (224;152)
* PAGE UP (224;73) (224;73) (224;132) (224;153)
* LEFT ARROW (224;75) (224;75) (224;115) (224;155)
* RIGHT ARROW (224;77) (224;77) (224;116) (224;157)
* END (224;79) (224;79) (224;117) (224;159)
* DOWN ARROW (224;80) (224;80) (224;145) (224;154)
* PAGE DOWN (224;81) (224;81) (224;118) (224;161)
* INSERT (224;82) (224;82) (224;146) (224;162)
* DELETE (224;83) (224;83) (224;147) (224;163)
* PRINT SCREEN -- -- 0;114 --
* PAUSE/BREAK -- -- 0;0 --
* BACKSPACE 8 8 127 (0)
* ENTER 13 -- 10 (0
* TAB 9 0;15 (0;148) (0;165)
* NULL 0;3 -- -- --
* A 97 65 1 0;30
* B 98 66 2 0;48
* C 99 66 3 0;46
* D 100 68 4 0;32
* E 101 69 5 0;18
* F 102 70 6 0;33
* G 103 71 7 0;34
* H 104 72 8 0;35
* I 105 73 9 0;23
* J 106 74 10 0;36
* K 107 75 11 0;37
* L 108 76 12 0;38
* M 109 77 13 0;50
* N 110 78 14 0;49
* O 111 79 15 0;24
* P 112 80 16 0;25
* Q 113 81 17 0;16
* R 114 82 18 0;19
* S 115 83 19 0;31
* T 116 84 20 0;20
* U 117 85 21 0;22
* V 118 86 22 0;47
* W 119 87 23 0;17
* X 120 88 24 0;45
* Y 121 89 25 0;21
* Z 122 90 26 0;44
* 1 49 33 -- 0;120
* 2 50 64 0 0;121
* 3 51 35 -- 0;122
* 4 52 36 -- 0;123
* 5 53 37 -- 0;124
* 6 54 94 30 0;125
* 7 55 38 -- 0;126
* 8 56 42 -- 0;126
* 9 57 40 -- 0;127
* 0 48 41 -- 0;129
* - 45 95 31 0;130
* = 61 43 --- 0;131
* [ 91 123 27 0;26
* ] 93 125 29 0;27
* 92 124 28 0;43
* ; 59 58 -- 0;39
* ' 39 34 -- 0;40
* , 44 60 -- 0;51
* . 46 62 -- 0;52
* / 47 63 -- 0;53
* ` 96 126 -- (0;41)
* ENTER (keypad) 13 -- 10 (0;166)
* / (keypad) 47 47 (0;142) (0;74)
* * (keypad) 42 (0;144) (0;78) --
* - (keypad) 45 45 (0;149) (0;164)
* + (keypad) 43 43 (0;150) (0;55)
* 5 (keypad) (0;76) 53 (0;143) --
*/
public static String setkey(final String code, final String value) {
return ESC + "[" + code + ";" + value + "p";
}
}
public static void main(final String[] args) throws Exception {
// sequence, one can use: ANSI.setkey ("0;59", "\"Hello F1\";13;10").
BufferedReader reader =
new BufferedReader(new InputStreamReader(System.in));
System.out.print(ANSICodes.setkey("97", "97;98;99;13")
+ ANSICodes.attrib(ANSICodes.OFF));
System.out.flush();
String line;
while ((line = reader.readLine()) != null) {
System.out.println("GOT: " + line);
}
}
}
jline-1.0.orig/src/src/main/java/jline/Completor.java 0000644 0001750 0001750 00000002056 11550705746 022520 0 ustar twerner twerner /*
* Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved.
*
* This software is distributable under the BSD license. See the terms of the
* BSD license in the documentation provided with this software.
*/
package jline;
import java.util.*;
/**
* A Completor is the mechanism by which tab-completion candidates
* will be resolved.
*
* @author Marc Prud'hommeaux
*/
public interface Completor {
/**
* Populates candidates with a list of possible
* completions for the buffer. The candidates
* list will not be sorted before being displayed to the
* user: thus, the complete method should sort the
* {@link List} before returning.
*
*
* @param buffer the buffer
* @param candidates the {@link List} of candidates to populate
* @return the index of the buffer for which
* the completion will be relative
*/
int complete(String buffer, int cursor, List candidates);
}
jline-1.0.orig/src/src/main/java/jline/FileNameCompletor.java 0000644 0001750 0001750 00000010547 11550705746 024125 0 ustar twerner twerner /*
* Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved.
*
* This software is distributable under the BSD license. See the terms of the
* BSD license in the documentation provided with this software.
*/
package jline;
import java.io.*;
import java.util.*;
/**
* A file name completor takes the buffer and issues a list of
* potential completions.
*
*
* This completor tries to behave as similar as possible to
* bash's file name completion (using GNU readline)
* with the following exceptions:
*
*
TODO
*The core JLine API. The central class is jline.ConsoleReader}, which is a reader for obtaining input from an arbitrary InputStream (usually System.in).
jline-1.0.orig/src/src/main/java/jline/CandidateCycleCompletionHandler.java 0000644 0001750 0001750 00000002005 11550705746 026732 0 ustar twerner twerner /* * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. * * This software is distributable under the BSD license. See the terms of the * BSD license in the documentation provided with this software. */ package jline; import java.io.*; import java.util.*; /** ** A {@link CompletionHandler} that deals with multiple distinct completions * by cycling through each one every time tab is pressed. This * mimics the behavior of the * editline * library. *
*This class is currently a stub; it does nothing
* @author Marc Prud'hommeaux */ public class CandidateCycleCompletionHandler implements CompletionHandler { public boolean complete(final ConsoleReader reader, final List candidates, final int position) throws IOException { throw new IllegalStateException("CandidateCycleCompletionHandler unimplemented"); } } jline-1.0.orig/src/src/main/java/jline/ArgumentCompletor.java 0000644 0001750 0001750 00000035255 11550705746 024232 0 ustar twerner twerner /* * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. * * This software is distributable under the BSD license. See the terms of the * BSD license in the documentation provided with this software. */ package jline; import java.util.*; /** * A {@link Completor} implementation that invokes a child completor * using the appropriate separator argument. This * can be used instead of the individual completors having to * know about argument parsing semantics. ** Example 1: Any argument of the command line can * use file completion. *
*
* consoleReader.addCompletor (new ArgumentCompletor (
* new {@link FileNameCompletor} ()))
*
* * Example 2: The first argument of the command line * can be completed with any of "foo", "bar", or "baz", and remaining * arguments can be completed with a file name. *
*
* consoleReader.addCompletor (new ArgumentCompletor (
* new {@link SimpleCompletor} (new String [] { "foo", "bar", "baz"})));
* consoleReader.addCompletor (new ArgumentCompletor (
* new {@link FileNameCompletor} ()));
*
*
* * When the argument index is past the last embedded completors, the last * completors is always used. To disable this behavior, have the last * completor be a {@link NullCompletor}. For example: *
* *
* consoleReader.addCompletor (new ArgumentCompletor (
* new {@link SimpleCompletor} (new String [] { "foo", "bar", "baz"}),
* new {@link SimpleCompletor} (new String [] { "xxx", "yyy", "xxx"}),
* new {@link NullCompletor}
* ));
*
* * TODO: handle argument quoting and escape characters *
* * @author Marc Prud'hommeaux */ public class ArgumentCompletor implements Completor { final Completor[] completors; final ArgumentDelimiter delim; boolean strict = true; /** * Constuctor: create a new completor with the default * argument separator of " ". * * @param completor the embedded completor */ public ArgumentCompletor(final Completor completor) { this(new Completor[] { completor }); } /** * Constuctor: create a new completor with the default * argument separator of " ". * * @param completors the List of completors to use */ public ArgumentCompletor(final List completors) { this((Completor[]) completors.toArray(new Completor[completors.size()])); } /** * Constuctor: create a new completor with the default * argument separator of " ". * * @param completors the embedded argument completors */ public ArgumentCompletor(final Completor[] completors) { this(completors, new WhitespaceArgumentDelimiter()); } /** * Constuctor: create a new completor with the specified * argument delimiter. * * @param completor the embedded completor * @param delim the delimiter for parsing arguments */ public ArgumentCompletor(final Completor completor, final ArgumentDelimiter delim) { this(new Completor[] { completor }, delim); } /** * Constuctor: create a new completor with the specified * argument delimiter. * * @param completors the embedded completors * @param delim the delimiter for parsing arguments */ public ArgumentCompletor(final Completor[] completors, final ArgumentDelimiter delim) { this.completors = completors; this.delim = delim; } /** * If true, a completion at argument index N will only succeed * if all the completions from 0-(N-1) also succeed. */ public void setStrict(final boolean strict) { this.strict = strict; } /** * Returns whether a completion at argument index N will succees * if all the completions from arguments 0-(N-1) also succeed. */ public boolean getStrict() { return this.strict; } public int complete(final String buffer, final int cursor, final List candidates) { ArgumentList list = delim.delimit(buffer, cursor); int argpos = list.getArgumentPosition(); int argIndex = list.getCursorArgumentIndex(); if (argIndex < 0) { return -1; } final Completor comp; // if we are beyond the end of the completors, just use the last one if (argIndex >= completors.length) { comp = completors[completors.length - 1]; } else { comp = completors[argIndex]; } // ensure that all the previous completors are successful before // allowing this completor to pass (only if strict is true). for (int i = 0; getStrict() && (i < argIndex); i++) { Completor sub = completors[(i >= completors.length) ? (completors.length - 1) : i]; String[] args = list.getArguments(); String arg = ((args == null) || (i >= args.length)) ? "" : args[i]; List subCandidates = new LinkedList(); if (sub.complete(arg, arg.length(), subCandidates) == -1) { return -1; } if (subCandidates.size() == 0) { return -1; } } int ret = comp.complete(list.getCursorArgument(), argpos, candidates); if (ret == -1) { return -1; } int pos = ret + (list.getBufferPosition() - argpos); /** * Special case: when completing in the middle of a line, and the * area under the cursor is a delimiter, then trim any delimiters * from the candidates, since we do not need to have an extra * delimiter. * * E.g., if we have a completion for "foo", and we * enter "f bar" into the buffer, and move to after the "f" * and hit TAB, we want "foo bar" instead of "foo bar". */ if ((cursor != buffer.length()) && delim.isDelimiter(buffer, cursor)) { for (int i = 0; i < candidates.size(); i++) { String val = candidates.get(i).toString(); while ((val.length() > 0) && delim.isDelimiter(val, val.length() - 1)) { val = val.substring(0, val.length() - 1); } candidates.set(i, val); } } ConsoleReader.debug("Completing " + buffer + "(pos=" + cursor + ") " + "with: " + candidates + ": offset=" + pos); return pos; } /** * The {@link ArgumentCompletor.ArgumentDelimiter} allows custom * breaking up of a {@link String} into individual arguments in * order to dispatch the arguments to the nested {@link Completor}. * * @author Marc Prud'hommeaux */ public static interface ArgumentDelimiter { /** * Break the specified buffer into individual tokens * that can be completed on their own. * * @param buffer the buffer to split * @param argumentPosition the current position of the * cursor in the buffer * @return the tokens */ ArgumentList delimit(String buffer, int argumentPosition); /** * Returns true if the specified character is a whitespace * parameter. * * @param buffer the complete command buffer * @param pos the index of the character in the buffer * @return true if the character should be a delimiter */ boolean isDelimiter(String buffer, int pos); } /** * Abstract implementation of a delimiter that uses the * {@link #isDelimiter} method to determine if a particular * character should be used as a delimiter. * * @author Marc Prud'hommeaux */ public abstract static class AbstractArgumentDelimiter implements ArgumentDelimiter { private char[] quoteChars = new char[] { '\'', '"' }; private char[] escapeChars = new char[] { '\\' }; public void setQuoteChars(final char[] quoteChars) { this.quoteChars = quoteChars; } public char[] getQuoteChars() { return this.quoteChars; } public void setEscapeChars(final char[] escapeChars) { this.escapeChars = escapeChars; } public char[] getEscapeChars() { return this.escapeChars; } public ArgumentList delimit(final String buffer, final int cursor) { List args = new LinkedList(); StringBuffer arg = new StringBuffer(); int argpos = -1; int bindex = -1; for (int i = 0; (buffer != null) && (i <= buffer.length()); i++) { // once we reach the cursor, set the // position of the selected index if (i == cursor) { bindex = args.size(); // the position in the current argument is just the // length of the current argument argpos = arg.length(); } if ((i == buffer.length()) || isDelimiter(buffer, i)) { if (arg.length() > 0) { args.add(arg.toString()); arg.setLength(0); // reset the arg } } else { arg.append(buffer.charAt(i)); } } return new ArgumentList((String[]) args. toArray(new String[args.size()]), bindex, argpos, cursor); } /** * Returns true if the specified character is a whitespace * parameter. Check to ensure that the character is not * escaped by any of * {@link #getQuoteChars}, and is not escaped by ant of the * {@link #getEscapeChars}, and returns true from * {@link #isDelimiterChar}. * * @param buffer the complete command buffer * @param pos the index of the character in the buffer * @return true if the character should be a delimiter */ public boolean isDelimiter(final String buffer, final int pos) { if (isQuoted(buffer, pos)) { return false; } if (isEscaped(buffer, pos)) { return false; } return isDelimiterChar(buffer, pos); } public boolean isQuoted(final String buffer, final int pos) { return false; } public boolean isEscaped(final String buffer, final int pos) { if (pos <= 0) { return false; } for (int i = 0; (escapeChars != null) && (i < escapeChars.length); i++) { if (buffer.charAt(pos) == escapeChars[i]) { return !isEscaped(buffer, pos - 1); // escape escape } } return false; } /** * Returns true if the character at the specified position * if a delimiter. This method will only be called if the * character is not enclosed in any of the * {@link #getQuoteChars}, and is not escaped by ant of the * {@link #getEscapeChars}. To perform escaping manually, * override {@link #isDelimiter} instead. */ public abstract boolean isDelimiterChar(String buffer, int pos); } /** * {@link ArgumentCompletor.ArgumentDelimiter} * implementation that counts all * whitespace (as reported by {@link Character#isWhitespace}) * as being a delimiter. * * @author Marc Prud'hommeaux */ public static class WhitespaceArgumentDelimiter extends AbstractArgumentDelimiter { /** * The character is a delimiter if it is whitespace, and the * preceeding character is not an escape character. */ public boolean isDelimiterChar(String buffer, int pos) { return Character.isWhitespace(buffer.charAt(pos)); } } /** * The result of a delimited buffer. * * @author Marc Prud'hommeaux */ public static class ArgumentList { private String[] arguments; private int cursorArgumentIndex; private int argumentPosition; private int bufferPosition; /** * @param arguments the array of tokens * @param cursorArgumentIndex the token index of the cursor * @param argumentPosition the position of the cursor in the * current token * @param bufferPosition the position of the cursor in * the whole buffer */ public ArgumentList(String[] arguments, int cursorArgumentIndex, int argumentPosition, int bufferPosition) { this.arguments = arguments; this.cursorArgumentIndex = cursorArgumentIndex; this.argumentPosition = argumentPosition; this.bufferPosition = bufferPosition; } public void setCursorArgumentIndex(int cursorArgumentIndex) { this.cursorArgumentIndex = cursorArgumentIndex; } public int getCursorArgumentIndex() { return this.cursorArgumentIndex; } public String getCursorArgument() { if ((cursorArgumentIndex < 0) || (cursorArgumentIndex >= arguments.length)) { return null; } return arguments[cursorArgumentIndex]; } public void setArgumentPosition(int argumentPosition) { this.argumentPosition = argumentPosition; } public int getArgumentPosition() { return this.argumentPosition; } public void setArguments(String[] arguments) { this.arguments = arguments; } public String[] getArguments() { return this.arguments; } public void setBufferPosition(int bufferPosition) { this.bufferPosition = bufferPosition; } public int getBufferPosition() { return this.bufferPosition; } } } jline-1.0.orig/src/src/main/java/jline/MultiCompletor.java 0000644 0001750 0001750 00000004500 11550705746 023527 0 ustar twerner twerner /* * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. * * This software is distributable under the BSD license. See the terms of the * BSD license in the documentation provided with this software. */ package jline; import java.util.*; /** ** A completor that contains multiple embedded completors. This differs * from the {@link ArgumentCompletor}, in that the nested completors * are dispatched individually, rather than delimited by arguments. *
* * @author Marc Prud'hommeaux */ public class MultiCompletor implements Completor { Completor[] completors = new Completor[0]; /** * Construct a MultiCompletor with no embedded completors. */ public MultiCompletor() { this(new Completor[0]); } /** * Construct a MultiCompletor with the specified list of * {@link Completor} instances. */ public MultiCompletor(final List completors) { this((Completor[]) completors.toArray(new Completor[completors.size()])); } /** * Construct a MultiCompletor with the specified * {@link Completor} instances. */ public MultiCompletor(final Completor[] completors) { this.completors = completors; } public int complete(final String buffer, final int pos, final List cand) { int[] positions = new int[completors.length]; List[] copies = new List[completors.length]; for (int i = 0; i < completors.length; i++) { // clone and save the candidate list copies[i] = new LinkedList(cand); positions[i] = completors[i].complete(buffer, pos, copies[i]); } int maxposition = -1; for (int i = 0; i < positions.length; i++) { maxposition = Math.max(maxposition, positions[i]); } // now we have the max cursor value: build up all the // candidate lists that have the same cursor value for (int i = 0; i < copies.length; i++) { if (positions[i] == maxposition) { cand.addAll(copies[i]); } } return maxposition; } public void setCompletors(final Completor[] completors) { this.completors = completors; } public Completor[] getCompletors() { return this.completors; } } jline-1.0.orig/src/src/main/java/jline/SimpleCompletor.java 0000644 0001750 0001750 00000012456 11550705746 023677 0 ustar twerner twerner /* * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. * * This software is distributable under the BSD license. See the terms of the * BSD license in the documentation provided with this software. */ package jline; import java.io.*; import java.util.*; /** ** A simple {@link Completor} implementation that handles a pre-defined * list of completion words. *
* ** Example usage: *
*
* myConsoleReader.addCompletor (new SimpleCompletor (new String [] { "now", "yesterday", "tomorrow" }));
*
*
* @author Marc Prud'hommeaux
*/
public class SimpleCompletor implements Completor, Cloneable {
/**
* The list of candidates that will be completed.
*/
SortedSet candidates;
/**
* A delimiter to use to qualify completions.
*/
String delimiter;
final SimpleCompletorFilter filter;
/**
* Create a new SimpleCompletor with a single possible completion
* values.
*/
public SimpleCompletor(final String candidateString) {
this(new String[] {
candidateString
});
}
/**
* Create a new SimpleCompletor with a list of possible completion
* values.
*/
public SimpleCompletor(final String[] candidateStrings) {
this(candidateStrings, null);
}
public SimpleCompletor(final String[] strings,
final SimpleCompletorFilter filter) {
this.filter = filter;
setCandidateStrings(strings);
}
/**
* Complete candidates using the contents of the specified Reader.
*/
public SimpleCompletor(final Reader reader) throws IOException {
this(getStrings(reader));
}
/**
* Complete candidates using the whitespearated values in
* read from the specified Reader.
*/
public SimpleCompletor(final InputStream in) throws IOException {
this(getStrings(new InputStreamReader(in)));
}
private static String[] getStrings(final Reader in)
throws IOException {
final Reader reader =
(in instanceof BufferedReader) ? in : new BufferedReader(in);
List words = new LinkedList();
String line;
while ((line = ((BufferedReader) reader).readLine()) != null) {
for (StringTokenizer tok = new StringTokenizer(line);
tok.hasMoreTokens(); words.add(tok.nextToken())) {
;
}
}
return (String[]) words.toArray(new String[words.size()]);
}
public int complete(final String buffer, final int cursor, final List clist) {
String start = (buffer == null) ? "" : buffer;
SortedSet matches = candidates.tailSet(start);
for (Iterator i = matches.iterator(); i.hasNext();) {
String can = (String) i.next();
if (!(can.startsWith(start))) {
break;
}
if (delimiter != null) {
int index = can.indexOf(delimiter, cursor);
if (index != -1) {
can = can.substring(0, index + 1);
}
}
clist.add(can);
}
if (clist.size() == 1) {
clist.set(0, ((String) clist.get(0)) + " ");
}
// the index of the completion is always from the beginning of
// the buffer.
return (clist.size() == 0) ? (-1) : 0;
}
public void setDelimiter(final String delimiter) {
this.delimiter = delimiter;
}
public String getDelimiter() {
return this.delimiter;
}
public void setCandidates(final SortedSet candidates) {
if (filter != null) {
TreeSet filtered = new TreeSet();
for (Iterator i = candidates.iterator(); i.hasNext();) {
String element = (String) i.next();
element = filter.filter(element);
if (element != null) {
filtered.add(element);
}
}
this.candidates = filtered;
} else {
this.candidates = candidates;
}
}
public SortedSet getCandidates() {
return Collections.unmodifiableSortedSet(this.candidates);
}
public void setCandidateStrings(final String[] strings) {
setCandidates(new TreeSet(Arrays.asList(strings)));
}
public void addCandidateString(final String candidateString) {
final String string =
(filter == null) ? candidateString : filter.filter(candidateString);
if (string != null) {
candidates.add(string);
}
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
/**
* Filter for elements in the completor.
*
* @author Marc Prud'hommeaux
*/
public static interface SimpleCompletorFilter {
/**
* Filter the specified String. To not filter it, return the
* same String as the parameter. To exclude it, return null.
*/
public String filter(String element);
}
public static class NoOpFilter implements SimpleCompletorFilter {
public String filter(final String element) {
return element;
}
}
}
jline-1.0.orig/src/src/main/java/jline/UnsupportedTerminal.java 0000644 0001750 0001750 00000004671 11550705746 024605 0 ustar twerner twerner /*
* Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved.
*
* This software is distributable under the BSD license. See the terms of the
* BSD license in the documentation provided with this software.
*/
package jline;
import java.io.IOException;
/**
* A no-op unsupported terminal.
*
* @author Marc Prud'hommeaux
*/
public class UnsupportedTerminal extends Terminal {
private Thread maskThread = null;
public void initializeTerminal() {
// nothing we need to do (or can do) for windows.
}
public boolean getEcho() {
return true;
}
public boolean isEchoEnabled() {
return true;
}
public void enableEcho() {
}
public void disableEcho() {
}
/**
* Always returng 80, since we can't access this info on Windows.
*/
public int getTerminalWidth() {
return 80;
}
/**
* Always returng 24, since we can't access this info on Windows.
*/
public int getTerminalHeight() {
return 80;
}
public boolean isSupported() {
return false;
}
public void beforeReadLine(final ConsoleReader reader, final String prompt,
final Character mask) {
if ((mask != null) && (maskThread == null)) {
final String fullPrompt = "\r" + prompt
+ " "
+ " "
+ " "
+ "\r" + prompt;
maskThread = new Thread("JLine Mask Thread") {
public void run() {
while (!interrupted()) {
try {
reader.out.write(fullPrompt);
reader.out.flush();
sleep(3);
} catch (IOException ioe) {
return;
} catch (InterruptedException ie) {
return;
}
}
}
};
maskThread.setPriority(Thread.MAX_PRIORITY);
maskThread.setDaemon(true);
maskThread.start();
}
}
public void afterReadLine(final ConsoleReader reader, final String prompt,
final Character mask) {
if ((maskThread != null) && maskThread.isAlive()) {
maskThread.interrupt();
}
maskThread = null;
}
}
jline-1.0.orig/src/src/main/java/jline/ClassNameCompletor.java 0000644 0001750 0001750 00000011032 11550705746 024301 0 ustar twerner twerner /*
* Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved.
*
* This software is distributable under the BSD license. See the terms of the
* BSD license in the documentation provided with this software.
*/
package jline;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
/**
* A Completor implementation that completes java class names. By default,
* it scans the java class path to locate all the classes.
*
* @author Marc Prud'hommeaux
*/
public class ClassNameCompletor extends SimpleCompletor {
/**
* Complete candidates using all the classes available in the
* java CLASSPATH.
*/
public ClassNameCompletor() throws IOException {
this(null);
}
public ClassNameCompletor(final SimpleCompletorFilter filter)
throws IOException {
super(getClassNames(), filter);
setDelimiter(".");
}
public static String[] getClassNames() throws IOException {
Set urls = new HashSet();
for (ClassLoader loader = ClassNameCompletor.class
.getClassLoader(); loader != null;
loader = loader.getParent()) {
if (!(loader instanceof URLClassLoader)) {
continue;
}
urls.addAll(Arrays.asList(((URLClassLoader) loader).getURLs()));
}
// Now add the URL that holds java.lang.String. This is because
// some JVMs do not report the core classes jar in the list of
// class loaders.
Class[] systemClasses = new Class[] {
String.class, javax.swing.JFrame.class
};
for (int i = 0; i < systemClasses.length; i++) {
URL classURL = systemClasses[i].getResource("/"
+ systemClasses[i].getName() .replace('.', '/') + ".class");
if (classURL != null) {
URLConnection uc = (URLConnection) classURL.openConnection();
if (uc instanceof JarURLConnection) {
urls.add(((JarURLConnection) uc).getJarFileURL());
}
}
}
Set classes = new HashSet();
for (Iterator i = urls.iterator(); i.hasNext();) {
URL url = (URL) i.next();
File file = new File(url.getFile());
if (file.isDirectory()) {
Set files = getClassFiles(file.getAbsolutePath(),
new HashSet(), file, new int[] { 200 });
classes.addAll(files);
continue;
}
if ((file == null) || !file.isFile()) // TODO: handle directories
{
continue;
}
if (!file.toString().endsWith (".jar"))
continue;
JarFile jf = new JarFile(file);
for (Enumeration e = jf.entries(); e.hasMoreElements();) {
JarEntry entry = (JarEntry) e.nextElement();
if (entry == null) {
continue;
}
String name = entry.getName();
if (!name.endsWith(".class")) // only use class files
{
continue;
}
classes.add(name);
}
}
// now filter classes by changing "/" to "." and trimming the
// trailing ".class"
Set classNames = new TreeSet();
for (Iterator i = classes.iterator(); i.hasNext();) {
String name = (String) i.next();
classNames.add(name.replace('/', '.').
substring(0, name.length() - 6));
}
return (String[]) classNames.toArray(new String[classNames.size()]);
}
private static Set getClassFiles(String root, Set holder, File directory,
int[] maxDirectories) {
// we have passed the maximum number of directories to scan
if (maxDirectories[0]-- < 0) {
return holder;
}
File[] files = directory.listFiles();
for (int i = 0; (files != null) && (i < files.length); i++) {
String name = files[i].getAbsolutePath();
if (!(name.startsWith(root))) {
continue;
} else if (files[i].isDirectory()) {
getClassFiles(root, holder, files[i], maxDirectories);
} else if (files[i].getName().endsWith(".class")) {
holder.add(files[i].getAbsolutePath().
substring(root.length() + 1));
}
}
return holder;
}
}
jline-1.0.orig/src/src/main/java/jline/ConsoleOperations.java 0000644 0001750 0001750 00000013430 11550705746 024220 0 ustar twerner twerner /*
* Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved.
*
* This software is distributable under the BSD license. See the terms of the
* BSD license in the documentation provided with this software.
*/
package jline;
import java.awt.event.KeyEvent;
/**
* Symbolic constants for Console operations and virtual key bindings.
* @see KeyEvent
*
* @author Marc Prud'hommeaux
*/
public interface ConsoleOperations {
final String CR = System.getProperty("line.separator");
final char BACKSPACE = '\b';
final char RESET_LINE = '\r';
final char KEYBOARD_BELL = '\07';
final char CTRL_A = 1;
final char CTRL_B = 2;
final char CTRL_C = 3;
final char CTRL_D = 4;
final char CTRL_E = 5;
final char CTRL_F = 6;
final char CTRL_G = 7;
final static char CTRL_K = 11;
final static char CTRL_L = 12;
final char CTRL_N = 14;
final char CTRL_P = 16;
final static char CTRL_OB = 27;
final static char DELETE = 127;
final static char CTRL_QM = 127;
/**
* Logical constants for key operations.
*/
/**
* Unknown operation.
*/
final short UNKNOWN = -99;
/**
* Operation that moves to the beginning of the buffer.
*/
final short MOVE_TO_BEG = -1;
/**
* Operation that moves to the end of the buffer.
*/
final short MOVE_TO_END = -3;
/**
* Operation that moved to the previous character in the buffer.
*/
final short PREV_CHAR = -4;
/**
* Operation that issues a newline.
*/
final short NEWLINE = -6;
/**
* Operation that deletes the buffer from the current character to the end.
*/
final short KILL_LINE = -7;
/**
* Operation that clears the screen.
*/
final short CLEAR_SCREEN = -8;
/**
* Operation that sets the buffer to the next history item.
*/
final short NEXT_HISTORY = -9;
/**
* Operation that sets the buffer to the previous history item.
*/
final short PREV_HISTORY = -11;
/**
* Operation that redisplays the current buffer.
*/
final short REDISPLAY = -13;
/**
* Operation that deletes the buffer from the cursor to the beginning.
*/
final short KILL_LINE_PREV = -15;
/**
* Operation that deletes the previous word in the buffer.
*/
final short DELETE_PREV_WORD = -16;
/**
* Operation that moves to the next character in the buffer.
*/
final short NEXT_CHAR = -19;
/**
* Operation that moves to the previous character in the buffer.
*/
final short REPEAT_PREV_CHAR = -20;
/**
* Operation that searches backwards in the command history.
*/
final short SEARCH_PREV = -21;
/**
* Operation that repeats the character.
*/
final short REPEAT_NEXT_CHAR = -24;
/**
* Operation that searches forward in the command history.
*/
final short SEARCH_NEXT = -25;
/**
* Operation that moved to the previous whitespace.
*/
final short PREV_SPACE_WORD = -27;
/**
* Operation that moved to the end of the current word.
*/
final short TO_END_WORD = -29;
/**
* Operation that
*/
final short REPEAT_SEARCH_PREV = -34;
/**
* Operation that
*/
final short PASTE_PREV = -36;
/**
* Operation that
*/
final short REPLACE_MODE = -37;
/**
* Operation that
*/
final short SUBSTITUTE_LINE = -38;
/**
* Operation that
*/
final short TO_PREV_CHAR = -39;
/**
* Operation that
*/
final short NEXT_SPACE_WORD = -40;
/**
* Operation that
*/
final short DELETE_PREV_CHAR = -41;
/**
* Operation that
*/
final short ADD = -42;
/**
* Operation that
*/
final short PREV_WORD = -43;
/**
* Operation that
*/
final short CHANGE_META = -44;
/**
* Operation that
*/
final short DELETE_META = -45;
/**
* Operation that
*/
final short END_WORD = -46;
/**
* Operation that toggles insert/overtype
*/
final short INSERT = -48;
/**
* Operation that
*/
final short REPEAT_SEARCH_NEXT = -49;
/**
* Operation that
*/
final short PASTE_NEXT = -50;
/**
* Operation that
*/
final short REPLACE_CHAR = -51;
/**
* Operation that
*/
final short SUBSTITUTE_CHAR = -52;
/**
* Operation that
*/
final short TO_NEXT_CHAR = -53;
/**
* Operation that undoes the previous operation.
*/
final short UNDO = -54;
/**
* Operation that moved to the next word.
*/
final short NEXT_WORD = -55;
/**
* Operation that deletes the previous character.
*/
final short DELETE_NEXT_CHAR = -56;
/**
* Operation that toggles between uppercase and lowercase.
*/
final short CHANGE_CASE = -57;
/**
* Operation that performs completion operation on the current word.
*/
final short COMPLETE = -58;
/**
* Operation that exits the command prompt.
*/
final short EXIT = -59;
/**
* Operation that pastes the contents of the clipboard into the line
*/
final short PASTE = -60;
/**
* Operation that moves the current History to the beginning.
*/
final static short START_OF_HISTORY = -61;
/**
* Operation that moves the current History to the end.
*/
final static short END_OF_HISTORY = -62;
/**
* Operation that clears whatever text is on the current line.
*/
final static short CLEAR_LINE = -63;
/**
* Operation that aborts the current command (like searching)
*/
final static short ABORT = -64;
}
jline-1.0.orig/src/src/main/java/jline/NullCompletor.java 0000644 0001750 0001750 00000001302 11550705746 023344 0 ustar twerner twerner /*
* Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved.
*
* This software is distributable under the BSD license. See the terms of the
* BSD license in the documentation provided with this software.
*/
package jline;
import java.util.*;
/**
* * A completor that does nothing. Useful as the last item in an * {@link ArgumentCompletor}. *
* * @author Marc Prud'hommeaux */ public class NullCompletor implements Completor { /** * Returns -1 always, indicating that the the buffer is never * handled. */ public int complete(final String buffer, int cursor, List candidates) { return -1; } } jline-1.0.orig/src/src/main/java/jline/UnixTerminal.java 0000644 0001750 0001750 00000032251 11550705746 023173 0 ustar twerner twerner /* * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. * * This software is distributable under the BSD license. See the terms of the * BSD license in the documentation provided with this software. */ package jline; import java.io.*; import java.util.*; /** ** Terminal that is used for unix platforms. Terminal initialization * is handled by issuing the stty command against the * /dev/tty file to disable character echoing and enable * character input. All known unix systems (including * Linux and Macintosh OS X) support the stty), so this * implementation should work for an reasonable POSIX system. *
* * @author Marc Prud'hommeaux * @author Updates Dale Kemp 2005-12-03 */ public class UnixTerminal extends Terminal { public static final short ARROW_START = 27; public static final short ARROW_PREFIX = 91; public static final short ARROW_LEFT = 68; public static final short ARROW_RIGHT = 67; public static final short ARROW_UP = 65; public static final short ARROW_DOWN = 66; public static final short O_PREFIX = 79; public static final short HOME_CODE = 72; public static final short END_CODE = 70; public static final short DEL_THIRD = 51; public static final short DEL_SECOND = 126; private boolean echoEnabled; private String ttyConfig; private String ttyProps; private long ttyPropsLastFetched; private boolean backspaceDeleteSwitched = false; private static String sttyCommand = System.getProperty("jline.sttyCommand", "stty"); String encoding = System.getProperty("input.encoding", "UTF-8"); ReplayPrefixOneCharInputStream replayStream = new ReplayPrefixOneCharInputStream(encoding); InputStreamReader replayReader; public UnixTerminal() { try { replayReader = new InputStreamReader(replayStream, encoding); } catch (Exception e) { throw new RuntimeException(e); } } protected void checkBackspace(){ String[] ttyConfigSplit = ttyConfig.split(":|="); backspaceDeleteSwitched = ttyConfigSplit.length >= 7 && "7f".equals(ttyConfigSplit[6]); } /** * Remove line-buffered input by invoking "stty -icanon min 1" * against the current terminal. */ public void initializeTerminal() throws IOException, InterruptedException { // save the initial tty configuration ttyConfig = stty("-g"); // sanity check if ((ttyConfig.length() == 0) || ((ttyConfig.indexOf("=") == -1) && (ttyConfig.indexOf(":") == -1))) { throw new IOException("Unrecognized stty code: " + ttyConfig); } checkBackspace(); // set the console to be character-buffered instead of line-buffered stty("-icanon min 1"); // disable character echoing stty("-echo"); echoEnabled = false; // at exit, restore the original tty configuration (for JDK 1.3+) try { Runtime.getRuntime().addShutdownHook(new Thread() { public void start() { try { restoreTerminal(); } catch (Exception e) { consumeException(e); } } }); } catch (AbstractMethodError ame) { // JDK 1.3+ only method. Bummer. consumeException(ame); } } /** * Restore the original terminal configuration, which can be used when * shutting down the console reader. The ConsoleReader cannot be * used after calling this method. */ public void restoreTerminal() throws Exception { if (ttyConfig != null) { stty(ttyConfig); ttyConfig = null; } resetTerminal(); } public int readVirtualKey(InputStream in) throws IOException { int c = readCharacter(in); if (backspaceDeleteSwitched) if (c == DELETE) c = BACKSPACE; else if (c == BACKSPACE) c = DELETE; // in Unix terminals, arrow keys are represented by // a sequence of 3 characters. E.g., the up arrow // key yields 27, 91, 68 if (c == ARROW_START && in.available() > 0) { // Escape key is also 27, so we use InputStream.available() // to distinguish those. If 27 represents an arrow, there // should be two more chars immediately available. while (c == ARROW_START) { c = readCharacter(in); } if (c == ARROW_PREFIX || c == O_PREFIX) { c = readCharacter(in); if (c == ARROW_UP) { return CTRL_P; } else if (c == ARROW_DOWN) { return CTRL_N; } else if (c == ARROW_LEFT) { return CTRL_B; } else if (c == ARROW_RIGHT) { return CTRL_F; } else if (c == HOME_CODE) { return CTRL_A; } else if (c == END_CODE) { return CTRL_E; } else if (c == DEL_THIRD) { c = readCharacter(in); // read 4th return DELETE; } } } // handle unicode characters, thanks for a patch from amyi@inf.ed.ac.uk if (c > 128) { // handle unicode characters longer than 2 bytes, // thanks to Marc.Herbert@continuent.com replayStream.setInput(c, in); // replayReader = new InputStreamReader(replayStream, encoding); c = replayReader.read(); } return c; } /** * No-op for exceptions we want to silently consume. */ private void consumeException(Throwable e) { } public boolean isSupported() { return true; } public boolean getEcho() { return false; } /** * Returns the value of "stty size" width param. * * Note: this method caches the value from the * first time it is called in order to increase speed, which means * that changing to size of the terminal will not be reflected * in the console. */ public int getTerminalWidth() { int val = -1; try { val = getTerminalProperty("columns"); } catch (Exception e) { } if (val == -1) { val = 80; } return val; } /** * Returns the value of "stty size" height param. * * Note: this method caches the value from the * first time it is called in order to increase speed, which means * that changing to size of the terminal will not be reflected * in the console. */ public int getTerminalHeight() { int val = -1; try { val = getTerminalProperty("rows"); } catch (Exception e) { } if (val == -1) { val = 24; } return val; } private int getTerminalProperty(String prop) throws IOException, InterruptedException { // tty properties are cached so we don't have to worry too much about getting term widht/height if (ttyProps == null || System.currentTimeMillis() - ttyPropsLastFetched > 1000) { ttyProps = stty("-a"); ttyPropsLastFetched = System.currentTimeMillis(); } // need to be able handle both output formats: // speed 9600 baud; 24 rows; 140 columns; // and: // speed 38400 baud; rows = 49; columns = 111; ypixels = 0; xpixels = 0; for (StringTokenizer tok = new StringTokenizer(ttyProps, ";\n"); tok.hasMoreTokens();) { String str = tok.nextToken().trim(); if (str.startsWith(prop)) { int index = str.lastIndexOf(" "); return Integer.parseInt(str.substring(index).trim()); } else if (str.endsWith(prop)) { int index = str.indexOf(" "); return Integer.parseInt(str.substring(0, index).trim()); } } return -1; } /** * Execute the stty command with the specified arguments * against the current active terminal. */ protected static String stty(final String args) throws IOException, InterruptedException { return exec("stty " + args + " < /dev/tty").trim(); } /** * Execute the specified command and return the output * (both stdout and stderr). */ private static String exec(final String cmd) throws IOException, InterruptedException { return exec(new String[] { "sh", "-c", cmd }); } /** * Execute the specified command and return the output * (both stdout and stderr). */ private static String exec(final String[] cmd) throws IOException, InterruptedException { ByteArrayOutputStream bout = new ByteArrayOutputStream(); Process p = Runtime.getRuntime().exec(cmd); int c; InputStream in = null; InputStream err = null; OutputStream out = null; try { in = p.getInputStream(); while ((c = in.read()) != -1) { bout.write(c); } err = p.getErrorStream(); while ((c = err.read()) != -1) { bout.write(c); } out = p.getOutputStream(); p.waitFor(); } finally { try {in.close();} catch (Exception e) {} try {err.close();} catch (Exception e) {} try {out.close();} catch (Exception e) {} } String result = new String(bout.toByteArray()); return result; } /** * The command to use to set the terminal options. Defaults * to "stty", or the value of the system property "jline.sttyCommand". */ public static void setSttyCommand(String cmd) { sttyCommand = cmd; } /** * The command to use to set the terminal options. Defaults * to "stty", or the value of the system property "jline.sttyCommand". */ public static String getSttyCommand() { return sttyCommand; } public synchronized boolean isEchoEnabled() { return echoEnabled; } public synchronized void enableEcho() { try { stty("echo"); echoEnabled = true; } catch (Exception e) { consumeException(e); } } public synchronized void disableEcho() { try { stty("-echo"); echoEnabled = false; } catch (Exception e) { consumeException(e); } } /** * This is awkward and inefficient, but probably the minimal way to add * UTF-8 support to JLine * * @author Marc Herbert */ static class ReplayPrefixOneCharInputStream extends InputStream { byte firstByte; int byteLength; InputStream wrappedStream; int byteRead; final String encoding; public ReplayPrefixOneCharInputStream(String encoding) { this.encoding = encoding; } public void setInput(int recorded, InputStream wrapped) throws IOException { this.byteRead = 0; this.firstByte = (byte) recorded; this.wrappedStream = wrapped; byteLength = 1; if (encoding.equalsIgnoreCase("UTF-8")) setInputUTF8(recorded, wrapped); else if (encoding.equalsIgnoreCase("UTF-16")) byteLength = 2; else if (encoding.equalsIgnoreCase("UTF-32")) byteLength = 4; } public void setInputUTF8(int recorded, InputStream wrapped) throws IOException { // 110yyyyy 10zzzzzz if ((firstByte & (byte) 0xE0) == (byte) 0xC0) this.byteLength = 2; // 1110xxxx 10yyyyyy 10zzzzzz else if ((firstByte & (byte) 0xF0) == (byte) 0xE0) this.byteLength = 3; // 11110www 10xxxxxx 10yyyyyy 10zzzzzz else if ((firstByte & (byte) 0xF8) == (byte) 0xF0) this.byteLength = 4; else throw new IOException("invalid UTF-8 first byte: " + firstByte); } public int read() throws IOException { if (available() == 0) return -1; byteRead++; if (byteRead == 1) return firstByte; return wrappedStream.read(); } /** * InputStreamReader is greedy and will try to read bytes in advance. We * do NOT want this to happen since we use a temporary/"losing bytes" * InputStreamReader above, that's why we hide the real * wrappedStream.available() here. */ public int available() { return byteLength - byteRead; } } } jline-1.0.orig/src/src/main/java/jline/ConsoleRunner.java 0000644 0001750 0001750 00000005647 11550705746 023361 0 ustar twerner twerner /* * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. * * This software is distributable under the BSD license. See the terms of the * BSD license in the documentation provided with this software. */ package jline; import java.io.*; import java.util.*; /** ** A pass-through application that sets the system input stream to a * {@link ConsoleReader} and invokes the specified main method. *
* @author Marc Prud'hommeaux */ public class ConsoleRunner { private static ConsoleReader reader; public static ConsoleReader getReader() { return reader; } public static final String property = "jline.history"; public static void main(final String[] args) throws Exception { String historyFileName = null; List argList = new ArrayList(Arrays.asList(args)); if (argList.size() == 0) { usage(); return; } historyFileName = System.getProperty(ConsoleRunner.property, null); // invoke the main() method String mainClass = (String) argList.remove(0); // setup the inpout stream reader = new ConsoleReader(); if (historyFileName != null) { reader.setHistory(new History (new File (System.getProperty("user.home"), ".jline-" + mainClass + "." + historyFileName + ".history"))); } else { reader.setHistory(new History(new File (System.getProperty("user.home"), ".jline-" + mainClass + ".history"))); } String completors = System.getProperty (ConsoleRunner.class.getName() + ".completors", ""); List completorList = new ArrayList(); for (StringTokenizer tok = new StringTokenizer(completors, ","); tok.hasMoreTokens();) { completorList.add ((Completor) Class.forName(tok.nextToken()).newInstance()); } if (completorList.size() > 0) { reader.addCompletor(new ArgumentCompletor(completorList)); } ConsoleReaderInputStream.setIn(reader); try { Class.forName(mainClass). getMethod("main", new Class[] { String[].class }). invoke(null, new Object[] { argList.toArray(new String[0]) }); } finally { // just in case this main method is called from another program ConsoleReaderInputStream.restoreIn(); } } private static void usage() { System.out.println("Usage: \n java " + "[-Djline.history='name'] " + ConsoleRunner.class.getName() + "* Terminal implementation for Microsoft Windows. Terminal initialization in * {@link #initializeTerminal} is accomplished by extracting the * jline_version.dll, saving it to the system temporary * directoy (determined by the setting of the java.io.tmpdir System * property), loading the library, and then calling the Win32 APIs SetConsoleMode and * GetConsoleMode to * disable character echoing. *
* *
* By default, the {@link #readCharacter} method will attempt to test to see if
* the specified {@link InputStream} is {@link System#in} or a wrapper around
* {@link FileDescriptor#in}, and if so, will bypass the character reading to
* directly invoke the readc() method in the JNI library. This is so the class
* can read special keys (like arrow keys) which are otherwise inaccessible via
* the {@link System#in} stream. Using JNI reading can be bypassed by setting
* the jline.WindowsTerminal.directConsole system property
* to false.
*
* A {@link CompletionHandler} that deals with multiple distinct completions * by outputting the complete list of possibilities to the console. This * mimics the behavior of the * readline * library. *
* * TODO: *Configure and return the {@link Terminal} instance for the * current platform. This will initialize any system settings * that are required for the console to be able to handle * input correctly, such as setting tabtop, buffered input, and * character echo.
* *This class will use the Terminal implementation specified in the
* jline.terminal system property, or, if it is unset, by
* detecting the operating system from the os.name
* system property and instantiating either the
* {@link WindowsTerminalTest} or {@link UnixTerminal}.
*
* @see #initializeTerminal
*/
public static synchronized Terminal setupTerminal() {
if (term != null) {
return term;
}
final Terminal t;
String os = System.getProperty("os.name").toLowerCase();
String termProp = System.getProperty("jline.terminal");
if ((termProp != null) && (termProp.length() > 0)) {
try {
t = (Terminal) Class.forName(termProp).newInstance();
} catch (Exception e) {
throw (IllegalArgumentException) new IllegalArgumentException(e
.toString()).fillInStackTrace();
}
} else if (os.indexOf("windows") != -1) {
t = new WindowsTerminal();
} else {
t = new UnixTerminal();
}
try {
t.initializeTerminal();
} catch (Exception e) {
e.printStackTrace();
return term = new UnsupportedTerminal();
}
return term = t;
}
/**
* Returns true if the current console supports ANSI
* codes.
*/
public boolean isANSISupported() {
return true;
}
/**
* Read a single character from the input stream. This might
* enable a terminal implementation to better handle nuances of
* the console.
*/
public int readCharacter(final InputStream in) throws IOException {
return in.read();
}
/**
* Reads a virtual key from the console. Typically, this will
* just be the raw character that was entered, but in some cases,
* multiple input keys will need to be translated into a single
* virtual key.
*
* @param in the InputStream to read from
* @return the virtual key (e.g., {@link ConsoleOperations#VK_UP})
*/
public int readVirtualKey(InputStream in) throws IOException {
return readCharacter(in);
}
/**
* Initialize any system settings
* that are required for the console to be able to handle
* input correctly, such as setting tabtop, buffered input, and
* character echo.
*/
public abstract void initializeTerminal() throws Exception;
/**
* Returns the current width of the terminal (in characters)
*/
public abstract int getTerminalWidth();
/**
* Returns the current height of the terminal (in lines)
*/
public abstract int getTerminalHeight();
/**
* Returns true if this terminal is capable of initializing the
* terminal to use jline.
*/
public abstract boolean isSupported();
/**
* Returns true if the terminal will echo all characters type.
*/
public abstract boolean getEcho();
/**
* Invokes before the console reads a line with the prompt and mask.
*/
public void beforeReadLine(ConsoleReader reader, String prompt,
Character mask) {
}
/**
* Invokes after the console reads a line with the prompt and mask.
*/
public void afterReadLine(ConsoleReader reader, String prompt,
Character mask) {
}
/**
* Returns false if character echoing is disabled.
*/
public abstract boolean isEchoEnabled();
/**
* Enable character echoing. This can be used to re-enable character
* if the ConsoleReader is no longer being used.
*/
public abstract void enableEcho();
/**
* Disable character echoing. This can be used to manually re-enable
* character if the ConsoleReader has been disabled.
*/
public abstract void disableEcho();
public InputStream getDefaultBindings() {
// Mac bindings are slightly different from Unix/Linux.
// For instance, the Delete key behavior is different between them.
return Terminal.class.getResourceAsStream(
System.getProperty("os.name").toLowerCase().startsWith("mac") ?
"keybindings-mac.properties" : "keybindings.properties");
}
}
jline-1.0.orig/src/src/main/java/jline/CursorBuffer.java 0000644 0001750 0001750 00000004562 11550705746 023167 0 ustar twerner twerner /*
* Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved.
*
* This software is distributable under the BSD license. See the terms of the
* BSD license in the documentation provided with this software.
*/
package jline;
/**
* A CursorBuffer is a holder for a {@link StringBuffer} that also contains the
* current cursor position.
*
* @author Marc Prud'hommeaux
*/
public class CursorBuffer {
public int cursor = 0;
StringBuffer buffer = new StringBuffer();
private boolean overtyping = false;
public int length() {
return buffer.length();
}
public char current() {
if (cursor <= 0) {
return 0;
}
return buffer.charAt(cursor - 1);
}
public boolean clearBuffer() {
if (buffer.length() == 0) {
return false;
}
buffer.delete(0, buffer.length());
cursor = 0;
return true;
}
/**
* Write the specific character into the buffer, setting the cursor position
* ahead one. The text may overwrite or insert based on the current setting
* of isOvertyping().
*
* @param c
* the character to insert
*/
public void write(final char c) {
buffer.insert(cursor++, c);
if (isOvertyping() && cursor < buffer.length()) {
buffer.deleteCharAt(cursor);
}
}
/**
* Insert the specified {@link String} into the buffer, setting the cursor
* to the end of the insertion point.
*
* @param str
* the String to insert. Must not be null.
*/
public void write(final String str) {
if (buffer.length() == 0) {
buffer.append(str);
} else {
buffer.insert(cursor, str);
}
cursor += str.length();
if (isOvertyping() && cursor < buffer.length()) {
buffer.delete(cursor, (cursor + str.length()));
}
}
public String toString() {
return buffer.toString();
}
public boolean isOvertyping() {
return overtyping;
}
public void setOvertyping(boolean b) {
overtyping = b;
}
public StringBuffer getBuffer() {
return buffer;
}
public void setBuffer(StringBuffer buffer) {
buffer.setLength(0);
buffer.append(this.buffer.toString());
this.buffer = buffer;
}
}
jline-1.0.orig/src/src/main/java/jline/ConsoleReaderInputStream.java 0000644 0001750 0001750 00000005626 11550705746 025503 0 ustar twerner twerner /*
* Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved.
*
* This software is distributable under the BSD license. See the terms of the
* BSD license in the documentation provided with this software.
*/
package jline;
import java.io.*;
import java.util.*;
/**
* An {@link InputStream} implementation that wraps a {@link ConsoleReader}.
* It is useful for setting up the {@link System#in} for a generic
* console.
* @author Marc Prud'hommeaux
*/
public class ConsoleReaderInputStream extends SequenceInputStream {
private static InputStream systemIn = System.in;
public static void setIn() throws IOException {
setIn(new ConsoleReader());
}
public static void setIn(final ConsoleReader reader) {
System.setIn(new ConsoleReaderInputStream(reader));
}
/**
* Restore the original {@link System#in} input stream.
*/
public static void restoreIn() {
System.setIn(systemIn);
}
public ConsoleReaderInputStream(final ConsoleReader reader) {
super(new ConsoleEnumeration(reader));
}
private static class ConsoleEnumeration implements Enumeration {
private final ConsoleReader reader;
private ConsoleLineInputStream next = null;
private ConsoleLineInputStream prev = null;
public ConsoleEnumeration(final ConsoleReader reader) {
this.reader = reader;
}
public Object nextElement() {
if (next != null) {
InputStream n = next;
prev = next;
next = null;
return n;
}
return new ConsoleLineInputStream(reader);
}
public boolean hasMoreElements() {
// the last line was null
if ((prev != null) && (prev.wasNull == true)) {
return false;
}
if (next == null) {
next = (ConsoleLineInputStream) nextElement();
}
return next != null;
}
}
private static class ConsoleLineInputStream extends InputStream {
private final ConsoleReader reader;
private String line = null;
private int index = 0;
private boolean eol = false;
protected boolean wasNull = false;
public ConsoleLineInputStream(final ConsoleReader reader) {
this.reader = reader;
}
public int read() throws IOException {
if (eol) {
return -1;
}
if (line == null) {
line = reader.readLine();
}
if (line == null) {
wasNull = true;
return -1;
}
if (index >= line.length()) {
eol = true;
return '\n'; // lines are ended with a newline
}
return line.charAt(index++);
}
}
}
jline-1.0.orig/src/src/main/native/ 0000755 0001750 0001750 00000000000 11550705746 017152 5 ustar twerner twerner jline-1.0.orig/src/src/main/native/jline_WindowsTerminal.h 0000644 0001750 0001750 00000003652 11550705746 023640 0 ustar twerner twerner /* DO NOT EDIT THIS FILE - it is machine generated */
#include
On Windows, JLine uses a native .dll (which it automatically
extracts from the jline jar and loads at runtime) to access
native console features. On UNIX systems, JLine will perform
the necessary terminal setup by launching the "stty" command.
Various flavors of Windows (95, 98, NT, XP, 2000), Mac OS X,
and multiple UNIX systems (Linux, Solaris, HPUX).
j*pL7J;APVexiȑKU j 9
j*pL7J;APVexiȑKU j 9Ln @ٜd*xz=$92JQ PprFk,ˤ2Lk\}f߁Ӑ"&ezUc-\ФP1,\IyआNl/h('̿2tKqcH ˛zϫVz5Y>n S=Db*i`f~V^:qJI/& %+-Xb( cyf[[PtQз﬩qpc U[
| uFK'LaU^)2of Mƃ)&yK?"sVldϭp%5
N\h*J"0±@ F>5jO?[oCwX[~=PZ T|
$8`*&-h;]Y (Pa90P e03@UTAcT9 -IĆTd)CxڶPܼ03ff9zS ( ݨu8rE:mQa|
TeRȨaލ1Lߥkc-ʝD J7ft-8"Z,ưd.AEs!Z=o+VoCc~fwFzf+s T.{\>
ֵDvxoN)G{?ۏz'`q]1w sKnT`~k.ǾoI [2@ %z Gau NȬ #B
琽
WH!7džQ md:
n5Obyljar}` qTl fngWB ̢/=c;P8joIS9**-ٝf,
R0:aDy,e;좖 `A > ;
uQWfaӃ|dfq9Uޑ9c wJ'W, a&j^lH~ /2xfޔS: n~ؙ\J SyZMh>2qmw*e.gM`ȕ&2&Ĺ=S͂e-edm*sܹdruf )!Cp v/f5ө8ԟ3KP^ ?s,1(țΩH u:Pޥ>;0<oL 0C2ͩԛ$)Jyј1 xu8֥67%NLp.^1֙C A|8FGKyJŻ3
7 ?ITV:$k
&~.Jh5, LO ts#
~sumOԘN'ĝҮYzt"w4;OB99 Y H{\/,ސWQVz^ɏ`?CәOgMMSκFYuV$SF74hԉ2!s8~'~}lx:J(42l Xsy ϐ:6N<{6o#_8z@~)塿@` *2]/+]PZf)']+y; ԃE j|ӌ j(%gP;3i&T(NXS'Sg:89=hw`x[Lڠ41~ YׯoB,6kN!u ,
0
mzP3/ VT*qi;c-e@Yfy,~ % @aVwDdI;k9I@@?҆& дZ#70gE- |7 j<S5u5c23stm =*\?kʃ_¦icwB J;**%i㮗 h+iBPOIĒ)jH$֫:Prt
L<xWٯ!Y v Ь@ eWf~^;j:EۓUfL\w{ʐmܒ d1̮ 8 y l D h
( RL1xi*0Xׂ'~\ZE),!7NV~FPR@ 9Q7KcU^#AxVEkV ƎM LP,@/j?~gtA? Ln(S9S9qԑ< iz)1 eڞrSmHUOh,&FDFmhC4b$U &FVHIR'
vdXSvҾf ûA[qoa9QκWiYsj?pt EDMT}=ՔK>ѳ7(S܉ R0.hK\'ޢnu]5HwM
0ϡ 8}1?LPKi Om)`L^|'tF1Oi vC ;1>((i|eAx:ذTΦAK@mD~VZR0CNcnzqb˃4Yp28Ck? ?s 5hSv O JhnZOܿ<~a\QT(
Xj_c= C
<|<(D&uɖ-Fjd.LTb<Ȕw5Ia0V?A PVdXJ&[$лصRRoz VF++ ujp( waI릨$@*Q֢EyuU_]רJ: Ou)jgw]eҬ&k-X̦Ab2g^: XhA8*tCR_j;2EVenge-3g(q
RD5J{UM3&N>٠8VO{:"z˱
ДGgu0G^JM_g#Fhᝑ~ZP|M4f1i<Ɓū̮Fوuw y&Z_
na JG:* ?pF?/UqϋUɾg[KAd>3?%:y
' d}q gRC#xêf┠|I? &T-ݯ,(=〛ZU*%%e/6fqXCc*L]hH`\ SPT:X A I*?Z]\sdFI"=ZdE
,&^͗qNݜIy}V
ؗ{|xX0yp3t:p 6'zPaߵg m F1mR
Ll 4h|О$
Nxg{ &[]^[^O4y9iN
Ln @ٜd*xz=$92JQ PprFk,ˤ2Lk\}f߁Ӑ"&ezUc-\ФP1,\IyआNl/h('̿2tKqcH ˛zϫVz5Y>n S=Db*i`f~V^:qJI/& %+-Xb( cyf[[PtQз﬩qpc U[
| uFK'LaU^)2of Mƃ)&yK?"sVldϭp%5
N\h*J"0±@ F>5jO?[oCwX[~=PZ T|
$8`*&-h;]Y (Pa90P e03@UTAcT9 -IĆTd)CxڶPܼ03ff9zS ( ݨu8rE:mQa|
TeRȨaލ1Lߥkc-ʝD J7ft-8"Z,ưd.AEs!Z=o+VoCc~fwFzf+s T.{\>
ֵDvxoN)G{?ۏz'`q]1w sKnT`~k.ǾoI [2@ %z Gau NȬ #B
琽
WH!7džQ md:
n5Obyljar}` qTl fngWB ̢/=c;P8joIS9**-ٝf,
R0:aDy,e;좖 `A > ;
uQWfaӃ|dfq9Uޑ9c wJ'W, a&j^lH~ /2xfޔS: n~ؙ\J SyZMh>2qmw*e.gM`ȕ&2&Ĺ=S͂e-edm*sܹdruf )!Cp v/f5ө8ԟ3KP^ ?s,1(țΩH u:Pޥ>;0<oL 0C2ͩԛ$)Jyј1 xu8֥67%NLp.^1֙C A|8FGKyJŻ3
7 ?ITV:$k
&~.Jh5, LO ts#