From 35c56431b3dc80e32e5671d79de65eb0a0b0e9f5 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Fri, 27 May 2016 19:21:58 +0300 Subject: [PATCH] J2K ReplFromTerminal, convert code --- .../kotlin/cli/jvm/repl/ReplFromTerminal.java | 262 +++++++++--------- 1 file changed, 130 insertions(+), 132 deletions(-) diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplFromTerminal.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplFromTerminal.java index 58d2f8981d6..e1026f9ac41 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplFromTerminal.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplFromTerminal.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2015 JetBrains s.r.o. + * Copyright 2010-2016 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,237 +14,235 @@ * limitations under the License. */ -package org.jetbrains.kotlin.cli.jvm.repl; +package org.jetbrains.kotlin.cli.jvm.repl -import com.intellij.openapi.Disposable; -import com.intellij.openapi.util.io.FileUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.cli.common.KotlinVersion; -import org.jetbrains.kotlin.cli.jvm.repl.messages.*; -import org.jetbrains.kotlin.cli.jvm.repl.reader.ConsoleReplCommandReader; -import org.jetbrains.kotlin.cli.jvm.repl.reader.IdeReplCommandReader; -import org.jetbrains.kotlin.cli.jvm.repl.reader.ReplCommandReader; -import org.jetbrains.kotlin.config.CompilerConfiguration; -import org.jetbrains.kotlin.utils.ExceptionUtilsKt; +import com.intellij.openapi.Disposable +import com.intellij.openapi.util.io.FileUtil +import org.jetbrains.kotlin.cli.common.KotlinVersion +import org.jetbrains.kotlin.cli.jvm.repl.messages.* +import org.jetbrains.kotlin.cli.jvm.repl.reader.ConsoleReplCommandReader +import org.jetbrains.kotlin.cli.jvm.repl.reader.IdeReplCommandReader +import org.jetbrains.kotlin.cli.jvm.repl.reader.ReplCommandReader +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.utils.* -import java.io.File; -import java.io.PrintWriter; -import java.util.Arrays; -import java.util.List; +import java.io.File +import java.io.PrintWriter +import java.util.Arrays -public class ReplFromTerminal { +class ReplFromTerminal( + disposable: Disposable, + compilerConfiguration: CompilerConfiguration +) { - private ReplInterpreter replInterpreter; - private Throwable replInitializationFailed; - private final Object waitRepl = new Object(); + private var replInterpreter: ReplInterpreter? = null + private var replInitializationFailed: Throwable? = null + private val waitRepl = Object() - private final boolean ideMode; - private ReplSystemInWrapper replReader; - private final ReplWriter replWriter; - private final ReplErrorLogger replErrorLogger; + private val ideMode: Boolean + private var replReader: ReplSystemInWrapper? = null + private val replWriter: ReplWriter + private val replErrorLogger: ReplErrorLogger - private ReplCommandReader commandReader; + private var commandReader: ReplCommandReader? = null - public ReplFromTerminal( - @NotNull final Disposable disposable, - @NotNull final CompilerConfiguration compilerConfiguration - ) { - String replIdeMode = System.getProperty("kotlin.repl.ideMode"); - ideMode = replIdeMode != null && replIdeMode.equals("true"); + init { + val replIdeMode = System.getProperty("kotlin.repl.ideMode") + ideMode = replIdeMode != null && replIdeMode == "true" // wrapper for `out` is required to escape every input in [ideMode]; // if [ideMode == false] then just redirects all input to [System.out] // if user calls [System.setOut(...)] then undefined behaviour if (ideMode) { - ReplSystemOutWrapperForIde soutWrapper = new ReplSystemOutWrapperForIde(System.out); - replWriter = soutWrapper; - System.setOut(soutWrapper); + val soutWrapper = ReplSystemOutWrapperForIde(System.out) + replWriter = soutWrapper + System.setOut(soutWrapper) } else { - replWriter = new ReplConsoleWriter(); + replWriter = ReplConsoleWriter() } // wrapper for `in` is required to give user possibility of calling // [readLine] from ide-console repl if (ideMode) { - replReader = new ReplSystemInWrapper(System.in, replWriter); - System.setIn(replReader); + replReader = ReplSystemInWrapper(System.`in`, replWriter) + System.setIn(replReader!!) } - replErrorLogger = new ReplErrorLogger(ideMode, replWriter); + replErrorLogger = ReplErrorLogger(ideMode, replWriter) - new Thread("initialize-repl") { - @Override - public void run() { + object : Thread("initialize-repl") { + override fun run() { try { - replInterpreter = new ReplInterpreter(disposable, compilerConfiguration, ideMode, replReader); + replInterpreter = ReplInterpreter(disposable, compilerConfiguration, ideMode, replReader) } - catch (Throwable e) { - replInitializationFailed = e; + catch (e: Throwable) { + replInitializationFailed = e } + synchronized (waitRepl) { - waitRepl.notifyAll(); + waitRepl.notifyAll() } } - }.start(); + }.start() try { - commandReader = createCommandReader(); + commandReader = createCommandReader() } - catch (Exception e) { - replErrorLogger.logException(e); + catch (e: Exception) { + replErrorLogger.logException(e) } + } - @NotNull - private ReplCommandReader createCommandReader() { - return ideMode ? new IdeReplCommandReader() - : new ConsoleReplCommandReader(); + private fun createCommandReader(): ReplCommandReader { + return if (ideMode) + IdeReplCommandReader() + else + ConsoleReplCommandReader() } - private ReplInterpreter getReplInterpreter() { + private fun getReplInterpreter(): ReplInterpreter { if (replInterpreter != null) { - return replInterpreter; + return replInterpreter!! } synchronized (waitRepl) { while (replInterpreter == null && replInitializationFailed == null) { try { - waitRepl.wait(); + waitRepl.wait() } - catch (Throwable e) { - throw ExceptionUtilsKt.rethrow(e); + catch (e: Throwable) { + throw rethrow(e) } + } if (replInterpreter != null) { - return replInterpreter; + return replInterpreter!! } - throw ExceptionUtilsKt.rethrow(replInitializationFailed); + throw rethrow(replInitializationFailed!!) } } - private void doRun() { + private fun doRun() { try { - replWriter.printlnWelcomeMessage("Welcome to Kotlin version " + KotlinVersion.VERSION + - " (JRE " + System.getProperty("java.runtime.version") + ")"); - replWriter.printlnWelcomeMessage("Type :help for help, :quit for quit"); - WhatNextAfterOneLine next = WhatNextAfterOneLine.READ_LINE; + replWriter.printlnWelcomeMessage("Welcome to Kotlin version ${KotlinVersion.VERSION} " + + "(JRE ${System.getProperty("java.runtime.version")})") + replWriter.printlnWelcomeMessage("Type :help for help, :quit for quit") + var next = WhatNextAfterOneLine.READ_LINE while (true) { - next = one(next); + next = one(next) if (next == WhatNextAfterOneLine.QUIT) { - break; + break } } } - catch (Exception e) { - replErrorLogger.logException(e); + catch (e: Exception) { + replErrorLogger.logException(e) } finally { try { - commandReader.flushHistory(); + commandReader!!.flushHistory() } - catch (Exception e) { - replErrorLogger.logException(e); + catch (e: Exception) { + replErrorLogger.logException(e) } + } } - public enum WhatNextAfterOneLine { + enum class WhatNextAfterOneLine { READ_LINE, INCOMPLETE, - QUIT, + QUIT } - @NotNull - private WhatNextAfterOneLine one(@NotNull WhatNextAfterOneLine next) { + private fun one(next: WhatNextAfterOneLine): WhatNextAfterOneLine { try { - String line = commandReader.readLine(next); + var line = commandReader!!.readLine(next) ?: return WhatNextAfterOneLine.QUIT - if (line == null) { - return WhatNextAfterOneLine.QUIT; + line = unescapeLineBreaks(line) + + if (line.startsWith(":") && (line.length == 1 || line.get(1) != ':')) { + val notQuit = oneCommand(line.substring(1)) + return if (notQuit) WhatNextAfterOneLine.READ_LINE else WhatNextAfterOneLine.QUIT } - line = UnescapeUtilsKt.unescapeLineBreaks(line); - - if (line.startsWith(":") && (line.length() == 1 || line.charAt(1) != ':')) { - boolean notQuit = oneCommand(line.substring(1)); - return notQuit ? WhatNextAfterOneLine.READ_LINE : WhatNextAfterOneLine.QUIT; - } - - ReplInterpreter.LineResultType lineResultType = eval(line); - if (lineResultType == ReplInterpreter.LineResultType.INCOMPLETE) { - return WhatNextAfterOneLine.INCOMPLETE; + val lineResultType = eval(line) + if (lineResultType === ReplInterpreter.LineResultType.INCOMPLETE) { + return WhatNextAfterOneLine.INCOMPLETE } else { - return WhatNextAfterOneLine.READ_LINE; + return WhatNextAfterOneLine.READ_LINE } } - catch (Exception e) { - throw ExceptionUtilsKt.rethrow(e); + catch (e: Exception) { + throw rethrow(e) } + } - @NotNull - private ReplInterpreter.LineResultType eval(@NotNull String line) { - ReplInterpreter.LineResult lineResult = getReplInterpreter().eval(line); - if (lineResult.getType() == ReplInterpreter.LineResultType.SUCCESS) { - replWriter.notifyCommandSuccess(); - if (!lineResult.isUnit()) { - replWriter.outputCommandResult(lineResult.getValue()); + private fun eval(line: String): ReplInterpreter.LineResultType { + val lineResult = getReplInterpreter().eval(line) + if (lineResult.type === ReplInterpreter.LineResultType.SUCCESS) { + replWriter.notifyCommandSuccess() + if (!lineResult.isUnit) { + replWriter.outputCommandResult(lineResult.value) } } - else if (lineResult.getType() == ReplInterpreter.LineResultType.INCOMPLETE) { - replWriter.notifyIncomplete(); + else if (lineResult.type === ReplInterpreter.LineResultType.INCOMPLETE) { + replWriter.notifyIncomplete() } - else if (lineResult.getType() == ReplInterpreter.LineResultType.COMPILE_ERROR) { - replWriter.outputCompileError(lineResult.getErrorText()); + else if (lineResult.type === ReplInterpreter.LineResultType.COMPILE_ERROR) { + replWriter.outputCompileError(lineResult.errorText!!) } - else if (lineResult.getType() == ReplInterpreter.LineResultType.RUNTIME_ERROR) { - replWriter.outputRuntimeError(lineResult.getErrorText()); + else if (lineResult.type === ReplInterpreter.LineResultType.RUNTIME_ERROR) { + replWriter.outputRuntimeError(lineResult.errorText!!) } else { - throw new IllegalStateException("unknown line result type: " + lineResult); + throw IllegalStateException("unknown line result type: " + lineResult) } - return lineResult.getType(); + return lineResult.type } - private boolean oneCommand(@NotNull String command) throws Exception { - List split = splitCommand(command); - if (split.size() >= 1 && command.equals("help")) { + @Throws(Exception::class) + private fun oneCommand(command: String): Boolean { + val split = splitCommand(command) + if (split.size >= 1 && command == "help") { replWriter.printlnHelpMessage("Available commands:\n" + ":help show this help\n" + ":quit exit the interpreter\n" + ":dump bytecode dump classes to terminal\n" + - ":load load script from specified file" - ); - return true; + ":load load script from specified file") + return true } - else if (split.size() >= 2 && split.get(0).equals("dump") && split.get(1).equals("bytecode")) { - getReplInterpreter().dumpClasses(new PrintWriter(System.out)); - return true; + else if (split.size >= 2 && split[0] == "dump" && split[1] == "bytecode") { + getReplInterpreter().dumpClasses(PrintWriter(System.out)) + return true } - else if (split.size() >= 1 && split.get(0).equals("quit")) { - return false; + else if (split.size >= 1 && split[0] == "quit") { + return false } - else if (split.size() >= 2 && split.get(0).equals("load")) { - String fileName = split.get(1); - String scriptText = FileUtil.loadFile(new File(fileName)); - eval(scriptText); - return true; + else if (split.size >= 2 && split[0] == "load") { + val fileName = split[1] + val scriptText = FileUtil.loadFile(File(fileName)) + eval(scriptText) + return true } else { - replWriter.printlnHelpMessage("Unknown command\n" + - "Type :help for help" - ); - return true; + replWriter.printlnHelpMessage("Unknown command\n" + "Type :help for help") + return true } } - private static List splitCommand(@NotNull String command) { - return Arrays.asList(command.split(" ")); - } + companion object { - public static void run(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) { - new ReplFromTerminal(disposable, configuration).doRun(); + private fun splitCommand(command: String): List { + return Arrays.asList(*command.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()) + } + + fun run(disposable: Disposable, configuration: CompilerConfiguration) { + ReplFromTerminal(disposable, configuration).doRun() + } } }