diff --git a/codeGeneration/src/prog8/codegen/target/C128Target.kt b/codeGeneration/src/prog8/codegen/target/C128Target.kt index 02c99ac39..608740412 100644 --- a/codeGeneration/src/prog8/codegen/target/C128Target.kt +++ b/codeGeneration/src/prog8/codegen/target/C128Target.kt @@ -1,43 +1,22 @@ package prog8.codegen.target -import com.github.michaelbull.result.fold -import prog8.ast.base.* +import prog8.ast.base.ByteDatatypes +import prog8.ast.base.DataType +import prog8.ast.base.PassByReferenceDatatypes +import prog8.ast.base.WordDatatypes import prog8.ast.expressions.Expression import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine import prog8.codegen.target.c128.C128MachineDefinition -import prog8.codegen.target.cbm.Petscii import prog8.codegen.target.cpu6502.codegen.asmsub6502ArgsEvalOrder import prog8.codegen.target.cpu6502.codegen.asmsub6502ArgsHaveRegisterClobberRisk -import prog8.compilerinterface.Encoding import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IStringEncoding -object C128Target: ICompilationTarget { +object C128Target: ICompilationTarget, IStringEncoding by Encoder { override val name = "c128" override val machine = C128MachineDefinition() - override fun encodeString(str: String, encoding: Encoding): List { // TODO use Result - val coded = when(encoding) { - Encoding.PETSCII -> Petscii.encodePetscii(str, true) - Encoding.SCREENCODES -> Petscii.encodeScreencode(str, true) - else -> throw FatalAstException("unsupported encoding $encoding") - } - return coded.fold( - failure = { throw it }, - success = { it } - ) - } - override fun decodeString(bytes: List, encoding: Encoding): String { // TODO use Result - val decoded = when(encoding) { - Encoding.PETSCII -> Petscii.decodePetscii(bytes, true) - Encoding.SCREENCODES -> Petscii.decodeScreencode(bytes, true) - else -> throw FatalAstException("unsupported encoding $encoding") - } - return decoded.fold( - failure = { throw it }, - success = { it } - ) - } override fun asmsubArgsEvalOrder(sub: Subroutine): List = asmsub6502ArgsEvalOrder(sub) diff --git a/codeGeneration/src/prog8/codegen/target/C64Target.kt b/codeGeneration/src/prog8/codegen/target/C64Target.kt index b6a33f505..b8c8489de 100644 --- a/codeGeneration/src/prog8/codegen/target/C64Target.kt +++ b/codeGeneration/src/prog8/codegen/target/C64Target.kt @@ -1,44 +1,22 @@ package prog8.codegen.target -import com.github.michaelbull.result.fold -import prog8.ast.base.* +import prog8.ast.base.ByteDatatypes +import prog8.ast.base.DataType +import prog8.ast.base.PassByReferenceDatatypes +import prog8.ast.base.WordDatatypes import prog8.ast.expressions.Expression import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine import prog8.codegen.target.c64.C64MachineDefinition -import prog8.codegen.target.cbm.Petscii import prog8.codegen.target.cpu6502.codegen.asmsub6502ArgsEvalOrder import prog8.codegen.target.cpu6502.codegen.asmsub6502ArgsHaveRegisterClobberRisk -import prog8.compilerinterface.Encoding import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IStringEncoding -object C64Target: ICompilationTarget { +object C64Target: ICompilationTarget, IStringEncoding by Encoder { override val name = "c64" override val machine = C64MachineDefinition() - override fun encodeString(str: String, encoding: Encoding): List { // TODO use Result - val coded = when(encoding) { - Encoding.PETSCII -> Petscii.encodePetscii(str, true) - Encoding.SCREENCODES -> Petscii.encodeScreencode(str, true) - else -> throw FatalAstException("unsupported encoding $encoding") - } - return coded.fold( - failure = { throw it }, - success = { it } - ) - } - override fun decodeString(bytes: List, encoding: Encoding): String { // TODO use Result - val decoded = when(encoding) { - Encoding.PETSCII -> Petscii.decodePetscii(bytes, true) - Encoding.SCREENCODES -> Petscii.decodeScreencode(bytes, true) - else -> throw FatalAstException("unsupported encoding $encoding") - } - return decoded.fold( - failure = { throw it }, - success = { it } - ) - } - override fun asmsubArgsEvalOrder(sub: Subroutine): List = asmsub6502ArgsEvalOrder(sub) diff --git a/codeGeneration/src/prog8/codegen/target/Cx16Target.kt b/codeGeneration/src/prog8/codegen/target/Cx16Target.kt index 30df954c4..4b08fc7f9 100644 --- a/codeGeneration/src/prog8/codegen/target/Cx16Target.kt +++ b/codeGeneration/src/prog8/codegen/target/Cx16Target.kt @@ -1,47 +1,22 @@ package prog8.codegen.target -import com.github.michaelbull.result.fold -import prog8.ast.base.* +import prog8.ast.base.ByteDatatypes +import prog8.ast.base.DataType +import prog8.ast.base.PassByReferenceDatatypes +import prog8.ast.base.WordDatatypes import prog8.ast.expressions.Expression import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine -import prog8.codegen.target.cbm.IsoEncoding -import prog8.codegen.target.cbm.Petscii import prog8.codegen.target.cpu6502.codegen.asmsub6502ArgsEvalOrder import prog8.codegen.target.cpu6502.codegen.asmsub6502ArgsHaveRegisterClobberRisk import prog8.codegen.target.cx16.CX16MachineDefinition -import prog8.compilerinterface.Encoding import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IStringEncoding -object Cx16Target: ICompilationTarget { +object Cx16Target: ICompilationTarget, IStringEncoding by Encoder { override val name = "cx16" override val machine = CX16MachineDefinition() - override fun encodeString(str: String, encoding: Encoding): List { // TODO use Result - val coded = when(encoding) { - Encoding.PETSCII -> Petscii.encodePetscii(str, true) - Encoding.SCREENCODES -> Petscii.encodeScreencode(str, true) - Encoding.ISO -> IsoEncoding.encode(str) - else -> throw FatalAstException("unsupported encoding $encoding") - } - return coded.fold( - failure = { throw it }, - success = { it } - ) - } - override fun decodeString(bytes: List, encoding: Encoding): String { // TODO use Result - val decoded = when(encoding) { - Encoding.PETSCII -> Petscii.decodePetscii(bytes, true) - Encoding.SCREENCODES -> Petscii.decodeScreencode(bytes, true) - Encoding.ISO -> IsoEncoding.decode(bytes) - else -> throw FatalAstException("unsupported encoding $encoding") - } - return decoded.fold( - failure = { throw it }, - success = { it } - ) - } - override fun asmsubArgsEvalOrder(sub: Subroutine): List = asmsub6502ArgsEvalOrder(sub) diff --git a/codeGeneration/src/prog8/codegen/target/Encoder.kt b/codeGeneration/src/prog8/codegen/target/Encoder.kt new file mode 100644 index 000000000..d282a37c9 --- /dev/null +++ b/codeGeneration/src/prog8/codegen/target/Encoder.kt @@ -0,0 +1,35 @@ +package prog8.codegen.target + +import com.github.michaelbull.result.fold +import prog8.ast.base.FatalAstException +import prog8.codegen.target.cbm.IsoEncoding +import prog8.codegen.target.cbm.PetsciiEncoding +import prog8.compilerinterface.Encoding +import prog8.compilerinterface.IStringEncoding + +internal object Encoder: IStringEncoding { + override fun encodeString(str: String, encoding: Encoding): List { // TODO use Result + val coded = when(encoding) { + Encoding.PETSCII -> PetsciiEncoding.encodePetscii(str, true) + Encoding.SCREENCODES -> PetsciiEncoding.encodePetscii(str, true) + Encoding.ISO -> IsoEncoding.encode(str) + else -> throw FatalAstException("unsupported encoding $encoding") + } + return coded.fold( + failure = { throw it }, + success = { it } + ) + } + override fun decodeString(bytes: List, encoding: Encoding): String { // TODO use Result + val decoded = when(encoding) { + Encoding.PETSCII -> PetsciiEncoding.decodePetscii(bytes, true) + Encoding.SCREENCODES -> PetsciiEncoding.decodePetscii(bytes, true) + Encoding.ISO -> IsoEncoding.decode(bytes) + else -> throw FatalAstException("unsupported encoding $encoding") + } + return decoded.fold( + failure = { throw it }, + success = { it } + ) + } +} \ No newline at end of file diff --git a/codeGeneration/src/prog8/codegen/target/cbm/Petscii.kt b/codeGeneration/src/prog8/codegen/target/cbm/PetsciiEncoding.kt similarity index 99% rename from codeGeneration/src/prog8/codegen/target/cbm/Petscii.kt rename to codeGeneration/src/prog8/codegen/target/cbm/PetsciiEncoding.kt index 2f6bdfe8c..576efd7d4 100644 --- a/codeGeneration/src/prog8/codegen/target/cbm/Petscii.kt +++ b/codeGeneration/src/prog8/codegen/target/cbm/PetsciiEncoding.kt @@ -6,10 +6,10 @@ import com.github.michaelbull.result.Result import prog8.ast.antlr.escape import java.io.CharConversionException -object Petscii { +object PetsciiEncoding { // decoding: from Petscii/Screencodes (0-255) to unicode - // character tables used from https://github.com/dj51d/cbmcodecs + // character tables used from https://github.com/irmen/cbmcodecs2 private val decodingPetsciiLowercase = charArrayOf( '\u0000', // 0x00 -> \u0000 diff --git a/compiler/test/TestPetscii.kt b/compiler/test/TestPetscii.kt index 73af9c160..155298d1e 100644 --- a/compiler/test/TestPetscii.kt +++ b/compiler/test/TestPetscii.kt @@ -7,86 +7,86 @@ import io.kotest.assertions.withClue import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe import prog8.codegen.target.cbm.IsoEncoding -import prog8.codegen.target.cbm.Petscii +import prog8.codegen.target.cbm.PetsciiEncoding class TestStringEncodings: FunSpec({ context("petscii") { test("testZero") { - Petscii.encodePetscii("\u0000", true) shouldBe Ok(listOf(0u)) - Petscii.encodePetscii("\u0000", false) shouldBe Ok(listOf(0u)) - Petscii.decodePetscii(listOf(0u), true) shouldBe Ok("\u0000") - Petscii.decodePetscii(listOf(0u), false) shouldBe Ok("\u0000") + PetsciiEncoding.encodePetscii("\u0000", true) shouldBe Ok(listOf(0u)) + PetsciiEncoding.encodePetscii("\u0000", false) shouldBe Ok(listOf(0u)) + PetsciiEncoding.decodePetscii(listOf(0u), true) shouldBe Ok("\u0000") + PetsciiEncoding.decodePetscii(listOf(0u), false) shouldBe Ok("\u0000") } test("testLowercase") { - Petscii.encodePetscii("hello WORLD 123 @!£", true) shouldBe + PetsciiEncoding.encodePetscii("hello WORLD 123 @!£", true) shouldBe Ok(listOf(72u, 69u, 76u, 76u, 79u, 32u, 0xd7u, 0xcfu, 0xd2u, 0xccu, 0xc4u, 32u, 49u, 50u, 51u, 32u, 64u, 33u, 0x5cu)) - Petscii.encodePetscii("\uf11a", true) shouldBe Ok(listOf(0x12u)) // reverse vid - Petscii.encodePetscii("✓", true) shouldBe Ok(listOf(0xfau)) + PetsciiEncoding.encodePetscii("\uf11a", true) shouldBe Ok(listOf(0x12u)) // reverse vid + PetsciiEncoding.encodePetscii("✓", true) shouldBe Ok(listOf(0xfau)) withClue("expect lowercase error fallback") { - Petscii.encodePetscii("π", true) shouldBe Ok(listOf(255u)) - Petscii.encodePetscii("♥", true) shouldBe Ok(listOf(0xd3u)) + PetsciiEncoding.encodePetscii("π", true) shouldBe Ok(listOf(255u)) + PetsciiEncoding.encodePetscii("♥", true) shouldBe Ok(listOf(0xd3u)) } - Petscii.decodePetscii(listOf(72u, 0xd7u, 0x5cu, 0xfau, 0x12u), true) shouldBe Ok("hW£✓\uF11A") + PetsciiEncoding.decodePetscii(listOf(72u, 0xd7u, 0x5cu, 0xfau, 0x12u), true) shouldBe Ok("hW£✓\uF11A") } test("testUppercase") { - Petscii.encodePetscii("HELLO 123 @!£") shouldBe + PetsciiEncoding.encodePetscii("HELLO 123 @!£") shouldBe Ok(listOf(72u, 69u, 76u, 76u, 79u, 32u, 49u, 50u, 51u, 32u, 64u, 33u, 0x5cu)) - Petscii.encodePetscii("\uf11a") shouldBe Ok(listOf(0x12u)) // reverse vid - Petscii.encodePetscii("♥") shouldBe Ok(listOf(0xd3u)) - Petscii.encodePetscii("π") shouldBe Ok(listOf(0xffu)) + PetsciiEncoding.encodePetscii("\uf11a") shouldBe Ok(listOf(0x12u)) // reverse vid + PetsciiEncoding.encodePetscii("♥") shouldBe Ok(listOf(0xd3u)) + PetsciiEncoding.encodePetscii("π") shouldBe Ok(listOf(0xffu)) withClue("expecting fallback") { - Petscii.encodePetscii("✓") shouldBe Ok(listOf(250u)) + PetsciiEncoding.encodePetscii("✓") shouldBe Ok(listOf(250u)) } - Petscii.decodePetscii(listOf(72u, 0x5cu, 0xd3u, 0xffu)) shouldBe Ok("H£♥π") + PetsciiEncoding.decodePetscii(listOf(72u, 0x5cu, 0xd3u, 0xffu)) shouldBe Ok("H£♥π") } test("testScreencodeLowercase") { - Petscii.encodeScreencode("hello WORLD 123 @!£", true) shouldBe + PetsciiEncoding.encodeScreencode("hello WORLD 123 @!£", true) shouldBe Ok(listOf(0x08u, 0x05u, 0x0cu, 0x0cu, 0x0fu, 0x20u, 0x57u, 0x4fu, 0x52u, 0x4cu, 0x44u, 0x20u, 0x31u, 0x32u, 0x33u, 0x20u, 0x00u, 0x21u, 0x1cu)) - Petscii.encodeScreencode("✓", true) shouldBe Ok(listOf(0x7au)) + PetsciiEncoding.encodeScreencode("✓", true) shouldBe Ok(listOf(0x7au)) withClue("expect fallback") { - Petscii.encodeScreencode("♥", true) shouldBe Ok(listOf(83u)) - Petscii.encodeScreencode("π", true) shouldBe Ok(listOf(94u)) + PetsciiEncoding.encodeScreencode("♥", true) shouldBe Ok(listOf(83u)) + PetsciiEncoding.encodeScreencode("π", true) shouldBe Ok(listOf(94u)) } - Petscii.decodeScreencode(listOf(0x08u, 0x57u, 0x1cu, 0x7au), true) shouldBe Ok("hW£✓") + PetsciiEncoding.decodeScreencode(listOf(0x08u, 0x57u, 0x1cu, 0x7au), true) shouldBe Ok("hW£✓") } test("testScreencodeUppercase") { - Petscii.encodeScreencode("WORLD 123 @!£") shouldBe + PetsciiEncoding.encodeScreencode("WORLD 123 @!£") shouldBe Ok(listOf(0x17u, 0x0fu, 0x12u, 0x0cu, 0x04u, 0x20u, 0x31u, 0x32u, 0x33u, 0x20u, 0x00u, 0x21u, 0x1cu)) - Petscii.encodeScreencode("♥") shouldBe Ok(listOf(0x53u)) - Petscii.encodeScreencode("π") shouldBe Ok(listOf(0x5eu)) - Petscii.encodeScreencode("HELLO") shouldBe Ok(listOf(8u, 5u, 12u, 12u, 15u)) + PetsciiEncoding.encodeScreencode("♥") shouldBe Ok(listOf(0x53u)) + PetsciiEncoding.encodeScreencode("π") shouldBe Ok(listOf(0x5eu)) + PetsciiEncoding.encodeScreencode("HELLO") shouldBe Ok(listOf(8u, 5u, 12u, 12u, 15u)) withClue("expecting fallback") { - Petscii.encodeScreencode("hello") shouldBe Ok(listOf(8u, 5u, 12u, 12u, 15u)) - Petscii.encodeScreencode("✓") shouldBe Ok(listOf(122u)) + PetsciiEncoding.encodeScreencode("hello") shouldBe Ok(listOf(8u, 5u, 12u, 12u, 15u)) + PetsciiEncoding.encodeScreencode("✓") shouldBe Ok(listOf(122u)) } - Petscii.decodeScreencode(listOf(0x17u, 0x1cu, 0x53u, 0x5eu)) shouldBe Ok("W£♥π") + PetsciiEncoding.decodeScreencode(listOf(0x17u, 0x1cu, 0x53u, 0x5eu)) shouldBe Ok("W£♥π") } test("testErrorCases") { - Petscii.encodePetscii("~", true).expectError { "shouldn't be able to encode tilde" } - Petscii.encodePetscii("~", false).expectError { "shouldn't be able to encode tilde" } - Petscii.encodeScreencode("~", true).expectError { "shouldn't be able to encode tilde" } - Petscii.encodeScreencode("~", false).expectError { "shouldn't be able to encode tilde" } + PetsciiEncoding.encodePetscii("~", true).expectError { "shouldn't be able to encode tilde" } + PetsciiEncoding.encodePetscii("~", false).expectError { "shouldn't be able to encode tilde" } + PetsciiEncoding.encodeScreencode("~", true).expectError { "shouldn't be able to encode tilde" } + PetsciiEncoding.encodeScreencode("~", false).expectError { "shouldn't be able to encode tilde" } } test("testSpecialReplacements") { - fun encodeP(c: Char, lower: Boolean) = Petscii.encodePetscii(c.toString(), lower).getOrElse { throw it }.single() - fun encodeS(c: Char, lower: Boolean) = Petscii.encodeScreencode(c.toString(), lower).getOrElse { throw it }.single() + fun encodeP(c: Char, lower: Boolean) = PetsciiEncoding.encodePetscii(c.toString(), lower).getOrElse { throw it }.single() + fun encodeS(c: Char, lower: Boolean) = PetsciiEncoding.encodeScreencode(c.toString(), lower).getOrElse { throw it }.single() - Petscii.encodePetscii("`", false).expectError { "shouldn't have translation for backtick" } - Petscii.encodePetscii("`", true).expectError { "shouldn't have translation for backtick" } - Petscii.encodePetscii("~", false).expectError { "shouldn't have translation for tilde" } - Petscii.encodePetscii("~", true).expectError { "shouldn't have translation for tilde" } + PetsciiEncoding.encodePetscii("`", false).expectError { "shouldn't have translation for backtick" } + PetsciiEncoding.encodePetscii("`", true).expectError { "shouldn't have translation for backtick" } + PetsciiEncoding.encodePetscii("~", false).expectError { "shouldn't have translation for tilde" } + PetsciiEncoding.encodePetscii("~", true).expectError { "shouldn't have translation for tilde" } encodeP('^', false) shouldBe 94u encodeP('^', true) shouldBe 94u @@ -115,8 +115,8 @@ class TestStringEncodings: FunSpec({ } test("testBoxDrawingCharsEncoding") { - fun encodeP(c: Char, lower: Boolean) = Petscii.encodePetscii(c.toString(), lower).getOrElse { throw it }.single() - fun encodeS(c: Char, lower: Boolean) = Petscii.encodeScreencode(c.toString(), lower).getOrElse { throw it }.single() + fun encodeP(c: Char, lower: Boolean) = PetsciiEncoding.encodePetscii(c.toString(), lower).getOrElse { throw it }.single() + fun encodeS(c: Char, lower: Boolean) = PetsciiEncoding.encodeScreencode(c.toString(), lower).getOrElse { throw it }.single() // pipe char encodeP('|', false) shouldBe 221u @@ -154,24 +154,24 @@ class TestStringEncodings: FunSpec({ test("testBoxDrawingCharsDecoding") { // ─ 0xC0 -> BOX DRAWINGS LIGHT HORIZONTAL - Petscii.decodePetscii(listOf(195u), false).getOrElse { throw it }.single() shouldBe '\uf13b' //"BOX DRAWINGS LIGHT HORIZONTAL ONE EIGHTH UP (CUS)" - Petscii.decodePetscii(listOf(195u), true).getOrElse { throw it }.single() shouldBe 'C' - Petscii.decodePetscii(listOf(192u), false).getOrElse { throw it }.single() shouldBe '─' - Petscii.decodePetscii(listOf(192u), true).getOrElse { throw it }.single() shouldBe '─' - Petscii.decodeScreencode(listOf(67u), false).getOrElse { throw it }.single() shouldBe '\uf13b' //"BOX DRAWINGS LIGHT HORIZONTAL ONE EIGHTH UP (CUS)" - Petscii.decodeScreencode(listOf(67u), true).getOrElse { throw it }.single() shouldBe 'C' - Petscii.decodeScreencode(listOf(64u), false).getOrElse { throw it }.single() shouldBe '─' - Petscii.decodeScreencode(listOf(64u), true).getOrElse { throw it }.single() shouldBe '─' + PetsciiEncoding.decodePetscii(listOf(195u), false).getOrElse { throw it }.single() shouldBe '\uf13b' //"BOX DRAWINGS LIGHT HORIZONTAL ONE EIGHTH UP (CUS)" + PetsciiEncoding.decodePetscii(listOf(195u), true).getOrElse { throw it }.single() shouldBe 'C' + PetsciiEncoding.decodePetscii(listOf(192u), false).getOrElse { throw it }.single() shouldBe '─' + PetsciiEncoding.decodePetscii(listOf(192u), true).getOrElse { throw it }.single() shouldBe '─' + PetsciiEncoding.decodeScreencode(listOf(67u), false).getOrElse { throw it }.single() shouldBe '\uf13b' //"BOX DRAWINGS LIGHT HORIZONTAL ONE EIGHTH UP (CUS)" + PetsciiEncoding.decodeScreencode(listOf(67u), true).getOrElse { throw it }.single() shouldBe 'C' + PetsciiEncoding.decodeScreencode(listOf(64u), false).getOrElse { throw it }.single() shouldBe '─' + PetsciiEncoding.decodeScreencode(listOf(64u), true).getOrElse { throw it }.single() shouldBe '─' // │ 0x62 -> BOX DRAWINGS LIGHT VERTICAL - Petscii.decodePetscii(listOf(125u), false).getOrElse { throw it }.single() shouldBe '│' - Petscii.decodePetscii(listOf(125u), true).getOrElse { throw it }.single() shouldBe '│' - Petscii.decodePetscii(listOf(221u), false).getOrElse { throw it }.single() shouldBe '│' - Petscii.decodePetscii(listOf(221u), true).getOrElse { throw it }.single() shouldBe '│' - Petscii.decodeScreencode(listOf(93u), false).getOrElse { throw it }.single() shouldBe '│' - Petscii.decodeScreencode(listOf(93u), true).getOrElse { throw it }.single() shouldBe '│' - Petscii.decodeScreencode(listOf(66u), false).getOrElse { throw it }.single() shouldBe '\uf13c' // "BOX DRAWINGS LIGHT VERTICAL ONE EIGHTH LEFT (CUS)" - Petscii.decodeScreencode(listOf(66u), true).getOrElse { throw it }.single() shouldBe 'B' + PetsciiEncoding.decodePetscii(listOf(125u), false).getOrElse { throw it }.single() shouldBe '│' + PetsciiEncoding.decodePetscii(listOf(125u), true).getOrElse { throw it }.single() shouldBe '│' + PetsciiEncoding.decodePetscii(listOf(221u), false).getOrElse { throw it }.single() shouldBe '│' + PetsciiEncoding.decodePetscii(listOf(221u), true).getOrElse { throw it }.single() shouldBe '│' + PetsciiEncoding.decodeScreencode(listOf(93u), false).getOrElse { throw it }.single() shouldBe '│' + PetsciiEncoding.decodeScreencode(listOf(93u), true).getOrElse { throw it }.single() shouldBe '│' + PetsciiEncoding.decodeScreencode(listOf(66u), false).getOrElse { throw it }.single() shouldBe '\uf13c' // "BOX DRAWINGS LIGHT VERTICAL ONE EIGHTH LEFT (CUS)" + PetsciiEncoding.decodeScreencode(listOf(66u), true).getOrElse { throw it }.single() shouldBe 'B' } } @@ -182,9 +182,9 @@ class TestStringEncodings: FunSpec({ } test("non-iso doesn't accept iso-characters") { - var result = Petscii.encodePetscii("a_~ë") + var result = PetsciiEncoding.encodePetscii("a_~ë") result.expectError { "should not encode" } - result = Petscii.encodeScreencode("a_~ë") + result = PetsciiEncoding.encodeScreencode("a_~ë") result.expectError { "should not encode" } } } diff --git a/compiler/test/ast/TestProg8Parser.kt b/compiler/test/ast/TestProg8Parser.kt index 56f7ab522..5e55115fb 100644 --- a/compiler/test/ast/TestProg8Parser.kt +++ b/compiler/test/ast/TestProg8Parser.kt @@ -20,7 +20,7 @@ import prog8.ast.base.Position import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.codegen.target.C64Target -import prog8.codegen.target.cbm.Petscii +import prog8.codegen.target.cbm.PetsciiEncoding import prog8.compilerinterface.Encoding import prog8.parser.ParseError import prog8.parser.Prog8Parser.parseModule @@ -923,7 +923,7 @@ class TestProg8Parser: FunSpec( { ff.value shouldBe NumericLiteralValue(DataType.UBYTE, 255.0, Position.DUMMY) val letter = start.statements[6] as Assignment // TODO characters should perhaps not be encoded until code generation, like strings... however this will prevent optimizing expressions with characters - val encodedletter = Petscii.encodePetscii("A", true).getOrElse { fail("petscii error") }.single() + val encodedletter = PetsciiEncoding.encodePetscii("A", true).getOrElse { fail("petscii error") }.single() letter.value shouldBe NumericLiteralValue(DataType.UBYTE, encodedletter.toDouble(), Position.DUMMY) } diff --git a/docs/source/todo.rst b/docs/source/todo.rst index 1a744392b..782262e95 100644 --- a/docs/source/todo.rst +++ b/docs/source/todo.rst @@ -3,7 +3,7 @@ TODO For next compiler release (7.7) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- make 'petscii' not hardcoded default but specified in machinedefinition +... Need help with