Skip to content

Commit 0ef3539

Browse files
naotojnaotoj
committedDec 15, 2022
8298416: Console should be declared sealed
Reviewed-by: jpai, alanb
1 parent 831b35f commit 0ef3539

File tree

3 files changed

+578
-454
lines changed

3 files changed

+578
-454
lines changed
 

‎src/java.base/share/classes/java/io/Console.java

+209-452
Original file line numberDiff line numberDiff line change
@@ -33,8 +33,6 @@
3333
import jdk.internal.access.SharedSecrets;
3434
import jdk.internal.io.JdkConsoleProvider;
3535
import jdk.internal.util.StaticProperty;
36-
import sun.nio.cs.StreamDecoder;
37-
import sun.nio.cs.StreamEncoder;
3836
import sun.security.action.GetPropertyAction;
3937

4038
/**
@@ -82,320 +80,250 @@
8280
* manually zero the returned character array after processing to minimize the
8381
* lifetime of sensitive data in memory.
8482
*
85-
* <blockquote><pre>{@code
83+
* {@snippet lang=java :
8684
* Console cons;
8785
* char[] passwd;
8886
* if ((cons = System.console()) != null &&
8987
* (passwd = cons.readPassword("[%s]", "Password:")) != null) {
9088
* ...
9189
* java.util.Arrays.fill(passwd, ' ');
9290
* }
93-
* }</pre></blockquote>
91+
* }
9492
*
9593
* @author Xueming Shen
9694
* @since 1.6
9795
*/
96+
public sealed class Console implements Flushable permits ConsoleImpl, ProxyingConsole {
97+
/**
98+
* Package private no-arg constructor.
99+
*/
100+
Console() {}
98101

99-
public class Console implements Flushable
100-
{
101-
/**
102-
* Retrieves the unique {@link java.io.PrintWriter PrintWriter} object
103-
* associated with this console.
104-
*
105-
* @return The printwriter associated with this console
106-
*/
102+
/**
103+
* Retrieves the unique {@link java.io.PrintWriter PrintWriter} object
104+
* associated with this console.
105+
*
106+
* @return The printwriter associated with this console
107+
*/
107108
public PrintWriter writer() {
108-
return pw;
109+
throw newUnsupportedOperationException();
109110
}
110111

111-
/**
112-
* Retrieves the unique {@link java.io.Reader Reader} object associated
113-
* with this console.
114-
* <p>
115-
* This method is intended to be used by sophisticated applications, for
116-
* example, a {@link java.util.Scanner} object which utilizes the rich
117-
* parsing/scanning functionality provided by the {@code Scanner}:
118-
* <blockquote><pre>
119-
* Console con = System.console();
120-
* if (con != null) {
121-
* Scanner sc = new Scanner(con.reader());
122-
* ...
123-
* }
124-
* </pre></blockquote>
125-
* <p>
126-
* For simple applications requiring only line-oriented reading, use
127-
* {@link #readLine}.
128-
* <p>
129-
* The bulk read operations {@link java.io.Reader#read(char[]) read(char[]) },
130-
* {@link java.io.Reader#read(char[], int, int) read(char[], int, int) } and
131-
* {@link java.io.Reader#read(java.nio.CharBuffer) read(java.nio.CharBuffer)}
132-
* on the returned object will not read in characters beyond the line
133-
* bound for each invocation, even if the destination buffer has space for
134-
* more characters. The {@code Reader}'s {@code read} methods may block if a
135-
* line bound has not been entered or reached on the console's input device.
136-
* A line bound is considered to be any one of a line feed ({@code '\n'}),
137-
* a carriage return ({@code '\r'}), a carriage return followed immediately
138-
* by a linefeed, or an end of stream.
139-
*
140-
* @return The reader associated with this console
141-
*/
112+
/**
113+
* Retrieves the unique {@link java.io.Reader Reader} object associated
114+
* with this console.
115+
* <p>
116+
* This method is intended to be used by sophisticated applications, for
117+
* example, a {@link java.util.Scanner} object which utilizes the rich
118+
* parsing/scanning functionality provided by the {@code Scanner}:
119+
* <blockquote><pre>
120+
* Console con = System.console();
121+
* if (con != null) {
122+
* Scanner sc = new Scanner(con.reader());
123+
* ...
124+
* }
125+
* </pre></blockquote>
126+
* <p>
127+
* For simple applications requiring only line-oriented reading, use
128+
* {@link #readLine}.
129+
* <p>
130+
* The bulk read operations {@link java.io.Reader#read(char[]) read(char[]) },
131+
* {@link java.io.Reader#read(char[], int, int) read(char[], int, int) } and
132+
* {@link java.io.Reader#read(java.nio.CharBuffer) read(java.nio.CharBuffer)}
133+
* on the returned object will not read in characters beyond the line
134+
* bound for each invocation, even if the destination buffer has space for
135+
* more characters. The {@code Reader}'s {@code read} methods may block if a
136+
* line bound has not been entered or reached on the console's input device.
137+
* A line bound is considered to be any one of a line feed ({@code '\n'}),
138+
* a carriage return ({@code '\r'}), a carriage return followed immediately
139+
* by a linefeed, or an end of stream.
140+
*
141+
* @return The reader associated with this console
142+
*/
142143
public Reader reader() {
143-
return reader;
144+
throw newUnsupportedOperationException();
144145
}
145146

146-
/**
147-
* Writes a formatted string to this console's output stream using
148-
* the specified format string and arguments.
149-
*
150-
* @param fmt
151-
* A format string as described in <a
152-
* href="../util/Formatter.html#syntax">Format string syntax</a>
153-
*
154-
* @param args
155-
* Arguments referenced by the format specifiers in the format
156-
* string. If there are more arguments than format specifiers, the
157-
* extra arguments are ignored. The number of arguments is
158-
* variable and may be zero. The maximum number of arguments is
159-
* limited by the maximum dimension of a Java array as defined by
160-
* <cite>The Java Virtual Machine Specification</cite>.
161-
* The behaviour on a
162-
* {@code null} argument depends on the <a
163-
* href="../util/Formatter.html#syntax">conversion</a>.
164-
*
165-
* @throws IllegalFormatException
166-
* If a format string contains an illegal syntax, a format
167-
* specifier that is incompatible with the given arguments,
168-
* insufficient arguments given the format string, or other
169-
* illegal conditions. For specification of all possible
170-
* formatting errors, see the <a
171-
* href="../util/Formatter.html#detail">Details</a> section
172-
* of the formatter class specification.
173-
*
174-
* @return This console
175-
*/
147+
/**
148+
* Writes a formatted string to this console's output stream using
149+
* the specified format string and arguments.
150+
*
151+
* @param fmt
152+
* A format string as described in <a
153+
* href="../util/Formatter.html#syntax">Format string syntax</a>
154+
*
155+
* @param args
156+
* Arguments referenced by the format specifiers in the format
157+
* string. If there are more arguments than format specifiers, the
158+
* extra arguments are ignored. The number of arguments is
159+
* variable and may be zero. The maximum number of arguments is
160+
* limited by the maximum dimension of a Java array as defined by
161+
* <cite>The Java Virtual Machine Specification</cite>.
162+
* The behaviour on a
163+
* {@code null} argument depends on the <a
164+
* href="../util/Formatter.html#syntax">conversion</a>.
165+
*
166+
* @throws IllegalFormatException
167+
* If a format string contains an illegal syntax, a format
168+
* specifier that is incompatible with the given arguments,
169+
* insufficient arguments given the format string, or other
170+
* illegal conditions. For specification of all possible
171+
* formatting errors, see the <a
172+
* href="../util/Formatter.html#detail">Details</a> section
173+
* of the formatter class specification.
174+
*
175+
* @return This console
176+
*/
176177
public Console format(String fmt, Object ...args) {
177-
formatter.format(fmt, args).flush();
178-
return this;
178+
throw newUnsupportedOperationException();
179179
}
180180

181-
/**
182-
* A convenience method to write a formatted string to this console's
183-
* output stream using the specified format string and arguments.
184-
*
185-
* <p> An invocation of this method of the form
186-
* {@code con.printf(format, args)} behaves in exactly the same way
187-
* as the invocation of
188-
* <pre>con.format(format, args)</pre>.
189-
*
190-
* @param format
191-
* A format string as described in <a
192-
* href="../util/Formatter.html#syntax">Format string syntax</a>.
193-
*
194-
* @param args
195-
* Arguments referenced by the format specifiers in the format
196-
* string. If there are more arguments than format specifiers, the
197-
* extra arguments are ignored. The number of arguments is
198-
* variable and may be zero. The maximum number of arguments is
199-
* limited by the maximum dimension of a Java array as defined by
200-
* <cite>The Java Virtual Machine Specification</cite>.
201-
* The behaviour on a
202-
* {@code null} argument depends on the <a
203-
* href="../util/Formatter.html#syntax">conversion</a>.
204-
*
205-
* @throws IllegalFormatException
206-
* If a format string contains an illegal syntax, a format
207-
* specifier that is incompatible with the given arguments,
208-
* insufficient arguments given the format string, or other
209-
* illegal conditions. For specification of all possible
210-
* formatting errors, see the <a
211-
* href="../util/Formatter.html#detail">Details</a> section of the
212-
* formatter class specification.
213-
*
214-
* @return This console
215-
*/
181+
/**
182+
* A convenience method to write a formatted string to this console's
183+
* output stream using the specified format string and arguments.
184+
*
185+
* <p> An invocation of this method of the form
186+
* {@code con.printf(format, args)} behaves in exactly the same way
187+
* as the invocation of
188+
* <pre>con.format(format, args)</pre>.
189+
*
190+
* @param format
191+
* A format string as described in <a
192+
* href="../util/Formatter.html#syntax">Format string syntax</a>.
193+
*
194+
* @param args
195+
* Arguments referenced by the format specifiers in the format
196+
* string. If there are more arguments than format specifiers, the
197+
* extra arguments are ignored. The number of arguments is
198+
* variable and may be zero. The maximum number of arguments is
199+
* limited by the maximum dimension of a Java array as defined by
200+
* <cite>The Java Virtual Machine Specification</cite>.
201+
* The behaviour on a
202+
* {@code null} argument depends on the <a
203+
* href="../util/Formatter.html#syntax">conversion</a>.
204+
*
205+
* @throws IllegalFormatException
206+
* If a format string contains an illegal syntax, a format
207+
* specifier that is incompatible with the given arguments,
208+
* insufficient arguments given the format string, or other
209+
* illegal conditions. For specification of all possible
210+
* formatting errors, see the <a
211+
* href="../util/Formatter.html#detail">Details</a> section of the
212+
* formatter class specification.
213+
*
214+
* @return This console
215+
*/
216216
public Console printf(String format, Object ... args) {
217-
return format(format, args);
217+
throw newUnsupportedOperationException();
218218
}
219219

220-
/**
221-
* Provides a formatted prompt, then reads a single line of text from the
222-
* console.
223-
*
224-
* @param fmt
225-
* A format string as described in <a
226-
* href="../util/Formatter.html#syntax">Format string syntax</a>.
227-
*
228-
* @param args
229-
* Arguments referenced by the format specifiers in the format
230-
* string. If there are more arguments than format specifiers, the
231-
* extra arguments are ignored. The maximum number of arguments is
232-
* limited by the maximum dimension of a Java array as defined by
233-
* <cite>The Java Virtual Machine Specification</cite>.
234-
*
235-
* @throws IllegalFormatException
236-
* If a format string contains an illegal syntax, a format
237-
* specifier that is incompatible with the given arguments,
238-
* insufficient arguments given the format string, or other
239-
* illegal conditions. For specification of all possible
240-
* formatting errors, see the <a
241-
* href="../util/Formatter.html#detail">Details</a> section
242-
* of the formatter class specification.
243-
*
244-
* @throws IOError
245-
* If an I/O error occurs.
246-
*
247-
* @return A string containing the line read from the console, not
248-
* including any line-termination characters, or {@code null}
249-
* if an end of stream has been reached.
250-
*/
220+
/**
221+
* Provides a formatted prompt, then reads a single line of text from the
222+
* console.
223+
*
224+
* @param fmt
225+
* A format string as described in <a
226+
* href="../util/Formatter.html#syntax">Format string syntax</a>.
227+
*
228+
* @param args
229+
* Arguments referenced by the format specifiers in the format
230+
* string. If there are more arguments than format specifiers, the
231+
* extra arguments are ignored. The maximum number of arguments is
232+
* limited by the maximum dimension of a Java array as defined by
233+
* <cite>The Java Virtual Machine Specification</cite>.
234+
*
235+
* @throws IllegalFormatException
236+
* If a format string contains an illegal syntax, a format
237+
* specifier that is incompatible with the given arguments,
238+
* insufficient arguments given the format string, or other
239+
* illegal conditions. For specification of all possible
240+
* formatting errors, see the <a
241+
* href="../util/Formatter.html#detail">Details</a> section
242+
* of the formatter class specification.
243+
*
244+
* @throws IOError
245+
* If an I/O error occurs.
246+
*
247+
* @return A string containing the line read from the console, not
248+
* including any line-termination characters, or {@code null}
249+
* if an end of stream has been reached.
250+
*/
251251
public String readLine(String fmt, Object ... args) {
252-
String line = null;
253-
synchronized (writeLock) {
254-
synchronized(readLock) {
255-
if (!fmt.isEmpty())
256-
pw.format(fmt, args);
257-
try {
258-
char[] ca = readline(false);
259-
if (ca != null)
260-
line = new String(ca);
261-
} catch (IOException x) {
262-
throw new IOError(x);
263-
}
264-
}
265-
}
266-
return line;
252+
throw newUnsupportedOperationException();
267253
}
268254

269-
/**
270-
* Reads a single line of text from the console.
271-
*
272-
* @throws IOError
273-
* If an I/O error occurs.
274-
*
275-
* @return A string containing the line read from the console, not
276-
* including any line-termination characters, or {@code null}
277-
* if an end of stream has been reached.
278-
*/
255+
/**
256+
* Reads a single line of text from the console.
257+
*
258+
* @throws IOError
259+
* If an I/O error occurs.
260+
*
261+
* @return A string containing the line read from the console, not
262+
* including any line-termination characters, or {@code null}
263+
* if an end of stream has been reached.
264+
*/
279265
public String readLine() {
280-
return readLine("");
266+
throw newUnsupportedOperationException();
281267
}
282268

283-
/**
284-
* Provides a formatted prompt, then reads a password or passphrase from
285-
* the console with echoing disabled.
286-
*
287-
* @param fmt
288-
* A format string as described in <a
289-
* href="../util/Formatter.html#syntax">Format string syntax</a>
290-
* for the prompt text.
291-
*
292-
* @param args
293-
* Arguments referenced by the format specifiers in the format
294-
* string. If there are more arguments than format specifiers, the
295-
* extra arguments are ignored. The maximum number of arguments is
296-
* limited by the maximum dimension of a Java array as defined by
297-
* <cite>The Java Virtual Machine Specification</cite>.
298-
*
299-
* @throws IllegalFormatException
300-
* If a format string contains an illegal syntax, a format
301-
* specifier that is incompatible with the given arguments,
302-
* insufficient arguments given the format string, or other
303-
* illegal conditions. For specification of all possible
304-
* formatting errors, see the <a
305-
* href="../util/Formatter.html#detail">Details</a>
306-
* section of the formatter class specification.
307-
*
308-
* @throws IOError
309-
* If an I/O error occurs.
310-
*
311-
* @return A character array containing the password or passphrase read
312-
* from the console, not including any line-termination characters,
313-
* or {@code null} if an end of stream has been reached.
314-
*/
269+
/**
270+
* Provides a formatted prompt, then reads a password or passphrase from
271+
* the console with echoing disabled.
272+
*
273+
* @param fmt
274+
* A format string as described in <a
275+
* href="../util/Formatter.html#syntax">Format string syntax</a>
276+
* for the prompt text.
277+
*
278+
* @param args
279+
* Arguments referenced by the format specifiers in the format
280+
* string. If there are more arguments than format specifiers, the
281+
* extra arguments are ignored. The maximum number of arguments is
282+
* limited by the maximum dimension of a Java array as defined by
283+
* <cite>The Java Virtual Machine Specification</cite>.
284+
*
285+
* @throws IllegalFormatException
286+
* If a format string contains an illegal syntax, a format
287+
* specifier that is incompatible with the given arguments,
288+
* insufficient arguments given the format string, or other
289+
* illegal conditions. For specification of all possible
290+
* formatting errors, see the <a
291+
* href="../util/Formatter.html#detail">Details</a>
292+
* section of the formatter class specification.
293+
*
294+
* @throws IOError
295+
* If an I/O error occurs.
296+
*
297+
* @return A character array containing the password or passphrase read
298+
* from the console, not including any line-termination characters,
299+
* or {@code null} if an end of stream has been reached.
300+
*/
315301
public char[] readPassword(String fmt, Object ... args) {
316-
char[] passwd = null;
317-
synchronized (writeLock) {
318-
synchronized(readLock) {
319-
installShutdownHook();
320-
try {
321-
restoreEcho = echo(false);
322-
} catch (IOException x) {
323-
throw new IOError(x);
324-
}
325-
IOError ioe = null;
326-
try {
327-
if (!fmt.isEmpty())
328-
pw.format(fmt, args);
329-
passwd = readline(true);
330-
} catch (IOException x) {
331-
ioe = new IOError(x);
332-
} finally {
333-
try {
334-
if (restoreEcho)
335-
restoreEcho = echo(true);
336-
} catch (IOException x) {
337-
if (ioe == null)
338-
ioe = new IOError(x);
339-
else
340-
ioe.addSuppressed(x);
341-
}
342-
if (ioe != null)
343-
throw ioe;
344-
}
345-
pw.println();
346-
}
347-
}
348-
return passwd;
302+
throw newUnsupportedOperationException();
349303
}
350304

351-
private void installShutdownHook() {
352-
if (shutdownHookInstalled)
353-
return;
354-
try {
355-
// Add a shutdown hook to restore console's echo state should
356-
// it be necessary.
357-
SharedSecrets.getJavaLangAccess()
358-
.registerShutdownHook(0 /* shutdown hook invocation order */,
359-
false /* only register if shutdown is not in progress */,
360-
new Runnable() {
361-
public void run() {
362-
try {
363-
if (restoreEcho) {
364-
echo(true);
365-
}
366-
} catch (IOException x) { }
367-
}
368-
});
369-
} catch (IllegalStateException e) {
370-
// shutdown is already in progress and readPassword is first used
371-
// by a shutdown hook
372-
}
373-
shutdownHookInstalled = true;
374-
}
375-
376-
/**
377-
* Reads a password or passphrase from the console with echoing disabled
378-
*
379-
* @throws IOError
380-
* If an I/O error occurs.
381-
*
382-
* @return A character array containing the password or passphrase read
383-
* from the console, not including any line-termination characters,
384-
* or {@code null} if an end of stream has been reached.
385-
*/
305+
/**
306+
* Reads a password or passphrase from the console with echoing disabled
307+
*
308+
* @throws IOError
309+
* If an I/O error occurs.
310+
*
311+
* @return A character array containing the password or passphrase read
312+
* from the console, not including any line-termination characters,
313+
* or {@code null} if an end of stream has been reached.
314+
*/
386315
public char[] readPassword() {
387-
return readPassword("");
316+
throw newUnsupportedOperationException();
388317
}
389318

390319
/**
391320
* Flushes the console and forces any buffered output to be written
392321
* immediately .
393322
*/
394323
public void flush() {
395-
pw.flush();
324+
throw newUnsupportedOperationException();
396325
}
397326

398-
399327
/**
400328
* Returns the {@link java.nio.charset.Charset Charset} object used for
401329
* the {@code Console}.
@@ -410,171 +338,16 @@ public void flush() {
410338
* @since 17
411339
*/
412340
public Charset charset() {
413-
assert CHARSET != null : "charset() should not return null";
414-
return CHARSET;
341+
throw newUnsupportedOperationException();
415342
}
416343

417-
private Object readLock;
418-
private Object writeLock;
419-
private Reader reader;
420-
private Writer out;
421-
private PrintWriter pw;
422-
private Formatter formatter;
423-
private char[] rcb;
424-
private boolean restoreEcho;
425-
private boolean shutdownHookInstalled;
426-
private static native String encoding();
427-
/*
428-
* Sets the console echo status to {@code on} and returns the previous
429-
* console on/off status.
430-
* @param on the echo status to set to. {@code true} for echo on and
431-
* {@code false} for echo off
432-
* @return true if the previous console echo status is on
433-
*/
434-
private static native boolean echo(boolean on) throws IOException;
435-
436-
private char[] readline(boolean zeroOut) throws IOException {
437-
int len = reader.read(rcb, 0, rcb.length);
438-
if (len < 0)
439-
return null; //EOL
440-
if (rcb[len-1] == '\r')
441-
len--; //remove CR at end;
442-
else if (rcb[len-1] == '\n') {
443-
len--; //remove LF at end;
444-
if (len > 0 && rcb[len-1] == '\r')
445-
len--; //remove the CR, if there is one
446-
}
447-
char[] b = new char[len];
448-
if (len > 0) {
449-
System.arraycopy(rcb, 0, b, 0, len);
450-
if (zeroOut) {
451-
Arrays.fill(rcb, 0, len, ' ');
452-
}
453-
}
454-
return b;
455-
}
456-
457-
private char[] grow() {
458-
assert Thread.holdsLock(readLock);
459-
char[] t = new char[rcb.length * 2];
460-
System.arraycopy(rcb, 0, t, 0, rcb.length);
461-
rcb = t;
462-
return rcb;
463-
}
464-
465-
class LineReader extends Reader {
466-
private Reader in;
467-
private char[] cb;
468-
private int nChars, nextChar;
469-
boolean leftoverLF;
470-
LineReader(Reader in) {
471-
this.in = in;
472-
cb = new char[1024];
473-
nextChar = nChars = 0;
474-
leftoverLF = false;
475-
}
476-
public void close () {}
477-
public boolean ready() throws IOException {
478-
//in.ready synchronizes on readLock already
479-
return in.ready();
480-
}
481-
482-
public int read(char[] cbuf, int offset, int length)
483-
throws IOException
484-
{
485-
int off = offset;
486-
int end = offset + length;
487-
if (offset < 0 || offset > cbuf.length || length < 0 ||
488-
end < 0 || end > cbuf.length) {
489-
throw new IndexOutOfBoundsException();
490-
}
491-
synchronized(readLock) {
492-
boolean eof = false;
493-
char c = 0;
494-
for (;;) {
495-
if (nextChar >= nChars) { //fill
496-
int n = 0;
497-
do {
498-
n = in.read(cb, 0, cb.length);
499-
} while (n == 0);
500-
if (n > 0) {
501-
nChars = n;
502-
nextChar = 0;
503-
if (n < cb.length &&
504-
cb[n-1] != '\n' && cb[n-1] != '\r') {
505-
/*
506-
* we're in canonical mode so each "fill" should
507-
* come back with an eol. if there no lf or nl at
508-
* the end of returned bytes we reached an eof.
509-
*/
510-
eof = true;
511-
}
512-
} else { /*EOF*/
513-
if (off - offset == 0)
514-
return -1;
515-
return off - offset;
516-
}
517-
}
518-
if (leftoverLF && cbuf == rcb && cb[nextChar] == '\n') {
519-
/*
520-
* if invoked by our readline, skip the leftover, otherwise
521-
* return the LF.
522-
*/
523-
nextChar++;
524-
}
525-
leftoverLF = false;
526-
while (nextChar < nChars) {
527-
c = cbuf[off++] = cb[nextChar];
528-
cb[nextChar++] = 0;
529-
if (c == '\n') {
530-
return off - offset;
531-
} else if (c == '\r') {
532-
if (off == end) {
533-
/* no space left even the next is LF, so return
534-
* whatever we have if the invoker is not our
535-
* readLine()
536-
*/
537-
if (cbuf == rcb) {
538-
cbuf = grow();
539-
end = cbuf.length;
540-
} else {
541-
leftoverLF = true;
542-
return off - offset;
543-
}
544-
}
545-
if (nextChar == nChars && in.ready()) {
546-
/*
547-
* we have a CR and we reached the end of
548-
* the read in buffer, fill to make sure we
549-
* don't miss a LF, if there is one, it's possible
550-
* that it got cut off during last round reading
551-
* simply because the read in buffer was full.
552-
*/
553-
nChars = in.read(cb, 0, cb.length);
554-
nextChar = 0;
555-
}
556-
if (nextChar < nChars && cb[nextChar] == '\n') {
557-
cbuf[off++] = '\n';
558-
nextChar++;
559-
}
560-
return off - offset;
561-
} else if (off == end) {
562-
if (cbuf == rcb) {
563-
cbuf = grow();
564-
end = cbuf.length;
565-
} else {
566-
return off - offset;
567-
}
568-
}
569-
}
570-
if (eof)
571-
return off - offset;
572-
}
573-
}
574-
}
344+
private static UnsupportedOperationException newUnsupportedOperationException() {
345+
return new UnsupportedOperationException(
346+
"Console class itself does not provide implementation");
575347
}
576348

577-
private static final Charset CHARSET;
349+
private static native String encoding();
350+
static final Charset CHARSET;
578351
static {
579352
Charset cs = null;
580353
boolean istty = istty();
@@ -619,31 +392,15 @@ private static Console instantiateConsole(boolean istty) {
619392
.filter(Objects::nonNull)
620393
.findAny()
621394
.map(jc -> (Console) new ProxyingConsole(jc))
622-
.orElse(istty ? new Console() : null);
395+
.orElse(istty ? new ConsoleImpl() : null);
623396
};
624397
return AccessController.doPrivileged(pa);
625398
} catch (ServiceConfigurationError ignore) {
626399
// default to built-in Console
627-
return istty ? new Console() : null;
400+
return istty ? new ConsoleImpl() : null;
628401
}
629402
}
630403

631404
private static final Console cons;
632405
private static native boolean istty();
633-
634-
Console() {
635-
readLock = new Object();
636-
writeLock = new Object();
637-
out = StreamEncoder.forOutputStreamWriter(
638-
new FileOutputStream(FileDescriptor.out),
639-
writeLock,
640-
CHARSET);
641-
pw = new PrintWriter(out, true) { public void close() {} };
642-
formatter = new Formatter(out);
643-
reader = new LineReader(StreamDecoder.forInputStreamReader(
644-
new FileInputStream(FileDescriptor.in),
645-
readLock,
646-
CHARSET));
647-
rcb = new char[1024];
648-
}
649406
}

‎src/java.base/share/classes/java/io/ConsoleImpl.java

+366
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,366 @@
1+
/*
2+
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
3+
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+
*
5+
* This code is free software; you can redistribute it and/or modify it
6+
* under the terms of the GNU General Public License version 2 only, as
7+
* published by the Free Software Foundation. Oracle designates this
8+
* particular file as subject to the "Classpath" exception as provided
9+
* by Oracle in the LICENSE file that accompanied this code.
10+
*
11+
* This code is distributed in the hope that it will be useful, but WITHOUT
12+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+
* version 2 for more details (a copy is included in the LICENSE file that
15+
* accompanied this code).
16+
*
17+
* You should have received a copy of the GNU General Public License version
18+
* 2 along with this work; if not, write to the Free Software Foundation,
19+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+
*
21+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+
* or visit www.oracle.com if you need additional information or have any
23+
* questions.
24+
*/
25+
26+
package java.io;
27+
28+
import java.util.*;
29+
import java.nio.charset.Charset;
30+
import jdk.internal.access.SharedSecrets;
31+
import sun.nio.cs.StreamDecoder;
32+
import sun.nio.cs.StreamEncoder;
33+
34+
/**
35+
* Console implementation based on the platform's TTY.
36+
*/
37+
38+
final class ConsoleImpl extends Console {
39+
/**
40+
* {@inheritDoc}
41+
*/
42+
@Override
43+
public PrintWriter writer() {
44+
return pw;
45+
}
46+
47+
/**
48+
* {@inheritDoc}
49+
*/
50+
@Override
51+
public Reader reader() {
52+
return reader;
53+
}
54+
55+
/**
56+
* {@inheritDoc}
57+
*/
58+
@Override
59+
public Console format(String fmt, Object ...args) {
60+
formatter.format(fmt, args).flush();
61+
return this;
62+
}
63+
64+
/**
65+
* {@inheritDoc}
66+
*/
67+
@Override
68+
public Console printf(String format, Object ... args) {
69+
return format(format, args);
70+
}
71+
72+
/**
73+
* {@inheritDoc}
74+
*/
75+
@Override
76+
public String readLine(String fmt, Object ... args) {
77+
String line = null;
78+
synchronized (writeLock) {
79+
synchronized(readLock) {
80+
if (!fmt.isEmpty())
81+
pw.format(fmt, args);
82+
try {
83+
char[] ca = readline(false);
84+
if (ca != null)
85+
line = new String(ca);
86+
} catch (IOException x) {
87+
throw new IOError(x);
88+
}
89+
}
90+
}
91+
return line;
92+
}
93+
94+
/**
95+
* {@inheritDoc}
96+
*/
97+
@Override
98+
public String readLine() {
99+
return readLine("");
100+
}
101+
102+
/**
103+
* {@inheritDoc}
104+
*/
105+
@Override
106+
public char[] readPassword(String fmt, Object ... args) {
107+
char[] passwd = null;
108+
synchronized (writeLock) {
109+
synchronized(readLock) {
110+
installShutdownHook();
111+
try {
112+
restoreEcho = echo(false);
113+
} catch (IOException x) {
114+
throw new IOError(x);
115+
}
116+
IOError ioe = null;
117+
try {
118+
if (!fmt.isEmpty())
119+
pw.format(fmt, args);
120+
passwd = readline(true);
121+
} catch (IOException x) {
122+
ioe = new IOError(x);
123+
} finally {
124+
try {
125+
if (restoreEcho)
126+
restoreEcho = echo(true);
127+
} catch (IOException x) {
128+
if (ioe == null)
129+
ioe = new IOError(x);
130+
else
131+
ioe.addSuppressed(x);
132+
}
133+
if (ioe != null)
134+
throw ioe;
135+
}
136+
pw.println();
137+
}
138+
}
139+
return passwd;
140+
}
141+
142+
private void installShutdownHook() {
143+
if (shutdownHookInstalled)
144+
return;
145+
try {
146+
// Add a shutdown hook to restore console's echo state should
147+
// it be necessary.
148+
SharedSecrets.getJavaLangAccess()
149+
.registerShutdownHook(0 /* shutdown hook invocation order */,
150+
false /* only register if shutdown is not in progress */,
151+
new Runnable() {
152+
public void run() {
153+
try {
154+
if (restoreEcho) {
155+
echo(true);
156+
}
157+
} catch (IOException x) { }
158+
}
159+
});
160+
} catch (IllegalStateException e) {
161+
// shutdown is already in progress and readPassword is first used
162+
// by a shutdown hook
163+
}
164+
shutdownHookInstalled = true;
165+
}
166+
167+
/**
168+
* {@inheritDoc}
169+
*/
170+
@Override
171+
public char[] readPassword() {
172+
return readPassword("");
173+
}
174+
175+
/**
176+
* {@inheritDoc}
177+
*/
178+
@Override
179+
public void flush() {
180+
pw.flush();
181+
}
182+
183+
/**
184+
* {@inheritDoc}
185+
*/
186+
@Override
187+
public Charset charset() {
188+
assert CHARSET != null : "charset() should not return null";
189+
return CHARSET;
190+
}
191+
192+
private final Object readLock;
193+
private final Object writeLock;
194+
private final Reader reader;
195+
private final Writer out;
196+
private final PrintWriter pw;
197+
private final Formatter formatter;
198+
private char[] rcb;
199+
private boolean restoreEcho;
200+
private boolean shutdownHookInstalled;
201+
202+
private char[] readline(boolean zeroOut) throws IOException {
203+
int len = reader.read(rcb, 0, rcb.length);
204+
if (len < 0)
205+
return null; //EOL
206+
if (rcb[len-1] == '\r')
207+
len--; //remove CR at end;
208+
else if (rcb[len-1] == '\n') {
209+
len--; //remove LF at end;
210+
if (len > 0 && rcb[len-1] == '\r')
211+
len--; //remove the CR, if there is one
212+
}
213+
char[] b = new char[len];
214+
if (len > 0) {
215+
System.arraycopy(rcb, 0, b, 0, len);
216+
if (zeroOut) {
217+
Arrays.fill(rcb, 0, len, ' ');
218+
}
219+
}
220+
return b;
221+
}
222+
223+
private char[] grow() {
224+
assert Thread.holdsLock(readLock);
225+
char[] t = new char[rcb.length * 2];
226+
System.arraycopy(rcb, 0, t, 0, rcb.length);
227+
rcb = t;
228+
return rcb;
229+
}
230+
231+
/*
232+
* Sets the console echo status to {@code on} and returns the previous
233+
* console on/off status.
234+
* @param on the echo status to set to. {@code true} for echo on and
235+
* {@code false} for echo off
236+
* @return true if the previous console echo status is on
237+
*/
238+
private static native boolean echo(boolean on) throws IOException;
239+
240+
class LineReader extends Reader {
241+
private final Reader in;
242+
private final char[] cb;
243+
private int nChars, nextChar;
244+
boolean leftoverLF;
245+
LineReader(Reader in) {
246+
this.in = in;
247+
cb = new char[1024];
248+
nextChar = nChars = 0;
249+
leftoverLF = false;
250+
}
251+
public void close () {}
252+
public boolean ready() throws IOException {
253+
//in.ready synchronizes on readLock already
254+
return in.ready();
255+
}
256+
257+
public int read(char[] cbuf, int offset, int length)
258+
throws IOException
259+
{
260+
int off = offset;
261+
int end = offset + length;
262+
if (offset < 0 || offset > cbuf.length || length < 0 ||
263+
end < 0 || end > cbuf.length) {
264+
throw new IndexOutOfBoundsException();
265+
}
266+
synchronized(readLock) {
267+
boolean eof = false;
268+
char c;
269+
for (;;) {
270+
if (nextChar >= nChars) { //fill
271+
int n;
272+
do {
273+
n = in.read(cb, 0, cb.length);
274+
} while (n == 0);
275+
if (n > 0) {
276+
nChars = n;
277+
nextChar = 0;
278+
if (n < cb.length &&
279+
cb[n-1] != '\n' && cb[n-1] != '\r') {
280+
/*
281+
* we're in canonical mode so each "fill" should
282+
* come back with an eol. if there is no lf or nl at
283+
* the end of returned bytes we reached an eof.
284+
*/
285+
eof = true;
286+
}
287+
} else { /*EOF*/
288+
if (off - offset == 0)
289+
return -1;
290+
return off - offset;
291+
}
292+
}
293+
if (leftoverLF && cbuf == rcb && cb[nextChar] == '\n') {
294+
/*
295+
* if invoked by our readline, skip the leftover, otherwise
296+
* return the LF.
297+
*/
298+
nextChar++;
299+
}
300+
leftoverLF = false;
301+
while (nextChar < nChars) {
302+
c = cbuf[off++] = cb[nextChar];
303+
cb[nextChar++] = 0;
304+
if (c == '\n') {
305+
return off - offset;
306+
} else if (c == '\r') {
307+
if (off == end) {
308+
/* no space left even the next is LF, so return
309+
* whatever we have if the invoker is not our
310+
* readLine()
311+
*/
312+
if (cbuf == rcb) {
313+
cbuf = grow();
314+
} else {
315+
leftoverLF = true;
316+
return off - offset;
317+
}
318+
}
319+
if (nextChar == nChars && in.ready()) {
320+
/*
321+
* we have a CR and we reached the end of
322+
* the read in buffer, fill to make sure we
323+
* don't miss a LF, if there is one, it's possible
324+
* that it got cut off during last round reading
325+
* simply because the read in buffer was full.
326+
*/
327+
nChars = in.read(cb, 0, cb.length);
328+
nextChar = 0;
329+
}
330+
if (nextChar < nChars && cb[nextChar] == '\n') {
331+
cbuf[off++] = '\n';
332+
nextChar++;
333+
}
334+
return off - offset;
335+
} else if (off == end) {
336+
if (cbuf == rcb) {
337+
cbuf = grow();
338+
end = cbuf.length;
339+
} else {
340+
return off - offset;
341+
}
342+
}
343+
}
344+
if (eof)
345+
return off - offset;
346+
}
347+
}
348+
}
349+
}
350+
351+
ConsoleImpl() {
352+
readLock = new Object();
353+
writeLock = new Object();
354+
out = StreamEncoder.forOutputStreamWriter(
355+
new FileOutputStream(FileDescriptor.out),
356+
writeLock,
357+
CHARSET);
358+
pw = new PrintWriter(out, true) { public void close() {} };
359+
formatter = new Formatter(out);
360+
reader = new LineReader(StreamDecoder.forInputStreamReader(
361+
new FileInputStream(FileDescriptor.in),
362+
readLock,
363+
CHARSET));
364+
rcb = new char[1024];
365+
}
366+
}

‎src/java.base/unix/native/libjava/Console_md.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
2+
* Copyright (c) 2005, 2022, Oracle and/or its affiliates. All rights reserved.
33
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
44
*
55
* This code is free software; you can redistribute it and/or modify it
@@ -27,6 +27,7 @@
2727
#include "jni_util.h"
2828
#include "jvm.h"
2929
#include "java_io_Console.h"
30+
#include "java_io_ConsoleImpl.h"
3031

3132
#include <stdlib.h>
3233
#include <unistd.h>
@@ -45,7 +46,7 @@ Java_java_io_Console_encoding(JNIEnv *env, jclass cls)
4546
}
4647

4748
JNIEXPORT jboolean JNICALL
48-
Java_java_io_Console_echo(JNIEnv *env,
49+
Java_java_io_ConsoleImpl_echo(JNIEnv *env,
4950
jclass cls,
5051
jboolean on)
5152
{

0 commit comments

Comments
 (0)
Please sign in to comment.