Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2024-06-16 13:29:31 +00:00
Code Issues Projects Releases Wiki Activity

move asmgen test to codeGeneration module

Browse Source
This commit is contained in:
Irmen de Jong 2021-10-29 16:20:53 +02:00
parent a226b82d0b
commit 495a18805c
17 changed files with 101 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt
View File

@ -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<String>) = fixNameSymbols(name.joinToString("."))
fun asmVariableName(name: Iterable<String>) = fixNameSymbols(name.joinToString("."))
internal fun asmSymbolName(name: String) = fixNameSymbols(name)
internal fun asmVariableName(name: String) = fixNameSymbols(name)
internal fun asmSymbolName(name: Iterable<String>) = fixNameSymbols(name.joinToString("."))
internal fun asmVariableName(name: Iterable<String>) = fixNameSymbols(name.joinToString("."))
internal fun loadByteFromPointerIntoA(pointervar: IdentifierReference): String {

2
codeGeneration/src/prog8/compiler/target/cpu6502/codegen/ForLoopsAsmGen.kt
View File

@ -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 {

8
compiler/test/AsmgenTests.kt → codeGeneration/test/AsmGenTests.kt
View File

@ -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 {

2
codeGeneration/test/TestCodeGeneration.kt
View File

@ -1,4 +1,4 @@
package prog8tests
package prog8tests.asmgen
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Test

27
codeGeneration/test/helpers/Dummies.kt Normal file
View File

@ -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<String> = emptySet()
override val purefunctionNames: Set<String> = emptySet()
override fun constValue(
name: String,
args: List<Expression>,
position: Position,
memsizer: IMemSizer
): NumericLiteralValue? = null
override fun returnType(name: String, args: MutableList<Expression>) = InferredTypes.InferredType.unknown()
}
internal val DummyMemsizer = object : IMemSizer {
override fun memorySize(dt: DataType): Int = 0
}

10
codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt
View File

@ -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(),

2
codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt
View File

@ -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)

5
compiler/src/prog8/compiler/Compiler.kt
View File

@ -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...")

2
compiler/test/ModuleImporterTests.kt
View File

@ -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

12
compiler/test/TestCompilerOnRanges.kt
View File

@ -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<RangeExpr>()[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<RangeExpr>()[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)
}

4
compiler/test/TestMemory.kt
View File

@ -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

26
compiler/test/helpers/Dummies.kt Normal file
View File

@ -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<String> = emptySet()
override val purefunctionNames: Set<String> = emptySet()
override fun constValue(
name: String,
args: List<Expression>,
position: Position,
memsizer: IMemSizer
): NumericLiteralValue? = null
override fun returnType(name: String, args: MutableList<Expression>) = InferredTypes.InferredType.unknown()
}
internal val DummyMemsizer = object : IMemSizer {
override fun memorySize(dt: DataType): Int = 0
}

7
compilerAst/test/helpers/DummyFunctions.kt → compilerAst/test/helpers/Dummies.kt
View File

@ -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<String> = emptySet()
override val purefunctionNames: Set<String> = emptySet()
override fun constValue(
@ -19,3 +20,7 @@ val DummyFunctions = object : IBuiltinFunctions {
override fun returnType(name: String, args: MutableList<Expression>) = InferredTypes.InferredType.unknown()
}
internal val DummyMemsizer = object : IMemSizer {
override fun memorySize(dt: DataType): Int = 0
}

8
compilerAst/test/helpers/DummyMemsizer.kt
View File

@ -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
}

31
compilerInterfaces/src/prog8/compilerinterface/AstExtensions.kt
View File

@ -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()
}

15
compilerInterfaces/test/TestAstExtensions.kt
View File

@ -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<Short> {
TODO("Not yet implemented")
}
override fun decodeString(bytes: List<Short>, altEncoding: Boolean): String {
TODO("Not yet implemented")
}
assertEquals(6, expr.size())
}
}

8
examples/test.p8
View File

@ -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++
}
}
}