package jdk.internal.jline;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import jdk.internal.jline.internal.Configuration;
import jdk.internal.jline.internal.Log;
import jdk.internal.jline.internal.Preconditions;
import static jdk.internal.jline.internal.Preconditions.checkNotNull;
public class TerminalFactory
{
public static final String JLINE_TERMINAL = "jline.terminal";
public static final String AUTO = "auto";
public static final String UNIX = "unix";
public static final String WIN = "win";
public static final String WINDOWS = "windows";
public static final String NONE = "none";
public static final String OFF = "off";
public static final String FALSE = "false";
private static Terminal term = null;
public static synchronized Terminal create() {
if (Log.TRACE) {
Log.trace(new Throwable("CREATE MARKER"));
}
String type = Configuration.getString(JLINE_TERMINAL, AUTO);
if ("dumb".equals(System.getenv("TERM"))) {
type = "none";
Log.debug("$TERM=dumb; setting type=", type);
}
Log.debug("Creating terminal; type=", type);
Terminal t;
try {
String tmp = type.toLowerCase();
if (tmp.equals(UNIX)) {
t = getFlavor(Flavor.UNIX);
}
else if (tmp.equals(WIN) | tmp.equals(WINDOWS)) {
t = getFlavor(Flavor.WINDOWS);
}
else if (tmp.equals(NONE) || tmp.equals(OFF) || tmp.equals(FALSE)) {
t = new UnsupportedTerminal();
}
else {
if (tmp.equals(AUTO)) {
String os = Configuration.getOsName();
Flavor flavor = Flavor.UNIX;
if (os.contains(WINDOWS)) {
flavor = Flavor.WINDOWS;
}
t = getFlavor(flavor);
}
else {
try {
@SuppressWarnings("deprecation")
Object o = Thread.currentThread().getContextClassLoader().loadClass(type).newInstance();
t = (Terminal) o;
}
catch (Exception e) {
throw new IllegalArgumentException(MessageFormat.format("Invalid terminal type: {0}", type), e);
}
}
}
}
catch (Exception e) {
Log.error("Failed to construct terminal; falling back to unsupported", e);
t = new UnsupportedTerminal();
}
Log.debug("Created Terminal: ", t);
try {
t.init();
}
catch (Throwable e) {
Log.error("Terminal initialization failed; falling back to unsupported", e);
return new UnsupportedTerminal();
}
return t;
}
public static synchronized void reset() {
term = null;
}
public static synchronized void resetIf(final Terminal t) {
if(t == term) {
reset();
}
}
public static enum Type
{
AUTO,
WINDOWS,
UNIX,
NONE
}
public static synchronized void configure(final String type) {
checkNotNull(type);
System.setProperty(JLINE_TERMINAL, type);
}
public static synchronized void configure(final Type type) {
checkNotNull(type);
configure(type.name().toLowerCase());
}
public static enum Flavor
{
WINDOWS,
UNIX
}
private static final Map<Flavor, Callable<? extends Terminal>> FLAVORS = new HashMap<>();
static {
registerFlavor(Flavor.WINDOWS, WindowsTerminal :: new);
registerFlavor(Flavor.UNIX, UnixTerminal :: new);
}
public static synchronized Terminal get() {
if (term == null) {
term = create();
}
return term;
}
public static Terminal getFlavor(final Flavor flavor) throws Exception {
return FLAVORS.getOrDefault(flavor, () -> {throw new InternalError();}).call();
}
public static void registerFlavor(final Flavor flavor, final Callable<? extends Terminal> sup) {
FLAVORS.put(flavor, sup);
}
}