From 495a18805c72ef65a7dc3ce5d423a7c2b46f8807 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Fri, 29 Oct 2021 16:20:53 +0200 Subject: [PATCH] move asmgen test to codeGeneration module --- .../compiler/target/cpu6502/codegen/AsmGen.kt | 10 +++--- .../target/cpu6502/codegen/ForLoopsAsmGen.kt | 2 +- .../test/AsmGenTests.kt | 8 ++--- codeGeneration/test/TestCodeGeneration.kt | 2 +- codeGeneration/test/helpers/Dummies.kt | 27 ++++++++++++++++ .../optimizer/ConstantIdentifierReplacer.kt | 10 +++--- .../src/prog8/optimizer/StatementOptimizer.kt | 2 +- compiler/src/prog8/compiler/Compiler.kt | 5 ++- compiler/test/ModuleImporterTests.kt | 2 ++ compiler/test/TestCompilerOnRanges.kt | 12 +++---- compiler/test/TestMemory.kt | 4 +-- compiler/test/helpers/Dummies.kt | 26 ++++++++++++++++ .../helpers/{DummyFunctions.kt => Dummies.kt} | 7 ++++- compilerAst/test/helpers/DummyMemsizer.kt | 8 ----- .../prog8/compilerinterface/AstExtensions.kt | 31 ++++++------------- compilerInterfaces/test/TestAstExtensions.kt | 15 +-------- examples/test.p8 | 8 ++--- 17 files changed, 101 insertions(+), 78 deletions(-) rename compiler/test/AsmgenTests.kt => codeGeneration/test/AsmGenTests.kt (98%) create mode 100644 codeGeneration/test/helpers/Dummies.kt create mode 100644 compiler/test/helpers/Dummies.kt rename compilerAst/test/helpers/{DummyFunctions.kt => Dummies.kt} (77%) delete mode 100644 compilerAst/test/helpers/DummyMemsizer.kt diff --git a/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt b/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt index 68f937624..d88b2ba51 100644 --- a/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt +++ b/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt @@ -545,16 +545,16 @@ class AsmGen(private val program: Program, return scopedName } - fun asmSymbolName(regs: RegisterOrPair): String = + internal fun asmSymbolName(regs: RegisterOrPair): String = if (regs in Cx16VirtualRegisters) "cx16." + regs.toString().lowercase() else throw AssemblyError("no symbol name for register $regs") - fun asmSymbolName(name: String) = fixNameSymbols(name) - fun asmVariableName(name: String) = fixNameSymbols(name) - fun asmSymbolName(name: Iterable) = fixNameSymbols(name.joinToString(".")) - fun asmVariableName(name: Iterable) = fixNameSymbols(name.joinToString(".")) + internal fun asmSymbolName(name: String) = fixNameSymbols(name) + internal fun asmVariableName(name: String) = fixNameSymbols(name) + internal fun asmSymbolName(name: Iterable) = fixNameSymbols(name.joinToString(".")) + internal fun asmVariableName(name: Iterable) = fixNameSymbols(name.joinToString(".")) internal fun loadByteFromPointerIntoA(pointervar: IdentifierReference): String { diff --git a/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/ForLoopsAsmGen.kt b/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/ForLoopsAsmGen.kt index f4e5586ce..e3b1f150a 100644 --- a/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/ForLoopsAsmGen.kt +++ b/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/ForLoopsAsmGen.kt @@ -20,7 +20,7 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen: throw AssemblyError("unknown dt") when(stmt.iterable) { is RangeExpr -> { - val range = (stmt.iterable as RangeExpr).toConstantIntegerRange(asmgen.options.compTarget) + val range = (stmt.iterable as RangeExpr).toConstantIntegerRange() if(range==null) { translateForOverNonconstRange(stmt, iterableDt.getOr(DataType.UNDEFINED), stmt.iterable as RangeExpr) } else { diff --git a/compiler/test/AsmgenTests.kt b/codeGeneration/test/AsmGenTests.kt similarity index 98% rename from compiler/test/AsmgenTests.kt rename to codeGeneration/test/AsmGenTests.kt index 7f253bfee..70efdb93b 100644 --- a/compiler/test/AsmgenTests.kt +++ b/codeGeneration/test/AsmGenTests.kt @@ -1,4 +1,4 @@ -package prog8tests +package prog8tests.asmgen import org.hamcrest.MatcherAssert.assertThat import org.hamcrest.Matchers.equalTo @@ -19,12 +19,10 @@ import prog8.compiler.target.c64.C64MachineDefinition import prog8.compiler.target.cpu6502.codegen.AsmGen import prog8.compilerinterface.* import prog8.parser.SourceCode -import prog8tests.ast.helpers.DummyFunctions -import prog8tests.ast.helpers.DummyMemsizer +import prog8tests.asmgen.helpers.DummyFunctions +import prog8tests.asmgen.helpers.DummyMemsizer import java.nio.file.Path -// TODO move to codegen project, readjust symbol protection levels - @TestInstance(TestInstance.Lifecycle.PER_CLASS) class TestAsmGen6502 { diff --git a/codeGeneration/test/TestCodeGeneration.kt b/codeGeneration/test/TestCodeGeneration.kt index 130f0ab82..dac2f041a 100644 --- a/codeGeneration/test/TestCodeGeneration.kt +++ b/codeGeneration/test/TestCodeGeneration.kt @@ -1,4 +1,4 @@ -package prog8tests +package prog8tests.asmgen import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test diff --git a/codeGeneration/test/helpers/Dummies.kt b/codeGeneration/test/helpers/Dummies.kt new file mode 100644 index 000000000..82b7553d1 --- /dev/null +++ b/codeGeneration/test/helpers/Dummies.kt @@ -0,0 +1,27 @@ +package prog8tests.asmgen.helpers + +import prog8.ast.IBuiltinFunctions +import prog8.ast.base.Position +import prog8.ast.expressions.Expression +import prog8.ast.expressions.InferredTypes +import prog8.ast.expressions.NumericLiteralValue +import prog8.compiler.IMemSizer +import prog8.ast.base.DataType + + +internal val DummyFunctions = object : IBuiltinFunctions { + override val names: Set = emptySet() + override val purefunctionNames: Set = emptySet() + override fun constValue( + name: String, + args: List, + position: Position, + memsizer: IMemSizer + ): NumericLiteralValue? = null + + override fun returnType(name: String, args: MutableList) = InferredTypes.InferredType.unknown() +} + +internal val DummyMemsizer = object : IMemSizer { + override fun memorySize(dt: DataType): Int = 0 +} diff --git a/codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt b/codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt index 107447170..f64f053be 100644 --- a/codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt +++ b/codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt @@ -141,9 +141,9 @@ internal class ConstantIdentifierReplacer(private val program: Program, private if(rangeExpr!=null) { // convert the initializer range expression to an actual array val declArraySize = decl.arraysize?.constIndex() - if(declArraySize!=null && declArraySize!=rangeExpr.size(compTarget)) + if(declArraySize!=null && declArraySize!=rangeExpr.size()) errors.err("range expression size doesn't match declared array size", decl.value?.position!!) - val constRange = rangeExpr.toConstantIntegerRange(compTarget) + val constRange = rangeExpr.toConstantIntegerRange() if(constRange!=null) { val eltType = rangeExpr.inferType(program).getOr(DataType.UBYTE) val newValue = if(eltType in ByteDatatypes) { @@ -195,9 +195,9 @@ internal class ConstantIdentifierReplacer(private val program: Program, private if(rangeExpr!=null) { // convert the initializer range expression to an actual array of floats val declArraySize = decl.arraysize?.constIndex() - if(declArraySize!=null && declArraySize!=rangeExpr.size(compTarget)) - errors.err("range expression size (${rangeExpr.size(compTarget)}) doesn't match declared array size ($declArraySize)", decl.value?.position!!) - val constRange = rangeExpr.toConstantIntegerRange(compTarget) + if(declArraySize!=null && declArraySize!=rangeExpr.size()) + errors.err("range expression size (${rangeExpr.size()}) doesn't match declared array size ($declArraySize)", decl.value?.position!!) + val constRange = rangeExpr.toConstantIntegerRange() if(constRange!=null) { val newValue = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_F), constRange.map { NumericLiteralValue(DataType.FLOAT, it.toDouble(), decl.value!!.position) }.toTypedArray(), diff --git a/codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt b/codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt index 6f7d89402..bb53fd5b0 100644 --- a/codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt +++ b/codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt @@ -198,7 +198,7 @@ class StatementOptimizer(private val program: Program, val range = forLoop.iterable as? RangeExpr if(range!=null) { - if (range.size(compTarget) == 1) { + if (range.size() == 1) { // for loop over a (constant) range of just a single value-- optimize the loop away // loopvar/reg = range value , follow by block val scope = AnonymousScope(mutableListOf(), forLoop.position) diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt index 9bc5fe28d..86b611d43 100644 --- a/compiler/src/prog8/compiler/Compiler.kt +++ b/compiler/src/prog8/compiler/Compiler.kt @@ -63,8 +63,7 @@ fun compileProgram(filepath: Path, programAst, errors, BuiltinFunctionsFacade(BuiltinFunctions), - compTarget, - compilationOptions + compTarget ) postprocessAst(programAst, errors, compilationOptions) @@ -266,7 +265,7 @@ private fun processAst(programAst: Program, errors: IErrorReporter, compilerOpti errors.report() } -private fun optimizeAst(programAst: Program, errors: IErrorReporter, functions: IBuiltinFunctions, compTarget: ICompilationTarget, options: CompilationOptions) { +private fun optimizeAst(programAst: Program, errors: IErrorReporter, functions: IBuiltinFunctions, compTarget: ICompilationTarget) { // optimize the parse tree println("Optimizing...") diff --git a/compiler/test/ModuleImporterTests.kt b/compiler/test/ModuleImporterTests.kt index 784073e49..fb7714c19 100644 --- a/compiler/test/ModuleImporterTests.kt +++ b/compiler/test/ModuleImporterTests.kt @@ -15,6 +15,8 @@ import prog8.parser.ParseError import prog8.parser.SourceCode import prog8tests.ast.helpers.* import prog8tests.helpers.ErrorReporterForTests +import prog8tests.helpers.DummyFunctions +import prog8tests.helpers.DummyMemsizer import kotlin.io.path.* import kotlin.test.assertContains import kotlin.test.assertFailsWith diff --git a/compiler/test/TestCompilerOnRanges.kt b/compiler/test/TestCompilerOnRanges.kt index 8374f1e96..73ce6f9a7 100644 --- a/compiler/test/TestCompilerOnRanges.kt +++ b/compiler/test/TestCompilerOnRanges.kt @@ -164,10 +164,10 @@ class TestCompilerOnRanges { val expectedEnd = platform.encodeString("f", false)[0].toInt() val expectedStr = "$expectedStart .. $expectedEnd" - val intProgression = rangeExpr.toConstantIntegerRange(platform) + val intProgression = rangeExpr.toConstantIntegerRange() val actualStr = "${intProgression?.first} .. ${intProgression?.last}" assertEquals(expectedStr, actualStr,".first .. .last") - assertEquals(expectedEnd - expectedStart + 1, rangeExpr.size(platform), "rangeExpr.size()") + assertEquals(expectedEnd - expectedStart + 1, rangeExpr.size(), "rangeExpr.size()") } @Test @@ -191,8 +191,8 @@ class TestCompilerOnRanges { .map { it.iterable } .filterIsInstance()[0] - assertEquals(2, rangeExpr.size(platform)) - val intProgression = rangeExpr.toConstantIntegerRange(platform) + assertEquals(2, rangeExpr.size()) + val intProgression = rangeExpr.toConstantIntegerRange() assertEquals(0, intProgression?.first) assertEquals(1, intProgression?.last) } @@ -218,8 +218,8 @@ class TestCompilerOnRanges { .map { it.iterable } .filterIsInstance()[0] - assertEquals(9, rangeExpr.size(platform)) - val intProgression = rangeExpr.toConstantIntegerRange(platform) + assertEquals(9, rangeExpr.size()) + val intProgression = rangeExpr.toConstantIntegerRange() assertEquals(1, intProgression?.first) assertEquals(9, intProgression?.last) } diff --git a/compiler/test/TestMemory.kt b/compiler/test/TestMemory.kt index 96912fabe..c75d8c4b9 100644 --- a/compiler/test/TestMemory.kt +++ b/compiler/test/TestMemory.kt @@ -15,8 +15,8 @@ import prog8.ast.statements.* import prog8.compiler.target.C64Target import prog8.compilerinterface.isInRegularRAMof import prog8.parser.SourceCode -import prog8tests.ast.helpers.DummyFunctions -import prog8tests.ast.helpers.DummyMemsizer +import prog8tests.helpers.DummyFunctions +import prog8tests.helpers.DummyMemsizer import kotlin.test.assertFalse import kotlin.test.assertTrue diff --git a/compiler/test/helpers/Dummies.kt b/compiler/test/helpers/Dummies.kt new file mode 100644 index 000000000..47b3411fa --- /dev/null +++ b/compiler/test/helpers/Dummies.kt @@ -0,0 +1,26 @@ +package prog8tests.helpers + +import prog8.ast.IBuiltinFunctions +import prog8.ast.base.DataType +import prog8.ast.base.Position +import prog8.ast.expressions.Expression +import prog8.ast.expressions.InferredTypes +import prog8.ast.expressions.NumericLiteralValue +import prog8.compiler.IMemSizer + +internal val DummyFunctions = object : IBuiltinFunctions { + override val names: Set = emptySet() + override val purefunctionNames: Set = emptySet() + override fun constValue( + name: String, + args: List, + position: Position, + memsizer: IMemSizer + ): NumericLiteralValue? = null + + override fun returnType(name: String, args: MutableList) = InferredTypes.InferredType.unknown() +} + +internal val DummyMemsizer = object : IMemSizer { + override fun memorySize(dt: DataType): Int = 0 +} diff --git a/compilerAst/test/helpers/DummyFunctions.kt b/compilerAst/test/helpers/Dummies.kt similarity index 77% rename from compilerAst/test/helpers/DummyFunctions.kt rename to compilerAst/test/helpers/Dummies.kt index a4396bfbe..42b76552a 100644 --- a/compilerAst/test/helpers/DummyFunctions.kt +++ b/compilerAst/test/helpers/Dummies.kt @@ -1,13 +1,14 @@ package prog8tests.ast.helpers import prog8.ast.IBuiltinFunctions +import prog8.ast.base.DataType import prog8.ast.base.Position import prog8.ast.expressions.Expression import prog8.ast.expressions.InferredTypes import prog8.ast.expressions.NumericLiteralValue import prog8.compiler.IMemSizer -val DummyFunctions = object : IBuiltinFunctions { +internal val DummyFunctions = object : IBuiltinFunctions { override val names: Set = emptySet() override val purefunctionNames: Set = emptySet() override fun constValue( @@ -19,3 +20,7 @@ val DummyFunctions = object : IBuiltinFunctions { override fun returnType(name: String, args: MutableList) = InferredTypes.InferredType.unknown() } + +internal val DummyMemsizer = object : IMemSizer { + override fun memorySize(dt: DataType): Int = 0 +} diff --git a/compilerAst/test/helpers/DummyMemsizer.kt b/compilerAst/test/helpers/DummyMemsizer.kt deleted file mode 100644 index 4735d948f..000000000 --- a/compilerAst/test/helpers/DummyMemsizer.kt +++ /dev/null @@ -1,8 +0,0 @@ -package prog8tests.ast.helpers - -import prog8.ast.base.DataType -import prog8.compiler.IMemSizer - -val DummyMemsizer = object : IMemSizer { - override fun memorySize(dt: DataType): Int = 0 -} diff --git a/compilerInterfaces/src/prog8/compilerinterface/AstExtensions.kt b/compilerInterfaces/src/prog8/compilerinterface/AstExtensions.kt index 61c5c5e1e..89f29daa7 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/AstExtensions.kt +++ b/compilerInterfaces/src/prog8/compilerinterface/AstExtensions.kt @@ -4,7 +4,6 @@ import prog8.ast.base.VarDeclType import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.NumericLiteralValue import prog8.ast.expressions.RangeExpr -import prog8.ast.expressions.StringLiteralValue import prog8.ast.statements.AssignTarget import kotlin.math.abs @@ -52,7 +51,7 @@ fun AssignTarget.isInRegularRAMof(machine: IMachineDefinition): Boolean { } } -fun RangeExpr.toConstantIntegerRange(encoding: IStringEncoding): IntProgression? { +fun RangeExpr.toConstantIntegerRange(): IntProgression? { fun makeRange(fromVal: Int, toVal: Int, stepVal: Int): IntProgression { return when { @@ -69,32 +68,20 @@ fun RangeExpr.toConstantIntegerRange(encoding: IStringEncoding): IntProgression? } } - val fromVal: Int - val toVal: Int - val fromString = from as? StringLiteralValue - val toString = to as? StringLiteralValue - if(fromString!=null && toString!=null ) { - // TODO WHAT IS A STRING RANGE?????? - // string range -> int range over character values - fromVal = encoding.encodeString(fromString.value, fromString.altEncoding)[0].toInt() - toVal = encoding.encodeString(toString.value, fromString.altEncoding)[0].toInt() - } else { - val fromLv = from as? NumericLiteralValue - val toLv = to as? NumericLiteralValue - if(fromLv==null || toLv==null) - return null // non-constant range - // integer range - fromVal = fromLv.number.toInt() - toVal = toLv.number.toInt() - } + val fromLv = from as? NumericLiteralValue + val toLv = to as? NumericLiteralValue + if(fromLv==null || toLv==null) + return null + val fromVal = fromLv.number.toInt() + val toVal = toLv.number.toInt() val stepVal = (step as? NumericLiteralValue)?.number?.toInt() ?: 1 return makeRange(fromVal, toVal, stepVal) } -fun RangeExpr.size(encoding: IStringEncoding): Int? { +fun RangeExpr.size(): Int? { val fromLv = (from as? NumericLiteralValue) val toLv = (to as? NumericLiteralValue) if(fromLv==null || toLv==null) return null - return toConstantIntegerRange(encoding)?.count() + return toConstantIntegerRange()?.count() } diff --git a/compilerInterfaces/test/TestAstExtensions.kt b/compilerInterfaces/test/TestAstExtensions.kt index 87538d7c0..54a042f4b 100644 --- a/compilerInterfaces/test/TestAstExtensions.kt +++ b/compilerInterfaces/test/TestAstExtensions.kt @@ -5,7 +5,6 @@ import org.junit.jupiter.api.TestInstance import prog8.ast.base.Position import prog8.ast.expressions.NumericLiteralValue import prog8.ast.expressions.RangeExpr -import prog8.compilerinterface.IStringEncoding import prog8.compilerinterface.size import kotlin.test.assertEquals @@ -20,18 +19,6 @@ class TestAstExtensions { NumericLiteralValue.optimalInteger(20, Position.DUMMY), NumericLiteralValue.optimalInteger(2, Position.DUMMY), Position.DUMMY) - val encoding = DummyStringEncoding() - assertEquals(6, expr.size(encoding)) - } - - class DummyStringEncoding : IStringEncoding { - override fun encodeString(str: String, altEncoding: Boolean): List { - TODO("Not yet implemented") - } - - override fun decodeString(bytes: List, altEncoding: Boolean): String { - TODO("Not yet implemented") - } - + assertEquals(6, expr.size()) } } diff --git a/examples/test.p8 b/examples/test.p8 index 4c5a23162..bf9716cb7 100644 --- a/examples/test.p8 +++ b/examples/test.p8 @@ -1,9 +1,9 @@ main { sub start() { - fubar(1,2,3,4) - } - - sub fubar(ubyte aa, ubyte bb, ubyte cc, ubyte dd) { + ubyte xx + for xx in "abcdef" to "zzz" { + xx++ + } } }