public void run() {
try {
for (; ; ) {
byte[] buf = new byte[8192];
int l = out.read(buf);
InputStreamReader r = new InputStreamReader(new ByteArrayInputStream(buf, 0, l));
StringBuilder sb = new StringBuilder();
for (; ; ) {
int c = r.read();
if (c == -1) {
break;
}
sb.append((char) c);
}
if (sb.length() > 0) {
terminal.write(sb.toString());
}
String s = terminal.read();
if (s != null && s.length() > 0) {
for (byte b : s.getBytes()) {
in.write(b);
}
}
}
} catch (IOException e) {
closed = true;
e.printStackTrace();
}
}
@Before
public void init() {
Nonterminal X = Nonterminal.withName("X");
Nonterminal A = Nonterminal.withName("A");
Nonterminal B = Nonterminal.withName("B");
Nonterminal C = Nonterminal.withName("C");
Rule r1 =
Rule.withHead(X)
.addSymbol(Nonterminal.builder(A).setLabel("a").build())
.addSymbol(
Star.builder(
Sequence.builder(
Code.code(
Nonterminal.builder(B)
.addPreCondition(predicate(equal(rExt("a"), lExt("b"))))
.build(),
stat(println(lExt("b")))),
Code.code(
Nonterminal.builder(C).setLabel("b").build(),
stat(println(var("b")))))
.build())
.setLabel("b")
.build())
.build();
Rule r2 = Rule.withHead(A).addSymbol(Terminal.from(Character.from('a'))).build();
Rule r3 = Rule.withHead(B).addSymbol(Terminal.from(Character.from('b'))).build();
Rule r4 = Rule.withHead(C).addSymbol(Terminal.from(Character.from('c'))).build();
grammar = Grammar.builder().addRules(r1, r2, r3, r4).build();
}
public Terminal demote() {
Terminal rv = new Terminal(branch, parent, id);
int totalCount = getTotalCount();
rv.setAggregateCount(totalCount);
rv.setAggregateSum(getMean() * totalCount);
return rv;
}
/**
* The <code>printSeparator()</code> method prints a horizontal bar on the terminal that helps to
* separate different sections of textual output. This implementation uses the '=' character,
* providing a double-thick separator line and embeds a header string within the separating line.
*
* @param width the width of the horizontal separator bar
* @param header the string to embed in the separator line
*/
public static void printSeparator(int width, String header) {
Terminal.print("=={ ");
Terminal.print(header);
Terminal.print(" }");
Terminal.print(StringUtil.dup('=', width - 6 - header.length()));
Terminal.nextln();
}
protected boolean execute(int address, String expectedOutput) {
boolean isSuccess = false;
Cpu cpu = computer.getCpu();
cpu.writeRegister(false, Cpu.PC, address);
long startTime = System.currentTimeMillis();
while ((System.currentTimeMillis() - startTime) < MAX_EXECUTION_TIME
|| terminal.getWrittenData().length() > Terminal.MAX_DATA_LENGTH) {
try {
cpu.executeNextOperation();
if (cpu.isHaltMode()) {
throw new IllegalStateException("HALT mode");
}
} catch (Exception e) {
e.printStackTrace();
fail(
"can't execute operation, PC: 0"
+ Integer.toOctalString(cpu.readRegister(false, Cpu.PC)));
}
if (expectedOutput.equals(terminal.getWrittenData())) {
isSuccess = true;
break;
}
}
return isSuccess;
}
/** @see VtResponse#appendDescription(Terminal) */
@Override
protected Terminal appendDescription(final Terminal term) {
term.print("Cursor location: +");
term.print(this.x);
term.print('+');
term.print(this.y);
return term;
}
@Override
public boolean equals(Object o) {
if (o instanceof Terminal) {
Terminal temp = (Terminal) o;
if (temp.matches(this.tokenType)) return true;
}
return false;
}
public void matchTerminal(Terminal ter) {
if (ter.getName().equals("Epsilon")) {
return;
}
if (!lookAhead.matches(ter.getRegex())) {
System.err.println(
"input wrong expected : " + ter.getName() + " get : " + lookAhead + " ,insert it");
} else {
lookAhead = getNextToken();
}
}
public static String parse(
Lexer lexer,
HashMap<Nonterminal, HashMap<Terminal, Rule>> parsingTable,
Nonterminal startSymbol) {
Stack<Token> stack = new Stack<Token>();
ArrayList<Terminal> inputs = lexer.getTokens();
int count = 0;
stack.push(startSymbol);
while (!stack.isEmpty() && count < inputs.size()) {
Token top = stack.peek();
System.out.println(
"Testing top: " + top.toString() + ", next input: " + inputs.get(count).toString());
if (top instanceof Nonterminal) {
Nonterminal nextNonTerm = (Nonterminal) top;
Rule rules = parsingTable.get(nextNonTerm).get(inputs.get(count));
if (rules == null)
return "Invalid. No rule found for "
+ nextNonTerm.toString()
+ " and the input "
+ inputs.get(count);
stack.pop();
for (int i = rules.rule.length - 1; i > -1; i--) {
if (!rules.rule[i].equals(new Terminal(Terminal.TerminalType.EPSILON)))
stack.push(rules.rule[i]);
}
} else if (top instanceof Terminal) {
Terminal nextTerm = (Terminal) top;
Terminal nextInput = inputs.get(count);
if (nextTerm.equals(nextInput)) {
++count;
stack.pop();
} else return nextTerm + " and " + nextInput + " do not match: invalid";
}
System.out.println("Current stack: " + stack.toString());
}
if (stack.isEmpty()) return "Valid";
return "Invalid. Ran out of tokens early or ran over input count";
}
public SessionTerminal() throws IOException {
try {
this.terminal = new Terminal(TERM_WIDTH, TERM_HEIGHT);
terminal.write("\u001b\u005B20\u0068"); // set newline mode on
in = new PipedOutputStream();
out = new PipedInputStream();
PrintStream pipedOut = new PrintStream(new PipedOutputStream(out), true);
final Subject subject = new Subject();
subject.getPrincipals().add(new UserPrincipal("karaf"));
Console console =
consoleFactory.create(
commandProcessor,
new PipedInputStream(in),
pipedOut,
pipedOut,
new WebTerminal(TERM_WIDTH, TERM_HEIGHT),
null);
consoleFactory.startConsoleAs(console, subject);
} catch (IOException e) {
e.printStackTrace();
throw e;
} catch (Exception e) {
e.printStackTrace();
throw (IOException) new IOException().initCause(e);
}
new Thread(this).start();
}
private List<Value> ls(String... ss) {
List<Value> list = new ArrayList<Value>();
for (String s : ss) {
list.add(Terminal.of(s));
}
return list;
}
/** Test method for {@link Sequence#compareTo(Value)}. */
@Test
public void testCompareTo_Unordered() {
Sequence s1 = Sequence.unordered(ls("1", "2"));
Sequence s2 = Sequence.unordered(ls("1", "2"));
Sequence s3 = Sequence.unordered(ls("1"));
Sequence s4 = Sequence.unordered(ls("1", "2", "3"));
Sequence s5 = Sequence.unordered(ls("1", "3"));
Sequence s6 = Sequence.unordered(ls("1", "1"));
Sequence s7 = Sequence.unordered(ls("0", "3"));
Sequence s8 = Sequence.unordered(ls("2", "1"));
Terminal v1 = Terminal.of("12");
Sequence v2 = Sequence.ordered(ls("1", "2"));
Record v3 = Record.of(Arrays.<Entry>asList());
// test is not an unordered list
assertThat(s1.compareTo(v1), greaterThan(0));
assertThat(s1.compareTo(v2), lessThan(0));
assertThat(s1.compareTo(v3), lessThan(0));
// entity
assertThat(s1.compareTo(s1), is(0));
assertThat(s1.compareTo(s2), is(0));
assertThat(s1.compareTo(s3), greaterThan(0));
assertThat(s1.compareTo(s4), lessThan(0));
assertThat(s1.compareTo(s5), lessThan(0));
assertThat(s1.compareTo(s6), greaterThan(0));
assertThat(s1.compareTo(s7), greaterThan(0));
assertThat(s1.compareTo(s8), is(0));
}
public void match(ArrayList<Token> rhs) {
outer:
for (Token i : rhs) {
// System.out.println("i:" + i);
if (i.getClass().getName().equals("compiler.Terminal")) {
matchTerminal((Terminal) i);
} else if (i.getClass().getName().equals("compiler.NonTerminal")) {
NonTerminal iNonTerminal = (NonTerminal) i;
ArrayList<Integer> lhses = getIndexOfRulesWithLeftHandSide(gr.rules, iNonTerminal);
for (Integer j : lhses) {
if (gr.getFirsts(gr.rules.get(j).getRightSide())
.contains(Terminal.getTerminalbyString(lookAhead))) {
// System.out.println("using rule:" +
// gr.rules.get(j).getRightSide());
match(gr.rules.get(j).getRightSide());
continue outer;
}
}
/// no rule with input in first
if (iNonTerminal.getFirsts().contains(Terminal.getTerminal("Epsilon"))) {
if (iNonTerminal.getFollows().contains(Terminal.getTerminalbyString(lookAhead))) {
ArrayList<Integer> indexOfRulesWithLeftHandSide =
getIndexOfRulesWithLeftHandSide(gr.rules, iNonTerminal);
for (Integer j : indexOfRulesWithLeftHandSide) {
if (gr.getFirsts(gr.rules.get(j).getRightSide())
.contains(Terminal.getTerminal("Epsilon"))) {
match(gr.rules.get(j).getRightSide());
continue outer;
}
}
}
}
if (iNonTerminal.getFollows().contains(Terminal.getTerminalbyString(lookAhead))) {
System.err.println("missing " + iNonTerminal.getDesc() + " ,insert it");
} else {
System.err.println("misplaced " + lookAhead + " I'm Skipping it!");
lookAhead = getNextToken();
}
} else if (i.getClass().getName().equals("compiler.Procedure")) {
runProcedure(i.getName());
}
}
}
public String handle(String str, boolean forceDump) throws IOException {
try {
if (str != null && str.length() > 0) {
String d = terminal.pipe(str);
for (byte b : d.getBytes()) {
in.write(b);
}
in.flush();
}
} catch (IOException e) {
closed = true;
throw e;
}
try {
return terminal.dump(10, forceDump);
} catch (InterruptedException e) {
throw new InterruptedIOException(e.toString());
}
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((avion == null) ? 0 : avion.hashCode());
result = prime * result + id;
result = prime * result + ((pista == null) ? 0 : pista.hashCode());
result = prime * result + ((terminal == null) ? 0 : terminal.hashCode());
return result;
}
/* Checks that the method lengthTerminalLenght works fine. */
@Test(timeout = 100)
public void lengthTerminalTest() {
int len = -2;
Collection<Terminal> ct;
Terminal t = null;
Terminal t2 = null;
Terminal t3 = null;
ct = g.getTerminals();
Assert.assertNotNull(ct);
for (Terminal t4 : ct) {
if ((t4.getSymbol()).equals("1")) {
t = t4;
}
if ((t4.getSymbol()).equals("5")) {
t2 = t4;
}
}
Assert.assertNotNull(t);
Assert.assertNotNull(t2);
len = l.lengthTerminal(null, t);
Assert.assertTrue(len == -2);
len = l.lengthTerminal(g, null);
Assert.assertTrue(len == -2);
try {
t3 = new TerminalImpl(0, "");
} catch (GrammarExceptionImpl e) {
System.out.println(e.getMessage());
}
len = l.lengthTerminal(g, t3);
Assert.assertTrue(len == -2);
len = l.lengthTerminal(g, t);
Assert.assertTrue(len == 0);
len = l.lengthTerminal(g, t2);
Assert.assertTrue(len == 0);
}
/**
* Read a character from the console.
*
* @return the character, or -1 if an EOF is received.
*/
public final int readVirtualKey() throws IOException {
int c = terminal.readVirtualKey(in);
if (debugger != null) {
debug("keystroke: " + c + "");
}
// clear any echo characters
clearEcho(c);
return c;
}
/** Clear the echoed characters for the specified character code. */
int clearEcho(int c) throws IOException {
// if the terminal is not echoing, then just return...
if (!terminal.getEcho()) {
return 0;
}
// otherwise, clear
int num = countEchoCharacters((char) c);
back(num);
drawBuffer(num);
return num;
}
/**
* The <code>reportProportion()</code> method is a simply utility to print out a quantity's name
* (such as "Number of instructions executed", the value (such as 2002), and the units (such as
* cycles) in a colorized and standardized way.
*
* @param name the name of the quantity as a string
* @param val the value of the quantity as a long integer
* @param units the name of the units as a string
*/
public static void reportProportion(String name, long val, long total, String units) {
String sval = Long.toString(val);
Terminal.printGreen(name);
Terminal.print(": ");
Terminal.printBrightCyan(sval);
if (units != null && units.length() > 0) Terminal.print(' ' + units + ' ');
else Terminal.print(" ");
float pcnt = (100 * (float) val / total);
Terminal.printBrightCyan(StringUtil.toFixedFloat(pcnt, 4));
Terminal.println(" %");
}
protected void stopTerminal() {
try {
TerminalFactory f = DefaultTerminalFactory.getInstance();
Terminal t = f.getTerminal();
t.stop();
} catch (IOException ex) {
// Log info:
{
String message = "Failure to stop terminal!";
log.log(Level.SEVERE, message, ex);
}
throw new RuntimeException(ex);
} catch (Throwable ex) {
// Log info:
{
String message = "Failure to stop terminal!";
log.log(Level.SEVERE, message, ex);
}
throw new RuntimeException(ex);
}
}
/** Clear the screen by issuing the ANSI "clear screen" code. */
public boolean clearScreen() throws IOException {
if (!terminal.isANSISupported()) {
return false;
}
// send the ANSI code to clear the screen
printString(((char) 27) + "[2J");
flushConsole();
// then send the ANSI code to go to position 1,1
printString(((char) 27) + "[1;1H");
flushConsole();
redrawLine();
return true;
}
private void commandLoop() throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
while (true) {
TerminalCommand tc = Terminal.create(in.readLine());
if (tc instanceof TerminalCommand.Guest) {
TerminalCommand.Guest tcg = (TerminalCommand.Guest) tc;
createGuest(tcg.count, tcg.drink, tcg.maxDrinkCount);
} else if (tc == TerminalCommand.Status.Instance) {
getStatus();
} else if (tc == TerminalCommand.Quit.Instance) {
system.shutdown();
break;
} else {
TerminalCommand.Unknown u = (TerminalCommand.Unknown) tc;
log.warning("Unknown terminal command {}!", u.command);
}
}
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Vuelo other = (Vuelo) obj;
if (avion == null) {
if (other.avion != null) return false;
} else if (!avion.equals(other.avion)) return false;
if (id != other.id) return false;
if (pista == null) {
if (other.pista != null) return false;
} else if (!pista.equals(other.pista)) return false;
if (terminal == null) {
if (other.terminal != null) return false;
} else if (!terminal.equals(other.terminal)) return false;
return true;
}
public void doClockIn(Terminal terminal, Shift shift, Calendar currentTime) {
setClockedIn(true);
setCurrentShift(shift);
setCurrentTerminal(terminal);
setLastClockInTime(currentTime.getTime());
LogFactory.getLog(Application.class)
.info("terminal id befor saving clockIn=" + terminal.getId());
AttendenceHistory attendenceHistory = new AttendenceHistory();
attendenceHistory.setClockInTime(currentTime.getTime());
attendenceHistory.setClockInHour(Short.valueOf((short) currentTime.get(Calendar.HOUR)));
attendenceHistory.setUser(this);
attendenceHistory.setTerminal(terminal);
attendenceHistory.setShift(shift);
UserDAO.getInstance().saveClockIn(this, attendenceHistory, shift, currentTime);
}
// ================================ main ===============================
//
// You can use command line arguments to have the output and/or input
// come from a file versus the command line.
//
// If there are two arguments then the first one is the file from where
// the input is read and the second is the file where a transcript is
// saved.
//
// If there is just one argument then it is the file where a transcript
// is saved.
public static void main(String args[]) {
XYPoint points[];
if (args.length >= 1) {
Terminal.startTranscript(args[0]);
}
if (args.length >= 2) {
// Read points from file
points = PointReader.readXYPoints(args[1]);
} else {
// You can change "" to something else when testing,
// but it MUST be "3861" for your submitted output!
java.util.Random randseq = new java.util.Random(3861);
// Use this line if you want a different random set of
// points for each run. This code uses the system
// clock as the seed to the random number generator.
//
// java.util.Random randseq = new java.util.Random();
Terminal.println("How many points? ");
int nPoints = Terminal.readInt();
points = genPointsAtRandom(nPoints, randseq);
}
XComparator lessThanX = new XComparator();
YComparator lessThanY = new YComparator();
Date startTime = new Date();
//////////////////////////////////////////////////////////////////////
// CLOSEST-PAIR ALGORITHM STARTS HERE
// The algorithm expects two arrays containing the same points.
XYPoint pointsByX[] = new XYPoint[points.length];
XYPoint pointsByY[] = new XYPoint[points.length];
for (int j = 0; j < points.length; j++) {
pointsByX[j] = points[j];
pointsByY[j] = points[j];
}
// Ensure sorting precondition for divide-and-conquer CP algorithm.
// You should *not* have to call msort() in your own code!
Sort.msort(pointsByX, lessThanX); // sort by x-coord
Sort.msort(pointsByY, lessThanY); // sort by y-coord
Result rMin = ClosestPair.findClosestPair(pointsByX, pointsByY);
rMin.print();
// CLOSEST-PAIR ALGORITHM ENDS HERE
//////////////////////////////////////////////////////////////////////
Date endTime = new Date();
long elapsedTime = endTime.getTime() - startTime.getTime();
Terminal.println(
"For n = " + points.length + ", the elapsed time is " + elapsedTime + " milliseconds.\n");
// *** NOTE: for your submitted output for Part Two, you MUST print
// *** the closest pair of points and the distance between them!
//////////////////////////////////////////////////////////////////////
// THE FOLLOWING LINES DEMONSTRATE HOW TO USE THE PROVIDED
// PLOTTER ROUTINE. Uncomment them as you wish for debugging
// purposes, or use them in your closest pair code to inspect
// the point arrays at any time. For example, you could color
// all points in the left half red and all points in the right
// half blue and then visually check that you divided them
// properly by calling the plotter before you recurse. Note
// that if you make several calls, all the plots will
// initially be on top of each other -- just move them so you
// can see everything.
//
// Here the points are plotted and labelled by X-coordinate
// new Plotter(pointsByY, true, "Sorted by X-coordinate");
// Here the points are plotted and labelled by Y-coordinate
// new Plotter(pointsByY, true, "Sorted by Y-coordinate");
// Here's a call to the plot routine in which the points
// aren't labeled. A nice thing to do at this point (if you
// computed the two closest points) would be to color the two
// closest points a different color For a XYPoint p, you could
// color p (say red) with the line:
//
// p.color = Color.red;
// new Plotter(pointsByX, true, "Output");
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
if (localName.compareToIgnoreCase("term") == 0) {
String tid = attributes.getValue("tid");
String address = attributes.getValue("addr");
Terminal terminal;
if (terminals.containsKey(tid)) terminal = terminals.get(tid);
else {
terminal = new Terminal(tid, address);
terminals.put(tid, terminal);
++count;
}
// статус
terminal.state = getInt(attributes, "rs", Terminal.STATE_ERROR);
// состояние принтера
terminal.printer_state = getString(attributes, "rp", "none");
// состояние купироприемника
terminal.cashbin_state = getString(attributes, "rc", "none");
// сумма
terminal.cash = getInt(attributes, "cs");
// последняя активность
terminal.lastActivity = getString(attributes, "lat");
// последний платеж
terminal.lastPayment = getString(attributes, "lpd");
// Число купюр
terminal.bondsCount = getInt(attributes, "nc");
// Баланс сим карты
terminal.balance = getString(attributes, "ss");
// Уровень сигнала сим карты
terminal.bondsCount = getInt(attributes, "sl");
// Версия софта
terminal.softVersion = getString(attributes, "csoft");
// Модель принтера
terminal.printerModel = getString(attributes, "pm");
terminal.cashbinModel = getString(attributes, "dm");
terminal.bonds10count = getInt(attributes, "b_co_10");
terminal.bonds50count = getInt(attributes, "b_co_50");
terminal.bonds100count = getInt(attributes, "b_co_100");
terminal.bonds500count = getInt(attributes, "b_co_500");
terminal.bonds1000count = getInt(attributes, "b_co_1000");
terminal.bonds5000count = getInt(attributes, "b_co_5000");
terminal.bonds10000count = getInt(attributes, "b_co_10000");
terminal.paysPerHour = getString(attributes, "pays_per_hour");
terminal.agentId = getString(attributes, "aid");
terminal.agentName = getString(attributes, "an");
} else if (localName.compareToIgnoreCase("result-code") == 0) tagState = TAG_RESULT;
else if (localName.compareToIgnoreCase("extra") == 0) {
tagState = TAG_EXTRA;
String extra_name = attributes.getValue("name");
if (extra_name.compareToIgnoreCase("balance") == 0) extraState = EXTRA_BALANCE;
else if (extra_name.compareToIgnoreCase("overdraft") == 0) extraState = EXTRA_OVERDRAFT;
else extraState = EXTRA_UNKNOWN;
} else tagState = TAG_NONE;
// не допускаем вложенности
text.delete(0, text.length());
}
/** Copy terminal fields. */
public final void link(Terminal terminal) {
set(F_TERMINALID, new Long(terminal.getId()));
set(F_TERMINALNAME, terminal.getName());
set(F_BUILDINGID, new Long(terminal.getBuildingId()));
set(F_BUILDINGNAME, terminal.getBuildingName());
}
/**
* Read a line from the <i>in</i> {@link InputStream}, and return the line (without any trailing
* newlines).
*
* @param prompt the prompt to issue to the console, may be null.
* @return a line that is read from the terminal, or null if there was null input (e.g.,
* <i>CTRL-D</i> was pressed).
*/
public String readLine(final String prompt, final Character mask) throws IOException {
this.mask = mask;
if (prompt != null) this.prompt = prompt;
try {
terminal.beforeReadLine(this, this.prompt, mask);
if ((this.prompt != null) && (this.prompt.length() > 0)) {
out.write(this.prompt);
out.flush();
}
// if the terminal is unsupported, just use plain-java reading
if (!terminal.isSupported()) {
return readLine(in);
}
while (true) {
int[] next = readBinding();
if (next == null) {
return null;
}
int c = next[0];
int code = next[1];
if (c == -1) {
return null;
}
boolean success = true;
switch (code) {
case EXIT: // ctrl-d
if (buf.buffer.length() == 0) {
return null;
}
case COMPLETE: // tab
success = complete();
break;
case MOVE_TO_BEG:
success = setCursorPosition(0);
break;
case KILL_LINE: // CTRL-K
success = killLine();
break;
case CLEAR_SCREEN: // CTRL-L
success = clearScreen();
break;
case KILL_LINE_PREV: // CTRL-U
success = resetLine();
break;
case NEWLINE: // enter
moveToEnd();
printNewline(); // output newline
return finishBuffer();
case DELETE_PREV_CHAR: // backspace
success = backspace();
break;
case DELETE_NEXT_CHAR: // delete
success = deleteCurrentCharacter();
break;
case MOVE_TO_END:
success = moveToEnd();
break;
case PREV_CHAR:
success = moveCursor(-1) != 0;
break;
case NEXT_CHAR:
success = moveCursor(1) != 0;
break;
case NEXT_HISTORY:
success = moveHistory(true);
break;
case PREV_HISTORY:
success = moveHistory(false);
break;
case REDISPLAY:
break;
case PASTE:
success = paste();
break;
case DELETE_PREV_WORD:
success = deletePreviousWord();
break;
case PREV_WORD:
success = previousWord();
break;
case NEXT_WORD:
success = nextWord();
break;
case START_OF_HISTORY:
success = history.moveToFirstEntry();
if (success) setBuffer(history.current());
break;
case END_OF_HISTORY:
success = history.moveToLastEntry();
if (success) setBuffer(history.current());
break;
case CLEAR_LINE:
moveInternal(-(buf.buffer.length()));
killLine();
break;
case INSERT:
buf.setOvertyping(!buf.isOvertyping());
break;
case UNKNOWN:
default:
if (c != 0) { // ignore null chars
ActionListener action =
(ActionListener) triggeredActions.get(new Character((char) c));
if (action != null) action.actionPerformed(null);
else putChar(c, true);
} else success = false;
}
if (!(success)) {
beep();
}
flushConsole();
}
} finally {
terminal.afterReadLine(this, this.prompt, mask);
}
}
/**
* Query the terminal to find the current width;
*
* @see Terminal#getTerminalHeight
* @return the height of the current terminal.
*/
public int getTermheight() {
return Terminal.setupTerminal().getTerminalHeight();
}
/**
* Query the terminal to find the current width;
*
* @see Terminal#getTerminalWidth
* @return the width of the current terminal.
*/
public int getTermwidth() {
return Terminal.setupTerminal().getTerminalWidth();
}
