mirror of
https://github.com/curioustorvald/Terrarum.git
synced 2026-03-07 20:31:51 +09:00
75d73f7d18
Former-commit-id: 80e3f0d13c2dc5bcff0843e509f416e9314cd52e Former-commit-id: e7e35bfd23d70db84f568f0c5388f3a1d89222bc
468 lines
17 KiB
Kotlin
468 lines
17 KiB
Kotlin
package net.torvald.terrarum.virtualcomputer.luaapi
|
|
|
|
import li.cil.repack.org.luaj.vm2.*
|
|
import li.cil.repack.org.luaj.vm2.lib.OneArgFunction
|
|
import li.cil.repack.org.luaj.vm2.lib.TwoArgFunction
|
|
import li.cil.repack.org.luaj.vm2.lib.ZeroArgFunction
|
|
import net.torvald.terrarum.Terrarum
|
|
import net.torvald.terrarum.virtualcomputer.computer.BaseTerrarumComputer
|
|
import net.torvald.terrarum.virtualcomputer.luaapi.Term.Companion.checkIBM437
|
|
import java.io.*
|
|
import java.nio.file.Files
|
|
import java.nio.file.Path
|
|
import java.util.*
|
|
|
|
/**
|
|
* computer directory:
|
|
* .../computers/
|
|
* media/hda/ -> .../computers/<uuid for the hda>/
|
|
*
|
|
* Created by minjaesong on 16-09-17.
|
|
*/
|
|
internal class Filesystem(globals: Globals, computer: BaseTerrarumComputer) {
|
|
|
|
init {
|
|
// load things. WARNING: THIS IS MANUAL!
|
|
globals["fs"] = LuaValue.tableOf()
|
|
globals["fs"]["list"] = ListFiles(computer) // CC compliant
|
|
globals["fs"]["exists"] = FileExists(computer) // CC/OC compliant
|
|
globals["fs"]["isDir"] = IsDirectory(computer) // CC compliant
|
|
globals["fs"]["isFile"] = IsFile(computer)
|
|
globals["fs"]["isReadOnly"] = IsReadOnly(computer) // CC compliant
|
|
globals["fs"]["getSize"] = GetSize(computer) // CC compliant
|
|
globals["fs"]["mkdir"] = Mkdir(computer)
|
|
globals["fs"]["mv"] = Mv(computer)
|
|
globals["fs"]["cp"] = Cp(computer)
|
|
globals["fs"]["rm"] = Rm(computer)
|
|
globals["fs"]["concat"] = ConcatPath(computer) // OC compliant
|
|
globals["fs"]["open"] = OpenFile(computer) //CC compliant
|
|
globals["fs"]["parent"] = GetParentDir(computer)
|
|
// fs.dofile defined in ROMLIB
|
|
// fs.fetchText defined in ROMLIB
|
|
}
|
|
|
|
companion object {
|
|
fun ensurePathSanity(path: LuaValue) {
|
|
if (path.checkIBM437().contains(Regex("""\.\.""")))
|
|
throw LuaError("'..' on path is not supported.")
|
|
}
|
|
|
|
val isCaseInsensitive: Boolean
|
|
get() {
|
|
// TODO add: force case insensitive in config
|
|
try {
|
|
val uuid = UUID.randomUUID().toString()
|
|
val lowerCase = File(Terrarum.currentSaveDir, uuid + "oc_rox")
|
|
val upperCase = File(Terrarum.currentSaveDir, uuid + "OC_ROX")
|
|
// This should NEVER happen but could also lead to VERY weird bugs, so we
|
|
// make sure the files don't exist.
|
|
lowerCase.exists() && lowerCase.delete()
|
|
upperCase.exists() && upperCase.delete()
|
|
lowerCase.createNewFile()
|
|
val insensitive = upperCase.exists()
|
|
lowerCase.delete()
|
|
return insensitive
|
|
}
|
|
catch (e: IOException) {
|
|
println("[Filesystem] Couldn't determine if file system is case sensitive, falling back to insensitive.")
|
|
return true
|
|
}
|
|
}
|
|
|
|
// Worst-case: we're on Windows or using a FAT32 partition mounted in *nix.
|
|
// Note: we allow / as the path separator and expect all \s to be converted
|
|
// accordingly before the path is passed to the file system.
|
|
private val invalidChars = Regex("""[\\:*?"<>|]""") // original OC uses Set(); we use regex
|
|
|
|
fun isValidFilename(name: String) = !name.contains(invalidChars)
|
|
|
|
fun validatePath(path: String) : String {
|
|
if (!isValidFilename(path)) {
|
|
throw IOException("path contains invalid characters")
|
|
}
|
|
return path
|
|
}
|
|
|
|
/** actual directory: <appdata>/Saves/<savename>/computers/<drivename>/
|
|
* directs media/ directory to /<uuid> directory
|
|
*/
|
|
fun BaseTerrarumComputer.getRealPath(luapath: LuaValue) : String {
|
|
// direct mounted paths to real path
|
|
val computerDir = Terrarum.currentSaveDir.absolutePath + "/computers/"
|
|
/* if not begins with "(/?)media/", direct to boot
|
|
* else, to corresponding drives
|
|
*
|
|
* List of device names (these are auto-mounted. why? primitivism :p):
|
|
* = hda - hdd: hard disks
|
|
* = fd1 - fd4: floppy drives
|
|
* = sda: whatever external drives, usually a CD
|
|
* = boot: current boot device
|
|
*/
|
|
|
|
// remove first '/' in path
|
|
var path = luapath.checkIBM437()
|
|
if (path.startsWith('/')) path = path.substring(1)
|
|
// replace '\' with '/'
|
|
path.replace('\\', '/')
|
|
|
|
if (path.startsWith("media/")) {
|
|
val device = path.substring(6, 9)
|
|
val subPath = path.substring(9)
|
|
return computerDir + this.computerValue.getAsString("device") + subPath
|
|
}
|
|
else {
|
|
return computerDir + this.computerValue.getAsString("boot") + "/" + path
|
|
}
|
|
}
|
|
|
|
fun combinePath(base: String, local: String) : String {
|
|
return "$base$local".replace("//", "/").replace("\\\\", "\\")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param cname == UUID of the drive
|
|
*
|
|
* actual directory: <appdata>/Saves/<savename>/computers/<drivename>/
|
|
*/
|
|
class ListFiles(val computer: BaseTerrarumComputer) : OneArgFunction() {
|
|
override fun call(path: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
val table = LuaTable()
|
|
val file = File(computer.getRealPath(path))
|
|
file.list().forEachIndexed { i, s -> table.insert(i, LuaValue.valueOf(s)) }
|
|
return table
|
|
}
|
|
}
|
|
|
|
class FileExists(val computer: BaseTerrarumComputer) : OneArgFunction() {
|
|
override fun call(path: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
return LuaValue.valueOf(File(computer.getRealPath(path)).exists())
|
|
}
|
|
}
|
|
|
|
class IsDirectory(val computer: BaseTerrarumComputer) : OneArgFunction() {
|
|
override fun call(path: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
return LuaValue.valueOf(File(computer.getRealPath(path)).isDirectory)
|
|
}
|
|
}
|
|
|
|
class IsFile(val computer: BaseTerrarumComputer) : OneArgFunction() {
|
|
override fun call(path: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
return LuaValue.valueOf(File(computer.getRealPath(path)).isFile)
|
|
}
|
|
}
|
|
|
|
class IsReadOnly(val computer: BaseTerrarumComputer) : OneArgFunction() {
|
|
override fun call(path: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
return LuaValue.valueOf(!File(computer.getRealPath(path)).canWrite())
|
|
}
|
|
}
|
|
|
|
/** we have 4GB file size limit */
|
|
class GetSize(val computer: BaseTerrarumComputer) : OneArgFunction() {
|
|
override fun call(path: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
return LuaValue.valueOf(File(computer.getRealPath(path)).length().toInt())
|
|
}
|
|
}
|
|
|
|
// TODO class GetFreeSpace
|
|
|
|
/**
|
|
* difference with ComputerCraft: it returns boolean, true on successful.
|
|
*/
|
|
class Mkdir(val computer: BaseTerrarumComputer) : OneArgFunction() {
|
|
override fun call(path: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
return LuaValue.valueOf(File(computer.getRealPath(path)).mkdir())
|
|
}
|
|
}
|
|
|
|
/**
|
|
* moves a directory, overwrites the target
|
|
*/
|
|
class Mv(val computer: BaseTerrarumComputer) : TwoArgFunction() {
|
|
override fun call(from: LuaValue, to: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(from)
|
|
Filesystem.ensurePathSanity(to)
|
|
|
|
val fromFile = File(computer.getRealPath(from))
|
|
var success = fromFile.copyRecursively(
|
|
File(computer.getRealPath(to)), overwrite = true
|
|
) // ignore IntelliJ's observation; it's opposite from redundant
|
|
success = fromFile.deleteRecursively()
|
|
return LuaValue.valueOf(success)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* copies a directory, overwrites the target
|
|
* difference with ComputerCraft: it returns boolean, true on successful.
|
|
*/
|
|
class Cp(val computer: BaseTerrarumComputer) : TwoArgFunction() {
|
|
override fun call(from: LuaValue, to: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(from)
|
|
Filesystem.ensurePathSanity(to)
|
|
|
|
return LuaValue.valueOf(
|
|
File(computer.getRealPath(from)).copyRecursively(
|
|
File(computer.getRealPath(to)), overwrite = true
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* difference with ComputerCraft: it returns boolean, true on successful.
|
|
*/
|
|
class Rm(val computer: BaseTerrarumComputer) : OneArgFunction() {
|
|
override fun call(path: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
return LuaValue.valueOf(
|
|
File(computer.getRealPath(path)).deleteRecursively()
|
|
)
|
|
}
|
|
}
|
|
|
|
class ConcatPath(val computer: BaseTerrarumComputer) : TwoArgFunction() {
|
|
override fun call(base: LuaValue, local: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(base)
|
|
Filesystem.ensurePathSanity(local)
|
|
|
|
val combinedPath = combinePath(base.checkIBM437(), local.checkIBM437())
|
|
return LuaValue.valueOf(combinedPath)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param mode: r, rb, w, wb, a, ab
|
|
*
|
|
* Difference: TEXT MODE assumes CP437 instead of UTF-8!
|
|
*
|
|
* When you have opened a file you must always close the file handle, or else data may not be saved.
|
|
*
|
|
* FILE class in CC:
|
|
* (when you look thru them using file = fs.open("./test", "w")
|
|
*
|
|
* file = {
|
|
* close = function()
|
|
* -- write mode
|
|
* write = function(string)
|
|
* flush = function() -- write, keep the handle
|
|
* writeLine = function(string) -- text mode
|
|
* -- read mode
|
|
* readLine = function() -- text mode
|
|
* readAll = function()
|
|
* -- binary read mode
|
|
* read = function() -- read single byte. return: number or nil
|
|
* -- binary write mode
|
|
* write = function(byte)
|
|
* writeBytes = function(string as bytearray)
|
|
* }
|
|
*/
|
|
class OpenFile(val computer: BaseTerrarumComputer) : TwoArgFunction() {
|
|
override fun call(path: LuaValue, mode: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
|
|
|
|
val mode = mode.checkIBM437().toLowerCase()
|
|
val luaClass = LuaTable()
|
|
val file = File(computer.getRealPath(path))
|
|
|
|
if (mode.contains("[aw]") && !file.canWrite())
|
|
throw LuaError("Cannot open file for " +
|
|
"${if (mode.startsWith('w')) "read" else "append"} mode" +
|
|
": is readonly.")
|
|
|
|
|
|
|
|
|
|
when (mode) {
|
|
"r" -> {
|
|
try {
|
|
val fr = FileReader(file)
|
|
luaClass["close"] = FileClassClose(fr)
|
|
luaClass["readLine"] = FileClassReadLine(fr)
|
|
luaClass["readAll"] = FileClassReadAll(file.toPath())
|
|
}
|
|
catch (e: FileNotFoundException) {
|
|
e.printStackTrace()
|
|
throw LuaError("$path: no such file.")
|
|
}
|
|
}
|
|
"rb" -> {
|
|
try {
|
|
val fis = FileInputStream(file)
|
|
luaClass["close"] = FileClassClose(fis)
|
|
luaClass["read"] = FileClassReadByte(fis)
|
|
luaClass["readAll"] = FileClassReadAll(file.toPath())
|
|
}
|
|
catch (e: FileNotFoundException) {
|
|
e.printStackTrace()
|
|
throw LuaError("$path: no such file.")
|
|
}
|
|
}
|
|
"w", "a" -> {
|
|
try {
|
|
val fw = FileWriter(file, (mode.startsWith('a')))
|
|
luaClass["close"] = FileClassClose(fw)
|
|
luaClass["write"] = FileClassPrintText(fw)
|
|
luaClass["writeLine"] = FileClassPrintlnText(fw)
|
|
luaClass["flush"] = FileClassFlush(fw)
|
|
}
|
|
catch (e: FileNotFoundException) {
|
|
e.printStackTrace()
|
|
throw LuaError("$path: is a directory.")
|
|
}
|
|
}
|
|
"wb", "ab" -> {
|
|
try {
|
|
val fos = FileOutputStream(file, (mode.startsWith('a')))
|
|
luaClass["close"] = FileClassClose(fos)
|
|
luaClass["write"] = FileClassWriteByte(fos)
|
|
luaClass["writeBytes"] = FileClassWriteBytes(fos)
|
|
luaClass["flush"] = FileClassFlush(fos)
|
|
}
|
|
catch (e: FileNotFoundException) {
|
|
e.printStackTrace()
|
|
throw LuaError("$path: is a directory.")
|
|
}
|
|
}
|
|
}
|
|
|
|
return luaClass
|
|
}
|
|
}
|
|
|
|
class GetParentDir(val computer: BaseTerrarumComputer) : OneArgFunction() {
|
|
override fun call(path: LuaValue) : LuaValue {
|
|
Filesystem.ensurePathSanity(path)
|
|
|
|
var pathSB = StringBuilder(path.checkIBM437())
|
|
|
|
// backward travel, drop chars until '/' has encountered
|
|
while (!pathSB.endsWith('/') && !pathSB.endsWith('\\'))
|
|
pathSB.deleteCharAt(pathSB.lastIndex - 1)
|
|
|
|
// drop trailing '/'
|
|
if (pathSB.endsWith('/') || pathSB.endsWith('\\'))
|
|
pathSB.deleteCharAt(pathSB.lastIndex - 1)
|
|
|
|
return LuaValue.valueOf(pathSB.toString())
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////
|
|
// OpenFile implementations //
|
|
//////////////////////////////
|
|
|
|
private class FileClassClose(val fo: Any) : ZeroArgFunction() {
|
|
override fun call() : LuaValue {
|
|
if (fo is FileOutputStream)
|
|
fo.close()
|
|
else if (fo is FileWriter)
|
|
fo.close()
|
|
else if (fo is FileReader)
|
|
fo.close()
|
|
else if (fo is FileInputStream)
|
|
fo.close()
|
|
else
|
|
throw IllegalArgumentException("Unacceptable file output: must be either Input/OutputStream or Reader/Writer.")
|
|
|
|
return LuaValue.NONE
|
|
}
|
|
}
|
|
|
|
private class FileClassWriteByte(val fos: FileOutputStream) : OneArgFunction() {
|
|
override fun call(byte: LuaValue) : LuaValue {
|
|
fos.write(byte.checkint())
|
|
|
|
return LuaValue.NONE
|
|
}
|
|
}
|
|
|
|
private class FileClassWriteBytes(val fos: FileOutputStream) : OneArgFunction() {
|
|
override fun call(byteString: LuaValue) : LuaValue {
|
|
val byteString = byteString.checkIBM437()
|
|
val bytearr = ByteArray(byteString.length, { byteString[it].toByte() })
|
|
fos.write(bytearr)
|
|
|
|
return LuaValue.NONE
|
|
}
|
|
}
|
|
|
|
private class FileClassPrintText(val fw: FileWriter) : OneArgFunction() {
|
|
override fun call(string: LuaValue) : LuaValue {
|
|
val text = string.checkIBM437()
|
|
fw.write(text)
|
|
return LuaValue.NONE
|
|
}
|
|
}
|
|
|
|
private class FileClassPrintlnText(val fw: FileWriter) : OneArgFunction() {
|
|
override fun call(string: LuaValue) : LuaValue {
|
|
val text = string.checkIBM437() + "\n"
|
|
fw.write(text)
|
|
return LuaValue.NONE
|
|
}
|
|
}
|
|
|
|
private class FileClassFlush(val fo: Any) : ZeroArgFunction() {
|
|
override fun call() : LuaValue {
|
|
if (fo is FileOutputStream)
|
|
fo.flush()
|
|
else if (fo is FileWriter)
|
|
fo.flush()
|
|
else
|
|
throw IllegalArgumentException("Unacceptable file output: must be either OutputStream or Writer.")
|
|
|
|
return LuaValue.NONE
|
|
}
|
|
}
|
|
|
|
private class FileClassReadByte(val fis: FileInputStream) : ZeroArgFunction() {
|
|
override fun call() : LuaValue {
|
|
val readByte = fis.read()
|
|
return if (readByte == -1) LuaValue.NIL else LuaValue.valueOf(readByte)
|
|
}
|
|
}
|
|
|
|
private class FileClassReadAllBytes(val path: Path) : ZeroArgFunction() {
|
|
override fun call() : LuaValue {
|
|
val byteArr = Files.readAllBytes(path)
|
|
val s: String = java.lang.String(byteArr, "IBM437").toString()
|
|
return LuaValue.valueOf(s)
|
|
}
|
|
}
|
|
|
|
private class FileClassReadAll(val path: Path) : ZeroArgFunction() {
|
|
override fun call() : LuaValue {
|
|
return FileClassReadAllBytes(path).call()
|
|
}
|
|
}
|
|
|
|
/** returns NO line separator! */
|
|
private class FileClassReadLine(val fr: FileReader) : ZeroArgFunction() {
|
|
val scanner = Scanner(fr.readText()) // no closing; keep the scanner status persistent
|
|
|
|
override fun call() : LuaValue {
|
|
return if (scanner.hasNextLine()) LuaValue.valueOf(scanner.nextLine())
|
|
else LuaValue.NIL
|
|
}
|
|
}
|
|
} |