diff --git a/.idea/modules.xml b/.idea/modules.xml index 68b9739cd..3cb9277d1 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -2,6 +2,8 @@ + + diff --git a/.idea/vcs.xml b/.idea/vcs.xml index 5ace414d8..94a25f7f4 100644 --- a/.idea/vcs.xml +++ b/.idea/vcs.xml @@ -3,4 +3,4 @@ - + \ No newline at end of file diff --git a/codeAst/codeAst.iml b/codeAst/codeAst.iml new file mode 100644 index 000000000..7bcaf0b62 --- /dev/null +++ b/codeAst/codeAst.iml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/compilerInterfaces/src/prog8/compilerinterface/intermediate/AstBase.kt b/codeAst/src/prog8/code/ast/AstBase.kt similarity index 93% rename from compilerInterfaces/src/prog8/compilerinterface/intermediate/AstBase.kt rename to codeAst/src/prog8/code/ast/AstBase.kt index f19f13cc9..a7d80c765 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/intermediate/AstBase.kt +++ b/codeAst/src/prog8/code/ast/AstBase.kt @@ -1,10 +1,11 @@ -package prog8.compilerinterface.intermediate +package prog8.code.ast -import prog8.compilerinterface.IMemSizer -import prog8.compilerinterface.IStringEncoding -import prog8.compilerinterface.Position +import prog8.code.core.IMemSizer +import prog8.code.core.IStringEncoding +import prog8.code.core.Position -// TODO : once the CodeGen doesn't need the old Ast anymore, get rid of the 'Pt' prefixes. + +// TODO : once the CodeGen doesn't need the old Ast anymore, get rid of the 'Pt' prefixes ? sealed class PtNode(val position: Position, val children: MutableList = mutableListOf()) { diff --git a/compilerInterfaces/src/prog8/compilerinterface/intermediate/AstExpressions.kt b/codeAst/src/prog8/code/ast/AstExpressions.kt similarity index 93% rename from compilerInterfaces/src/prog8/compilerinterface/intermediate/AstExpressions.kt rename to codeAst/src/prog8/code/ast/AstExpressions.kt index f09085154..04dc93d38 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/intermediate/AstExpressions.kt +++ b/codeAst/src/prog8/code/ast/AstExpressions.kt @@ -1,8 +1,8 @@ -package prog8.compilerinterface.intermediate +package prog8.code.ast -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Encoding -import prog8.compilerinterface.Position +import prog8.code.core.DataType +import prog8.code.core.Encoding +import prog8.code.core.Position class PtAddressOf(position: Position) : PtNode(position) { diff --git a/compilerInterfaces/src/prog8/compilerinterface/intermediate/AstStatements.kt b/codeAst/src/prog8/code/ast/AstStatements.kt similarity index 90% rename from compilerInterfaces/src/prog8/compilerinterface/intermediate/AstStatements.kt rename to codeAst/src/prog8/code/ast/AstStatements.kt index 3217ec00c..51f501c70 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/intermediate/AstStatements.kt +++ b/codeAst/src/prog8/code/ast/AstStatements.kt @@ -1,9 +1,6 @@ -package prog8.compilerinterface.intermediate +package prog8.code.ast -import prog8.ast.statements.AssignmentOrigin -import prog8.ast.statements.RegisterOrStatusflag -import prog8.ast.statements.SubroutineParameter -import prog8.compilerinterface.* +import prog8.code.core.* class PtAsmSub( @@ -23,7 +20,7 @@ class PtAsmSub( class PtSub( name: String, - val parameters: List, + val parameters: List, val returntypes: List, val inline: Boolean, position: Position @@ -34,16 +31,21 @@ class PtSub( } -class PtAssignment(val augmentable: Boolean, - val origin: AssignmentOrigin, // TODO is this ever used in the codegen? - position: Position) : PtNode(position) { +class PtSubroutineParameter(val name: String, val type: DataType, position: Position): PtNode(position) { + override fun printProperties() { + print("$type $name") + } +} + + +class PtAssignment(val augmentable: Boolean, position: Position) : PtNode(position) { val target: PtAssignTarget get() = children[0] as PtAssignTarget val value: PtNode get() = children[1] override fun printProperties() { - print("aug=$augmentable origin=$origin") + print("aug=$augmentable") } } diff --git a/codeCore/codeCore.iml b/codeCore/codeCore.iml new file mode 100644 index 000000000..245d3429f --- /dev/null +++ b/codeCore/codeCore.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/codeCore/src/prog8/code/core/Enumerations.kt b/codeCore/src/prog8/code/core/Enumerations.kt new file mode 100644 index 000000000..baff17b9e --- /dev/null +++ b/codeCore/src/prog8/code/core/Enumerations.kt @@ -0,0 +1,153 @@ +package prog8.code.core + +enum class DataType { + UBYTE, // pass by value + BYTE, // pass by value + UWORD, // pass by value + WORD, // pass by value + FLOAT, // pass by value + STR, // pass by reference + ARRAY_UB, // pass by reference + ARRAY_B, // pass by reference + ARRAY_UW, // pass by reference + ARRAY_W, // pass by reference + ARRAY_F, // pass by reference + UNDEFINED; + + /** + * is the type assignable to the given other type (perhaps via a typecast) without loss of precision? + */ + infix fun isAssignableTo(targetType: DataType) = + when(this) { + UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, FLOAT) + BYTE -> targetType.oneOf(BYTE, WORD, FLOAT) + UWORD -> targetType.oneOf(UWORD, FLOAT) + WORD -> targetType.oneOf(WORD, FLOAT) + FLOAT -> targetType == FLOAT + STR -> targetType.oneOf(STR, UWORD) + in ArrayDatatypes -> targetType == this + else -> false + } + + fun oneOf(vararg types: DataType) = this in types + + infix fun largerThan(other: DataType) = + when { + this == other -> false + this in ByteDatatypes -> false + this in WordDatatypes -> other in ByteDatatypes + this== STR && other== UWORD || this== UWORD && other== STR -> false + else -> true + } + + infix fun equalsSize(other: DataType) = + when { + this == other -> true + this in ByteDatatypes -> other in ByteDatatypes + this in WordDatatypes -> other in WordDatatypes + this== STR && other== UWORD || this== UWORD && other== STR -> true + else -> false + } +} + +enum class CpuRegister { + A, + X, + Y; + + fun asRegisterOrPair(): RegisterOrPair = when(this) { + A -> RegisterOrPair.A + X -> RegisterOrPair.X + Y -> RegisterOrPair.Y + } +} + +enum class RegisterOrPair { + A, + X, + Y, + AX, + AY, + XY, + FAC1, + FAC2, + // cx16 virtual registers: + R0, R1, R2, R3, R4, R5, R6, R7, + R8, R9, R10, R11, R12, R13, R14, R15; + + companion object { + val names by lazy { values().map { it.toString()} } + } + + fun asCpuRegister(): CpuRegister = when(this) { + A -> CpuRegister.A + X -> CpuRegister.X + Y -> CpuRegister.Y + else -> throw IllegalArgumentException("no cpu hardware register for $this") + } + +} // only used in parameter and return value specs in asm subroutines + +enum class Statusflag { + Pc, + Pz, // don't use + Pv, + Pn; // don't use + + companion object { + val names by lazy { values().map { it.toString()} } + } +} + +enum class BranchCondition { + CS, + CC, + EQ, + Z, + NE, + NZ, + VS, + VC, + MI, + NEG, + PL, + POS +} + + +val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE) +val WordDatatypes = arrayOf(DataType.UWORD, DataType.WORD) +val IntegerDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD) +val NumericDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT) +val SignedDatatypes = arrayOf(DataType.BYTE, DataType.WORD, DataType.FLOAT) +val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F) +val StringlyDatatypes = arrayOf(DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B, DataType.UWORD) +val IterableDatatypes = arrayOf( + DataType.STR, + DataType.ARRAY_UB, DataType.ARRAY_B, + DataType.ARRAY_UW, DataType.ARRAY_W, + DataType.ARRAY_F +) +val PassByValueDatatypes = NumericDatatypes +val PassByReferenceDatatypes = IterableDatatypes +val ArrayToElementTypes = mapOf( + DataType.STR to DataType.UBYTE, + DataType.ARRAY_B to DataType.BYTE, + DataType.ARRAY_UB to DataType.UBYTE, + DataType.ARRAY_W to DataType.WORD, + DataType.ARRAY_UW to DataType.UWORD, + DataType.ARRAY_F to DataType.FLOAT +) +val ElementToArrayTypes = mapOf( + DataType.BYTE to DataType.ARRAY_B, + DataType.UBYTE to DataType.ARRAY_UB, + DataType.WORD to DataType.ARRAY_W, + DataType.UWORD to DataType.ARRAY_UW, + DataType.FLOAT to DataType.ARRAY_F +) +val Cx16VirtualRegisters = arrayOf( + RegisterOrPair.R0, RegisterOrPair.R1, RegisterOrPair.R2, RegisterOrPair.R3, + RegisterOrPair.R4, RegisterOrPair.R5, RegisterOrPair.R6, RegisterOrPair.R7, + RegisterOrPair.R8, RegisterOrPair.R9, RegisterOrPair.R10, RegisterOrPair.R11, + RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15 +) diff --git a/codeCore/src/prog8/code/core/IMemSizer.kt b/codeCore/src/prog8/code/core/IMemSizer.kt new file mode 100644 index 000000000..714b8e4c8 --- /dev/null +++ b/codeCore/src/prog8/code/core/IMemSizer.kt @@ -0,0 +1,5 @@ +package prog8.code.core + +interface IMemSizer { + fun memorySize(dt: DataType): Int +} diff --git a/compilerAst/src/prog8/compilerinterface/IStringEncoding.kt b/codeCore/src/prog8/code/core/IStringEncoding.kt similarity index 93% rename from compilerAst/src/prog8/compilerinterface/IStringEncoding.kt rename to codeCore/src/prog8/code/core/IStringEncoding.kt index 01ea96c17..95e9d723f 100644 --- a/compilerAst/src/prog8/compilerinterface/IStringEncoding.kt +++ b/codeCore/src/prog8/code/core/IStringEncoding.kt @@ -1,4 +1,4 @@ -package prog8.compilerinterface +package prog8.code.core enum class Encoding(val prefix: String) { DEFAULT("default"), // depends on compilation target diff --git a/codeCore/src/prog8/code/core/Position.kt b/codeCore/src/prog8/code/core/Position.kt new file mode 100644 index 000000000..3efb8f1d7 --- /dev/null +++ b/codeCore/src/prog8/code/core/Position.kt @@ -0,0 +1,16 @@ +package prog8.code.core + +import kotlin.io.path.Path +import kotlin.io.path.absolute + +data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) { + override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]" + fun toClickableStr(): String { + val path = Path(file).absolute().normalize() + return "file://$path:$line:$startCol:" + } + + companion object { + val DUMMY = Position("", 0, 0, 0) + } +} \ No newline at end of file diff --git a/codeCore/src/prog8/code/core/RegisterOrStatusflag.kt b/codeCore/src/prog8/code/core/RegisterOrStatusflag.kt new file mode 100644 index 000000000..a7600aab8 --- /dev/null +++ b/codeCore/src/prog8/code/core/RegisterOrStatusflag.kt @@ -0,0 +1,3 @@ +package prog8.code.core + +data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?) diff --git a/codeCore/src/prog8/code/core/ToHex.kt b/codeCore/src/prog8/code/core/ToHex.kt new file mode 100644 index 000000000..e1f8f1824 --- /dev/null +++ b/codeCore/src/prog8/code/core/ToHex.kt @@ -0,0 +1,31 @@ +package prog8.code.core + +import kotlin.math.abs + +fun Number.toHex(): String { + // 0..15 -> "0".."15" + // 16..255 -> "$10".."$ff" + // 256..65536 -> "$0100".."$ffff" + // negative values are prefixed with '-'. + val integer = this.toInt() + if(integer<0) + return '-' + abs(integer).toHex() + return when (integer) { + in 0 until 16 -> integer.toString() + in 0 until 0x100 -> "$"+integer.toString(16).padStart(2,'0') + in 0 until 0x10000 -> "$"+integer.toString(16).padStart(4,'0') + else -> throw IllegalArgumentException("number too large for 16 bits $this") + } +} + +fun UInt.toHex(): String { + // 0..15 -> "0".."15" + // 16..255 -> "$10".."$ff" + // 256..65536 -> "$0100".."$ffff" + return when (this) { + in 0u until 16u -> this.toString() + in 0u until 0x100u -> "$"+this.toString(16).padStart(2,'0') + in 0u until 0x10000u -> "$"+this.toString(16).padStart(4,'0') + else -> throw IllegalArgumentException("number too large for 16 bits $this") + } +} diff --git a/codeGenCpu6502/codeGenCpu6502.iml b/codeGenCpu6502/codeGenCpu6502.iml index f04990594..bdacb4379 100644 --- a/codeGenCpu6502/codeGenCpu6502.iml +++ b/codeGenCpu6502/codeGenCpu6502.iml @@ -12,5 +12,6 @@ + \ No newline at end of file diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt index 923109edc..8d3e8a9b6 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt @@ -2,9 +2,10 @@ package prog8.codegen.cpu6502 import com.github.michaelbull.result.fold import prog8.ast.* -import prog8.ast.base.* +import prog8.ast.base.FatalAstException import prog8.ast.expressions.* import prog8.ast.statements.* +import prog8.code.core.* import prog8.codegen.cpu6502.assignment.* import prog8.compilerinterface.* import prog8.parser.SourceCode diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmOptimizer.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmOptimizer.kt index 169371aac..db270db4d 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmOptimizer.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmOptimizer.kt @@ -3,8 +3,8 @@ package prog8.codegen.cpu6502 import prog8.ast.Program import prog8.ast.expressions.NumericLiteral import prog8.ast.statements.VarDecl +import prog8.ast.statements.VarDeclType import prog8.compilerinterface.IMachineDefinition -import prog8.compilerinterface.VarDeclType // note: see https://wiki.nesdev.org/w/index.php/6502_assembly_optimisations diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt index 853e47b1f..ada9eced4 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt @@ -3,12 +3,12 @@ package prog8.codegen.cpu6502 import prog8.ast.IFunctionCall import prog8.ast.Node import prog8.ast.Program -import prog8.ast.base.* import prog8.ast.expressions.* import prog8.ast.statements.ArrayIndex import prog8.ast.statements.BuiltinFunctionCallStatement import prog8.ast.statements.DirectMemoryWrite import prog8.ast.statements.Subroutine +import prog8.code.core.* import prog8.codegen.cpu6502.assignment.* import prog8.compilerinterface.* diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/ExpressionsAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/ExpressionsAsmGen.kt index ec63fcb7c..22b2c0436 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/ExpressionsAsmGen.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/ExpressionsAsmGen.kt @@ -1,9 +1,10 @@ package prog8.codegen.cpu6502 import prog8.ast.Program -import prog8.ast.base.* import prog8.ast.expressions.* -import prog8.compilerinterface.* +import prog8.code.core.* +import prog8.compilerinterface.AssemblyError +import prog8.compilerinterface.CpuType import kotlin.math.absoluteValue internal class ExpressionsAsmGen(private val program: Program, diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/ForLoopsAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/ForLoopsAsmGen.kt index 2d1df5781..1cabb85e4 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/ForLoopsAsmGen.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/ForLoopsAsmGen.kt @@ -5,7 +5,12 @@ import prog8.ast.Program import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.RangeExpression import prog8.ast.statements.ForLoop -import prog8.compilerinterface.* +import prog8.code.core.ArrayToElementTypes +import prog8.code.core.DataType +import prog8.code.core.RegisterOrPair +import prog8.code.core.toHex +import prog8.compilerinterface.AssemblyError +import prog8.compilerinterface.Zeropage import kotlin.math.absoluteValue internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen, private val zeropage: Zeropage) { diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/FunctionCallAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/FunctionCallAsmGen.kt index 462a4d92f..52ab2918b 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/FunctionCallAsmGen.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/FunctionCallAsmGen.kt @@ -8,11 +8,12 @@ import prog8.ast.expressions.Expression import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.NumericLiteral import prog8.ast.statements.* +import prog8.code.core.* import prog8.codegen.cpu6502.assignment.AsmAssignSource import prog8.codegen.cpu6502.assignment.AsmAssignTarget import prog8.codegen.cpu6502.assignment.AsmAssignment import prog8.codegen.cpu6502.assignment.TargetStorageKind -import prog8.compilerinterface.* +import prog8.compilerinterface.AssemblyError internal class FunctionCallAsmGen(private val program: Program, private val asmgen: AsmGen) { diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt index 6be6e7faa..3a17adddb 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt @@ -4,7 +4,8 @@ import prog8.ast.Program import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.NumericLiteral import prog8.ast.statements.PostIncrDecr -import prog8.compilerinterface.* +import prog8.code.core.* +import prog8.compilerinterface.AssemblyError internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) { diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/ProgramAndVarsGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/ProgramAndVarsGen.kt index 88b6eec76..c6da10c92 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/ProgramAndVarsGen.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/ProgramAndVarsGen.kt @@ -2,8 +2,8 @@ package prog8.codegen.cpu6502 import prog8.ast.Program import prog8.ast.antlr.escape -import prog8.ast.base.* import prog8.ast.statements.* +import prog8.code.core.* import prog8.codegen.cpu6502.assignment.AsmAssignTarget import prog8.codegen.cpu6502.assignment.TargetStorageKind import prog8.compilerinterface.* diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/VariableAllocator.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/VariableAllocator.kt index c1798a6d0..9f6a6a0fe 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/VariableAllocator.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/VariableAllocator.kt @@ -2,6 +2,9 @@ package prog8.codegen.cpu6502 import com.github.michaelbull.result.fold import com.github.michaelbull.result.onSuccess +import prog8.code.core.ArrayDatatypes +import prog8.code.core.DataType +import prog8.code.core.IntegerDatatypes import prog8.compilerinterface.* diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt index 2fed8d3a3..d4bc53d02 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt @@ -3,8 +3,9 @@ package prog8.codegen.cpu6502.assignment import prog8.ast.Program import prog8.ast.expressions.* import prog8.ast.statements.* +import prog8.code.core.* import prog8.codegen.cpu6502.AsmGen -import prog8.compilerinterface.* +import prog8.compilerinterface.AssemblyError internal enum class TargetStorageKind { diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt index f2a6e426a..08baf3e79 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt @@ -1,12 +1,14 @@ package prog8.codegen.cpu6502.assignment import prog8.ast.Program -import prog8.ast.base.* import prog8.ast.expressions.* import prog8.ast.statements.* +import prog8.code.core.* import prog8.codegen.cpu6502.AsmGen import prog8.codegen.cpu6502.VariableAllocator -import prog8.compilerinterface.* +import prog8.compilerinterface.AssemblyError +import prog8.compilerinterface.CpuType +import prog8.compilerinterface.builtinFunctionReturnType internal class AssignmentAsmGen(private val program: Program, diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt index 544aa3c03..2bdb977f0 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt @@ -1,12 +1,14 @@ package prog8.codegen.cpu6502.assignment import prog8.ast.Program -import prog8.ast.base.* +import prog8.ast.base.FatalAstException import prog8.ast.expressions.* import prog8.ast.statements.Subroutine +import prog8.code.core.* import prog8.codegen.cpu6502.AsmGen import prog8.codegen.cpu6502.VariableAllocator -import prog8.compilerinterface.* +import prog8.compilerinterface.AssemblyError +import prog8.compilerinterface.CpuType internal class AugmentableAssignmentAsmGen(private val program: Program, diff --git a/codeGenExperimental6502/codeGenExperimental6502.iml b/codeGenExperimental6502/codeGenExperimental6502.iml index 6412199dc..a58cec9a6 100644 --- a/codeGenExperimental6502/codeGenExperimental6502.iml +++ b/codeGenExperimental6502/codeGenExperimental6502.iml @@ -11,5 +11,6 @@ + \ No newline at end of file diff --git a/codeGenExperimental6502/src/prog8/codegen/experimental6502/AsmGen.kt b/codeGenExperimental6502/src/prog8/codegen/experimental6502/AsmGen.kt index a9a02e68a..ca4c45c3c 100644 --- a/codeGenExperimental6502/src/prog8/codegen/experimental6502/AsmGen.kt +++ b/codeGenExperimental6502/src/prog8/codegen/experimental6502/AsmGen.kt @@ -1,12 +1,14 @@ package prog8.codegen.experimental6502 +import prog8.code.ast.PtProgram import prog8.compilerinterface.* -import prog8.compilerinterface.intermediate.PtProgram + class AsmGen(internal val program: PtProgram, internal val errors: IErrorReporter, internal val symbolTable: SymbolTable, - internal val options: CompilationOptions): IAssemblyGenerator { + internal val options: CompilationOptions +): IAssemblyGenerator { override fun compileToAssembly(): IAssemblyProgram? { diff --git a/codeGenTargets/codeGenTargets.iml b/codeGenTargets/codeGenTargets.iml index 4fb573763..340fb12a1 100644 --- a/codeGenTargets/codeGenTargets.iml +++ b/codeGenTargets/codeGenTargets.iml @@ -10,7 +10,8 @@ - + + \ No newline at end of file diff --git a/codeGenTargets/src/prog8/codegen/target/AtariTarget.kt b/codeGenTargets/src/prog8/codegen/target/AtariTarget.kt index 27b381fda..f7fed5847 100644 --- a/codeGenTargets/src/prog8/codegen/target/AtariTarget.kt +++ b/codeGenTargets/src/prog8/codegen/target/AtariTarget.kt @@ -1,12 +1,12 @@ package prog8.codegen.target import prog8.ast.expressions.Expression -import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine +import prog8.code.core.* import prog8.codegen.target.atari.AtariMachineDefinition import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk -import prog8.compilerinterface.* +import prog8.compilerinterface.ICompilationTarget class AtariTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer { diff --git a/codeGenTargets/src/prog8/codegen/target/C128Target.kt b/codeGenTargets/src/prog8/codegen/target/C128Target.kt index 6056e031f..2ce7ba32b 100644 --- a/codeGenTargets/src/prog8/codegen/target/C128Target.kt +++ b/codeGenTargets/src/prog8/codegen/target/C128Target.kt @@ -1,16 +1,16 @@ package prog8.codegen.target import prog8.ast.expressions.Expression -import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine +import prog8.code.core.Encoding +import prog8.code.core.IMemSizer +import prog8.code.core.IStringEncoding +import prog8.code.core.RegisterOrStatusflag import prog8.codegen.target.c128.C128MachineDefinition import prog8.codegen.target.cbm.CbmMemorySizer import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk -import prog8.compilerinterface.Encoding import prog8.compilerinterface.ICompilationTarget -import prog8.compilerinterface.IMemSizer -import prog8.compilerinterface.IStringEncoding class C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer { diff --git a/codeGenTargets/src/prog8/codegen/target/C64Target.kt b/codeGenTargets/src/prog8/codegen/target/C64Target.kt index 0c12bd15e..d566c2814 100644 --- a/codeGenTargets/src/prog8/codegen/target/C64Target.kt +++ b/codeGenTargets/src/prog8/codegen/target/C64Target.kt @@ -1,16 +1,16 @@ package prog8.codegen.target import prog8.ast.expressions.Expression -import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine +import prog8.code.core.Encoding +import prog8.code.core.IMemSizer +import prog8.code.core.IStringEncoding +import prog8.code.core.RegisterOrStatusflag import prog8.codegen.target.c64.C64MachineDefinition import prog8.codegen.target.cbm.CbmMemorySizer import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk -import prog8.compilerinterface.Encoding import prog8.compilerinterface.ICompilationTarget -import prog8.compilerinterface.IMemSizer -import prog8.compilerinterface.IStringEncoding class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer { diff --git a/codeGenTargets/src/prog8/codegen/target/Cx16Target.kt b/codeGenTargets/src/prog8/codegen/target/Cx16Target.kt index 287d79463..2ef12d938 100644 --- a/codeGenTargets/src/prog8/codegen/target/Cx16Target.kt +++ b/codeGenTargets/src/prog8/codegen/target/Cx16Target.kt @@ -1,16 +1,16 @@ package prog8.codegen.target import prog8.ast.expressions.Expression -import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine +import prog8.code.core.Encoding +import prog8.code.core.IMemSizer +import prog8.code.core.IStringEncoding +import prog8.code.core.RegisterOrStatusflag import prog8.codegen.target.cbm.CbmMemorySizer import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk import prog8.codegen.target.cx16.CX16MachineDefinition -import prog8.compilerinterface.Encoding import prog8.compilerinterface.ICompilationTarget -import prog8.compilerinterface.IMemSizer -import prog8.compilerinterface.IStringEncoding class Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer { diff --git a/codeGenTargets/src/prog8/codegen/target/Encoder.kt b/codeGenTargets/src/prog8/codegen/target/Encoder.kt index 5f2aac98a..63127696c 100644 --- a/codeGenTargets/src/prog8/codegen/target/Encoder.kt +++ b/codeGenTargets/src/prog8/codegen/target/Encoder.kt @@ -1,13 +1,14 @@ package prog8.codegen.target import com.github.michaelbull.result.fold +import prog8.code.core.Encoding +import prog8.code.core.IStringEncoding import prog8.codegen.target.cbm.AtasciiEncoding import prog8.codegen.target.cbm.IsoEncoding import prog8.codegen.target.cbm.PetsciiEncoding -import prog8.compilerinterface.Encoding -import prog8.compilerinterface.IStringEncoding import prog8.compilerinterface.InternalCompilerException + internal object Encoder: IStringEncoding { override fun encodeString(str: String, encoding: Encoding): List { val coded = when(encoding) { diff --git a/codeGenTargets/src/prog8/codegen/target/cbm/AsmsubHelpers.kt b/codeGenTargets/src/prog8/codegen/target/cbm/AsmsubHelpers.kt index 06b245e5b..7546e5408 100644 --- a/codeGenTargets/src/prog8/codegen/target/cbm/AsmsubHelpers.kt +++ b/codeGenTargets/src/prog8/codegen/target/cbm/AsmsubHelpers.kt @@ -3,10 +3,10 @@ package prog8.codegen.target.cbm import prog8.ast.expressions.ArrayIndexedExpression import prog8.ast.expressions.BuiltinFunctionCall import prog8.ast.expressions.Expression -import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine -import prog8.compilerinterface.Cx16VirtualRegisters -import prog8.compilerinterface.RegisterOrPair +import prog8.code.core.Cx16VirtualRegisters +import prog8.code.core.RegisterOrPair +import prog8.code.core.RegisterOrStatusflag internal fun asmsub6502ArgsEvalOrder(sub: Subroutine): List { diff --git a/codeGenTargets/src/prog8/codegen/target/cbm/CbmMemorySizer.kt b/codeGenTargets/src/prog8/codegen/target/cbm/CbmMemorySizer.kt index 536260b57..d72bc3312 100644 --- a/codeGenTargets/src/prog8/codegen/target/cbm/CbmMemorySizer.kt +++ b/codeGenTargets/src/prog8/codegen/target/cbm/CbmMemorySizer.kt @@ -1,6 +1,7 @@ package prog8.codegen.target.cbm -import prog8.compilerinterface.* +import prog8.code.core.* + internal object CbmMemorySizer: IMemSizer { override fun memorySize(dt: DataType): Int { diff --git a/codeGenTargets/src/prog8/codegen/target/cx16/CX16Zeropage.kt b/codeGenTargets/src/prog8/codegen/target/cx16/CX16Zeropage.kt index 8f56a7b43..108a295e3 100644 --- a/codeGenTargets/src/prog8/codegen/target/cx16/CX16Zeropage.kt +++ b/codeGenTargets/src/prog8/codegen/target/cx16/CX16Zeropage.kt @@ -1,6 +1,11 @@ package prog8.codegen.target.cx16 -import prog8.compilerinterface.* +import prog8.code.core.DataType +import prog8.compilerinterface.CompilationOptions +import prog8.compilerinterface.InternalCompilerException +import prog8.compilerinterface.Zeropage +import prog8.compilerinterface.ZeropageType + class CX16Zeropage(options: CompilationOptions) : Zeropage(options) { diff --git a/codeOptimizers/codeOptimizers.iml b/codeOptimizers/codeOptimizers.iml index a426d893e..8c1f57512 100644 --- a/codeOptimizers/codeOptimizers.iml +++ b/codeOptimizers/codeOptimizers.iml @@ -11,5 +11,6 @@ + \ No newline at end of file diff --git a/codeOptimizers/src/prog8/optimizer/BinExprSplitter.kt b/codeOptimizers/src/prog8/optimizer/BinExprSplitter.kt index a05133e0f..d598a0d69 100644 --- a/codeOptimizers/src/prog8/optimizer/BinExprSplitter.kt +++ b/codeOptimizers/src/prog8/optimizer/BinExprSplitter.kt @@ -13,8 +13,8 @@ import prog8.ast.statements.Assignment import prog8.ast.statements.AssignmentOrigin import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification +import prog8.code.core.DataType import prog8.compilerinterface.CompilationOptions -import prog8.compilerinterface.DataType import prog8.compilerinterface.ICompilationTarget import prog8.compilerinterface.isIOAddress diff --git a/codeOptimizers/src/prog8/optimizer/ConstExprEvaluator.kt b/codeOptimizers/src/prog8/optimizer/ConstExprEvaluator.kt index 8c2da6ecb..3eac0e000 100644 --- a/codeOptimizers/src/prog8/optimizer/ConstExprEvaluator.kt +++ b/codeOptimizers/src/prog8/optimizer/ConstExprEvaluator.kt @@ -1,11 +1,12 @@ package prog8.optimizer -import prog8.ast.base.* +import prog8.ast.base.ExpressionError +import prog8.ast.base.FatalAstException import prog8.ast.expressions.Expression import prog8.ast.expressions.NumericLiteral -import prog8.compilerinterface.DataType -import prog8.compilerinterface.IntegerDatatypes -import prog8.compilerinterface.Position +import prog8.code.core.DataType +import prog8.code.core.IntegerDatatypes +import prog8.code.core.Position import kotlin.math.pow diff --git a/codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt b/codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt index 7e3460a5b..7ad6d1ffb 100644 --- a/codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt +++ b/codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt @@ -2,16 +2,18 @@ package prog8.optimizer import prog8.ast.Node import prog8.ast.Program -import prog8.ast.base.* +import prog8.ast.base.ExpressionError +import prog8.ast.base.FatalAstException +import prog8.ast.base.UndefinedSymbolError import prog8.ast.expressions.* import prog8.ast.statements.Assignment import prog8.ast.statements.ForLoop import prog8.ast.statements.VarDecl +import prog8.ast.statements.VarDeclType import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.DataType -import prog8.compilerinterface.IntegerDatatypes -import prog8.compilerinterface.VarDeclType +import prog8.code.core.DataType +import prog8.code.core.IntegerDatatypes import kotlin.math.pow diff --git a/codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt b/codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt index c6fd06954..830edbde4 100644 --- a/codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt +++ b/codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt @@ -2,12 +2,16 @@ package prog8.optimizer import prog8.ast.Node import prog8.ast.Program -import prog8.ast.base.* +import prog8.ast.base.FatalAstException +import prog8.ast.base.UndefinedSymbolError import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.* +import prog8.code.core.* +import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IErrorReporter +import prog8.compilerinterface.InternalCompilerException // Fix up the literal value's type to match that of the vardecl // (also check range literal operands types before they get expanded into arrays for instance) @@ -23,7 +27,7 @@ class VarConstantValueTypeAdjuster(private val program: Program, private val err if(declConstValue!=null && (decl.type== VarDeclType.VAR || decl.type==VarDeclType.CONST) && declConstValue.type != decl.datatype) { // avoid silent float roundings - if(decl.datatype in IntegerDatatypes && declConstValue.type==DataType.FLOAT) { + if(decl.datatype in IntegerDatatypes && declConstValue.type == DataType.FLOAT) { errors.err("refused rounding of float to avoid loss of precision", decl.value!!.position) } else { // cast the numeric literal to the appropriate datatype of the variable diff --git a/codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt b/codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt index fb0174649..10b2091ed 100644 --- a/codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt +++ b/codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt @@ -6,10 +6,10 @@ import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.DataType +import prog8.code.core.DataType +import prog8.code.core.IntegerDatatypes +import prog8.code.core.NumericDatatypes import prog8.compilerinterface.IErrorReporter -import prog8.compilerinterface.IntegerDatatypes -import prog8.compilerinterface.NumericDatatypes import kotlin.math.abs import kotlin.math.log2 import kotlin.math.pow diff --git a/codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt b/codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt index c3c6d0c1c..72fa66eed 100644 --- a/codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt +++ b/codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt @@ -5,7 +5,11 @@ import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.* +import prog8.code.core.ArrayDatatypes +import prog8.code.core.DataType +import prog8.code.core.IntegerDatatypes +import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IErrorReporter import kotlin.math.floor diff --git a/codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt b/codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt index 5b9e15503..949744655 100644 --- a/codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt +++ b/codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt @@ -5,7 +5,11 @@ import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.* +import prog8.code.core.DataType +import prog8.compilerinterface.CallGraph +import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IErrorReporter +import prog8.compilerinterface.isIOAddress class UnusedCodeRemover(private val program: Program, diff --git a/compiler/compiler.iml b/compiler/compiler.iml index a27258ff2..95c017a24 100644 --- a/compiler/compiler.iml +++ b/compiler/compiler.iml @@ -22,5 +22,8 @@ + + + \ No newline at end of file diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt index 2650b1045..7a4def076 100644 --- a/compiler/src/prog8/compiler/Compiler.kt +++ b/compiler/src/prog8/compiler/Compiler.kt @@ -11,6 +11,7 @@ import prog8.ast.expressions.NumericLiteral import prog8.ast.statements.Directive import prog8.ast.statements.VarDecl import prog8.ast.walk.IAstVisitor +import prog8.code.core.Position import prog8.codegen.target.AtariTarget import prog8.codegen.target.C128Target import prog8.codegen.target.C64Target diff --git a/compiler/src/prog8/compiler/ErrorReporter.kt b/compiler/src/prog8/compiler/ErrorReporter.kt index bbf138ad1..27deb04a9 100644 --- a/compiler/src/prog8/compiler/ErrorReporter.kt +++ b/compiler/src/prog8/compiler/ErrorReporter.kt @@ -1,7 +1,8 @@ package prog8.compiler +import prog8.code.core.Position import prog8.compilerinterface.IErrorReporter -import prog8.compilerinterface.Position + internal class ErrorReporter: IErrorReporter { private enum class MessageSeverity { diff --git a/compiler/src/prog8/compiler/IntermediateAstMaker.kt b/compiler/src/prog8/compiler/IntermediateAstMaker.kt index 59dedfbfc..094989292 100644 --- a/compiler/src/prog8/compiler/IntermediateAstMaker.kt +++ b/compiler/src/prog8/compiler/IntermediateAstMaker.kt @@ -1,12 +1,11 @@ package prog8.compiler -import prog8.ast.Program import prog8.ast.Module +import prog8.ast.Program import prog8.ast.base.FatalAstException -import prog8.ast.statements.* import prog8.ast.expressions.* -import prog8.compilerinterface.VarDeclType -import prog8.compilerinterface.intermediate.* +import prog8.ast.statements.* +import prog8.code.ast.* class IntermediateAstMaker(val srcProgram: Program) { @@ -94,7 +93,7 @@ class IntermediateAstMaker(val srcProgram: Program) { } private fun transform(srcAssign: Assignment): PtAssignment { - val assign = PtAssignment(srcAssign.isAugmentable, srcAssign.origin, srcAssign.position) + val assign = PtAssignment(srcAssign.isAugmentable, srcAssign.position) assign.add(transform(srcAssign.target)) assign.add(transformExpression(srcAssign.value)) return assign @@ -284,7 +283,7 @@ class IntermediateAstMaker(val srcProgram: Program) { private fun transformSub(srcSub: Subroutine): PtSub { val sub = PtSub(srcSub.name, - srcSub.parameters, + srcSub.parameters.map { PtSubroutineParameter(it.name, it.type, it.position) }, srcSub.returntypes, srcSub.inline, srcSub.position) diff --git a/compiler/src/prog8/compiler/ModuleImporter.kt b/compiler/src/prog8/compiler/ModuleImporter.kt index 81bbf90a8..db4e7ea86 100644 --- a/compiler/src/prog8/compiler/ModuleImporter.kt +++ b/compiler/src/prog8/compiler/ModuleImporter.kt @@ -6,8 +6,8 @@ import prog8.ast.Program import prog8.ast.base.SyntaxError import prog8.ast.statements.Directive import prog8.ast.statements.DirectiveArg +import prog8.code.core.Position import prog8.compilerinterface.IErrorReporter -import prog8.compilerinterface.Position import prog8.parser.Prog8Parser import prog8.parser.SourceCode import java.io.File diff --git a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt index 726368479..89572a877 100644 --- a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt +++ b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt @@ -1,10 +1,12 @@ package prog8.compiler.astprocessing import prog8.ast.* -import prog8.ast.base.* +import prog8.ast.base.FatalAstException +import prog8.ast.base.SyntaxError import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.IAstVisitor +import prog8.code.core.* import prog8.compilerinterface.* import java.io.CharConversionException import java.io.File diff --git a/compiler/src/prog8/compiler/astprocessing/AstExtensions.kt b/compiler/src/prog8/compiler/astprocessing/AstExtensions.kt index 3311cc214..40abf1f8d 100644 --- a/compiler/src/prog8/compiler/astprocessing/AstExtensions.kt +++ b/compiler/src/prog8/compiler/astprocessing/AstExtensions.kt @@ -9,7 +9,11 @@ import prog8.ast.statements.Directive import prog8.ast.statements.VarDeclOrigin import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.* +import prog8.code.core.DataType +import prog8.code.core.Encoding +import prog8.compilerinterface.CompilationOptions +import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IErrorReporter internal fun Program.checkValid(errors: IErrorReporter, compilerOptions: CompilationOptions) { diff --git a/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt b/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt index d40bec927..8a01817d7 100644 --- a/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt +++ b/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt @@ -8,10 +8,11 @@ import prog8.ast.expressions.FunctionCallExpression import prog8.ast.expressions.StringLiteral import prog8.ast.statements.* import prog8.ast.walk.IAstVisitor +import prog8.code.core.Position import prog8.compilerinterface.BuiltinFunctions import prog8.compilerinterface.ICompilationTarget import prog8.compilerinterface.IErrorReporter -import prog8.compilerinterface.Position + internal class AstIdentifiersChecker(private val errors: IErrorReporter, private val program: Program, diff --git a/compiler/src/prog8/compiler/astprocessing/AstPreprocessor.kt b/compiler/src/prog8/compiler/astprocessing/AstPreprocessor.kt index 477e31df5..a1766e12c 100644 --- a/compiler/src/prog8/compiler/astprocessing/AstPreprocessor.kt +++ b/compiler/src/prog8/compiler/astprocessing/AstPreprocessor.kt @@ -8,13 +8,17 @@ import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.* +import prog8.code.core.Encoding +import prog8.code.core.NumericDatatypes +import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IErrorReporter +import prog8.compilerinterface.InternalCompilerException class AstPreprocessor(val program: Program, val errors: IErrorReporter, val compTarget: ICompilationTarget) : AstWalker() { override fun before(char: CharLiteral, parent: Node): Iterable { - if(char.encoding==Encoding.DEFAULT) + if(char.encoding== Encoding.DEFAULT) char.encoding = compTarget.defaultEncoding return noModifications } diff --git a/compiler/src/prog8/compiler/astprocessing/AstVariousTransforms.kt b/compiler/src/prog8/compiler/astprocessing/AstVariousTransforms.kt index 746f1e3dc..3e53609d1 100644 --- a/compiler/src/prog8/compiler/astprocessing/AstVariousTransforms.kt +++ b/compiler/src/prog8/compiler/astprocessing/AstVariousTransforms.kt @@ -12,7 +12,7 @@ import prog8.ast.statements.Subroutine import prog8.ast.statements.VarDecl import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.DataType +import prog8.code.core.DataType internal class AstVariousTransforms(private val program: Program) : AstWalker() { @@ -104,7 +104,7 @@ internal class AstVariousTransforms(private val program: Program) : AstWalker() internal fun replacePointerVarIndexWithMemreadOrMemwrite(program: Program, arrayIndexedExpression: ArrayIndexedExpression, parent: Node): Iterable { val arrayVar = arrayIndexedExpression.arrayvar.targetVarDecl(program) - if(arrayVar!=null && arrayVar.datatype == DataType.UWORD) { + if(arrayVar!=null && arrayVar.datatype == DataType.UWORD) { // rewrite pointervar[index] into @(pointervar+index) val indexer = arrayIndexedExpression.indexer val add = BinaryExpression(arrayIndexedExpression.arrayvar.copy(), "+", indexer.indexExpr, arrayIndexedExpression.position) diff --git a/compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt b/compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt index 41babc278..a9f26181b 100644 --- a/compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt +++ b/compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt @@ -1,12 +1,15 @@ package prog8.compiler.astprocessing import prog8.ast.* -import prog8.ast.base.* +import prog8.ast.base.FatalAstException import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification import prog8.ast.walk.IAstVisitor +import prog8.code.core.DataType +import prog8.code.core.NumericDatatypes +import prog8.code.core.Position import prog8.compilerinterface.* internal class BeforeAsmAstChanger(val program: Program, diff --git a/compiler/src/prog8/compiler/astprocessing/BeforeAsmTypecastCleaner.kt b/compiler/src/prog8/compiler/astprocessing/BeforeAsmTypecastCleaner.kt index 7371352fa..802a0253e 100644 --- a/compiler/src/prog8/compiler/astprocessing/BeforeAsmTypecastCleaner.kt +++ b/compiler/src/prog8/compiler/astprocessing/BeforeAsmTypecastCleaner.kt @@ -8,7 +8,12 @@ import prog8.ast.statements.BuiltinFunctionCallStatement import prog8.ast.statements.FunctionCallStatement import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.* +import prog8.code.core.ByteDatatypes +import prog8.code.core.DataType +import prog8.code.core.PassByReferenceDatatypes +import prog8.code.core.WordDatatypes +import prog8.compilerinterface.IErrorReporter + internal class BeforeAsmTypecastCleaner(val program: Program, private val errors: IErrorReporter diff --git a/compiler/src/prog8/compiler/astprocessing/CodeDesugarer.kt b/compiler/src/prog8/compiler/astprocessing/CodeDesugarer.kt index 9a2e526e5..1c0c49820 100644 --- a/compiler/src/prog8/compiler/astprocessing/CodeDesugarer.kt +++ b/compiler/src/prog8/compiler/astprocessing/CodeDesugarer.kt @@ -8,8 +8,9 @@ import prog8.ast.expressions.PrefixExpression import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification +import prog8.code.core.Position import prog8.compilerinterface.IErrorReporter -import prog8.compilerinterface.Position + private var generatedLabelSequenceNumber: Int = 0 diff --git a/compiler/src/prog8/compiler/astprocessing/LiteralsToAutoVars.kt b/compiler/src/prog8/compiler/astprocessing/LiteralsToAutoVars.kt index bb3841f62..02f3311f0 100644 --- a/compiler/src/prog8/compiler/astprocessing/LiteralsToAutoVars.kt +++ b/compiler/src/prog8/compiler/astprocessing/LiteralsToAutoVars.kt @@ -11,8 +11,8 @@ import prog8.ast.statements.VarDecl import prog8.ast.statements.WhenChoice import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Encoding +import prog8.code.core.DataType +import prog8.code.core.Encoding import prog8.compilerinterface.ICompilationTarget import prog8.compilerinterface.IErrorReporter diff --git a/compiler/src/prog8/compiler/astprocessing/StatementReorderer.kt b/compiler/src/prog8/compiler/astprocessing/StatementReorderer.kt index 0fad3d136..388a53a00 100644 --- a/compiler/src/prog8/compiler/astprocessing/StatementReorderer.kt +++ b/compiler/src/prog8/compiler/astprocessing/StatementReorderer.kt @@ -1,16 +1,21 @@ package prog8.compiler.astprocessing import prog8.ast.* -import prog8.ast.base.* +import prog8.ast.base.FatalAstException import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.* +import prog8.code.core.* +import prog8.compilerinterface.BuiltinFunctions +import prog8.compilerinterface.CompilationOptions +import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IErrorReporter internal class StatementReorderer(val program: Program, val errors: IErrorReporter, - private val options: CompilationOptions) : AstWalker() { + private val options: CompilationOptions +) : AstWalker() { // Reorders the statements in a way the compiler needs. // - 'main' block must be the very first statement UNLESS it has an address set. // - library blocks are put last. @@ -469,7 +474,8 @@ private fun tryReplaceCallNormalSubWithGosub(call: FunctionCallStatement, parent private fun tryReplaceCallAsmSubWithGosub(call: FunctionCallStatement, parent: Node, callee: Subroutine, - compTarget: ICompilationTarget): Iterable { + compTarget: ICompilationTarget +): Iterable { val noModifications = emptyList() if(callee.parameters.isEmpty()) { diff --git a/compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt b/compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt index 108397744..34fc10df0 100644 --- a/compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt +++ b/compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt @@ -5,6 +5,7 @@ import prog8.ast.base.FatalAstException import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.IAstVisitor +import prog8.code.core.Position import prog8.compilerinterface.* import java.util.* diff --git a/compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt b/compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt index 7028f0c32..e9ddc8a03 100644 --- a/compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt +++ b/compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt @@ -3,12 +3,18 @@ package prog8.compiler.astprocessing import prog8.ast.IFunctionCall import prog8.ast.Node import prog8.ast.Program -import prog8.ast.base.* +import prog8.ast.base.FatalAstException import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.* +import prog8.code.core.ArrayDatatypes +import prog8.code.core.DataType +import prog8.code.core.IterableDatatypes +import prog8.code.core.PassByReferenceDatatypes +import prog8.compilerinterface.BuiltinFunctions +import prog8.compilerinterface.CompilationOptions +import prog8.compilerinterface.IErrorReporter class TypecastsAdder(val program: Program, val options: CompilationOptions, val errors: IErrorReporter) : AstWalker() { diff --git a/compiler/src/prog8/compiler/astprocessing/VariousCleanups.kt b/compiler/src/prog8/compiler/astprocessing/VariousCleanups.kt index 88bd0ea9c..ec4882a58 100644 --- a/compiler/src/prog8/compiler/astprocessing/VariousCleanups.kt +++ b/compiler/src/prog8/compiler/astprocessing/VariousCleanups.kt @@ -11,9 +11,9 @@ import prog8.ast.statements.Assignment import prog8.ast.statements.FunctionCallStatement import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstModification -import prog8.compilerinterface.ArrayDatatypes +import prog8.code.core.ArrayDatatypes +import prog8.code.core.DataType import prog8.compilerinterface.CompilationOptions -import prog8.compilerinterface.DataType import prog8.compilerinterface.IErrorReporter diff --git a/compiler/src/prog8/compiler/astprocessing/VerifyFunctionArgTypes.kt b/compiler/src/prog8/compiler/astprocessing/VerifyFunctionArgTypes.kt index d5d1d3784..1b3867e93 100644 --- a/compiler/src/prog8/compiler/astprocessing/VerifyFunctionArgTypes.kt +++ b/compiler/src/prog8/compiler/astprocessing/VerifyFunctionArgTypes.kt @@ -8,7 +8,11 @@ import prog8.ast.expressions.PipeExpression import prog8.ast.expressions.TypecastExpression import prog8.ast.statements.* import prog8.ast.walk.IAstVisitor -import prog8.compilerinterface.* +import prog8.code.core.DataType +import prog8.code.core.Position +import prog8.compilerinterface.BuiltinFunctions +import prog8.compilerinterface.IErrorReporter +import prog8.compilerinterface.builtinFunctionReturnType internal class VerifyFunctionArgTypes(val program: Program, val errors: IErrorReporter) : IAstVisitor { diff --git a/compiler/test/TestBuiltinFunctions.kt b/compiler/test/TestBuiltinFunctions.kt index bddf2e9e2..95760fb23 100644 --- a/compiler/test/TestBuiltinFunctions.kt +++ b/compiler/test/TestBuiltinFunctions.kt @@ -2,11 +2,10 @@ package prog8tests import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe +import prog8.code.core.DataType +import prog8.code.core.NumericDatatypes +import prog8.code.core.RegisterOrPair import prog8.compilerinterface.BuiltinFunctions -import prog8.compilerinterface.DataType -import prog8.compilerinterface.NumericDatatypes -import prog8.compilerinterface.RegisterOrPair - class TestBuiltinFunctions: FunSpec({ diff --git a/compiler/test/TestCompilerOnCharLit.kt b/compiler/test/TestCompilerOnCharLit.kt index c0ab14acd..cdf5c6146 100644 --- a/compiler/test/TestCompilerOnCharLit.kt +++ b/compiler/test/TestCompilerOnCharLit.kt @@ -8,10 +8,10 @@ import io.kotest.matchers.types.instanceOf import prog8.ast.IFunctionCall import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.NumericLiteral +import prog8.ast.statements.VarDeclType +import prog8.code.core.DataType +import prog8.code.core.Encoding import prog8.codegen.target.Cx16Target -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Encoding -import prog8.compilerinterface.VarDeclType import prog8tests.helpers.compileText diff --git a/compiler/test/TestCompilerOnRanges.kt b/compiler/test/TestCompilerOnRanges.kt index a3a3ff348..155485e3d 100644 --- a/compiler/test/TestCompilerOnRanges.kt +++ b/compiler/test/TestCompilerOnRanges.kt @@ -12,12 +12,14 @@ import prog8.ast.expressions.NumericLiteral import prog8.ast.expressions.RangeExpression import prog8.ast.statements.ForLoop import prog8.ast.statements.VarDecl +import prog8.code.core.DataType +import prog8.code.core.Encoding +import prog8.code.core.Position import prog8.codegen.target.C64Target import prog8.codegen.target.Cx16Target -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Encoding -import prog8.compilerinterface.Position -import prog8tests.helpers.* +import prog8tests.helpers.ErrorReporterForTests +import prog8tests.helpers.cartesianProduct +import prog8tests.helpers.compileText /** diff --git a/compiler/test/TestCompilerOptionLibdirs.kt b/compiler/test/TestCompilerOptionLibdirs.kt index c66b4133c..98e6318de 100644 --- a/compiler/test/TestCompilerOptionLibdirs.kt +++ b/compiler/test/TestCompilerOptionLibdirs.kt @@ -6,7 +6,10 @@ import prog8.codegen.target.Cx16Target import prog8.compiler.CompilationResult import prog8.compiler.CompilerArguments import prog8.compiler.compileProgram -import prog8tests.helpers.* +import prog8tests.helpers.assumeReadableFile +import prog8tests.helpers.fixturesDir +import prog8tests.helpers.outputDir +import prog8tests.helpers.workingDir import java.nio.file.Path import kotlin.io.path.absolute import kotlin.io.path.createTempFile diff --git a/compiler/test/TestMemory.kt b/compiler/test/TestMemory.kt index 0e83004ab..00d9b9ce4 100644 --- a/compiler/test/TestMemory.kt +++ b/compiler/test/TestMemory.kt @@ -10,14 +10,16 @@ import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.NumericLiteral import prog8.ast.expressions.PrefixExpression import prog8.ast.statements.* +import prog8.code.core.DataType +import prog8.code.core.Position import prog8.codegen.target.C64Target import prog8.compiler.printProgram -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Position -import prog8.compilerinterface.VarDeclType import prog8.compilerinterface.isIOAddress import prog8.parser.SourceCode -import prog8tests.helpers.* +import prog8tests.helpers.DummyFunctions +import prog8tests.helpers.DummyMemsizer +import prog8tests.helpers.DummyStringEncoder +import prog8tests.helpers.compileText class TestMemory: FunSpec({ diff --git a/compiler/test/TestNumbers.kt b/compiler/test/TestNumbers.kt index a98dff0c6..10794d99e 100644 --- a/compiler/test/TestNumbers.kt +++ b/compiler/test/TestNumbers.kt @@ -6,10 +6,10 @@ import io.kotest.matchers.doubles.plusOrMinus import io.kotest.matchers.shouldBe import io.kotest.matchers.shouldNotBe import io.kotest.matchers.string.shouldContain +import prog8.code.core.toHex import prog8.codegen.target.C64Target import prog8.codegen.target.cbm.Mflpt5 import prog8.compilerinterface.InternalCompilerException -import prog8.compilerinterface.toHex import prog8tests.helpers.ErrorReporterForTests import prog8tests.helpers.compileText diff --git a/compiler/test/TestNumericLiteral.kt b/compiler/test/TestNumericLiteral.kt index 283520bac..129187bc1 100644 --- a/compiler/test/TestNumericLiteral.kt +++ b/compiler/test/TestNumericLiteral.kt @@ -10,9 +10,10 @@ import prog8.ast.expressions.ArrayLiteral import prog8.ast.expressions.InferredTypes import prog8.ast.expressions.NumericLiteral import prog8.ast.expressions.StringLiteral -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Encoding -import prog8.compilerinterface.Position +import prog8.code.core.DataType +import prog8.code.core.Encoding +import prog8.code.core.Position + class TestNumericLiteral: FunSpec({ diff --git a/compiler/test/TestOptimization.kt b/compiler/test/TestOptimization.kt index 1d626c526..1e6b69005 100644 --- a/compiler/test/TestOptimization.kt +++ b/compiler/test/TestOptimization.kt @@ -13,12 +13,17 @@ import prog8.ast.ParentSentinel import prog8.ast.Program import prog8.ast.expressions.* import prog8.ast.statements.* +import prog8.code.core.DataType +import prog8.code.core.Position import prog8.codegen.target.C64Target import prog8.compiler.astprocessing.processAstBeforeAsmGeneration import prog8.compiler.printProgram -import prog8.compilerinterface.* +import prog8.compilerinterface.CbmPrgLauncherType +import prog8.compilerinterface.CompilationOptions +import prog8.compilerinterface.OutputType +import prog8.compilerinterface.ZeropageType import prog8tests.helpers.* -import prog8.compilerinterface.Position.Companion as Position1 + class TestOptimization: FunSpec({ test("remove empty subroutine except start") { @@ -70,8 +75,8 @@ class TestOptimization: FunSpec({ } test("generated constvalue from typecast inherits proper parent linkage") { - val number = NumericLiteral(DataType.UBYTE, 11.0, Position1.DUMMY) - val tc = TypecastExpression(number, DataType.BYTE, false, Position1.DUMMY) + val number = NumericLiteral(DataType.UBYTE, 11.0, Position.DUMMY) + val tc = TypecastExpression(number, DataType.BYTE, false, Position.DUMMY) val program = Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder) tc.linkParents(ParentSentinel) tc.parent shouldNotBe null @@ -85,8 +90,8 @@ class TestOptimization: FunSpec({ } test("generated constvalue from prefixexpr inherits proper parent linkage") { - val number = NumericLiteral(DataType.UBYTE, 11.0, Position1.DUMMY) - val pfx = PrefixExpression("-", number, Position1.DUMMY) + val number = NumericLiteral(DataType.UBYTE, 11.0, Position.DUMMY) + val pfx = PrefixExpression("-", number, Position.DUMMY) val program = Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder) pfx.linkParents(ParentSentinel) pfx.parent shouldNotBe null @@ -137,23 +142,23 @@ class TestOptimization: FunSpec({ val addR0value = (stmts[5] as Assignment).value val binexpr0 = addR0value as BinaryExpression binexpr0.operator shouldBe "+" - binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position1.DUMMY) + binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position.DUMMY) val addR2value = (stmts[7] as Assignment).value val binexpr2 = addR2value as BinaryExpression binexpr2.operator shouldBe "+" - binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position1.DUMMY) + binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position.DUMMY) val addR4value = (stmts[9] as Assignment).value val binexpr4 = addR4value as BinaryExpression binexpr4.operator shouldBe "+" - binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 22.0, Position1.DUMMY) + binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 22.0, Position.DUMMY) val subR5value = (stmts[11] as Assignment).value val binexpr5 = subR5value as BinaryExpression binexpr5.operator shouldBe "-" - binexpr5.right shouldBe NumericLiteral(DataType.UWORD, 1899.0, Position1.DUMMY) + binexpr5.right shouldBe NumericLiteral(DataType.UWORD, 1899.0, Position.DUMMY) val subR7value = (stmts[13] as Assignment).value val binexpr7 = subR7value as BinaryExpression binexpr7.operator shouldBe "+" - binexpr7.right shouldBe NumericLiteral(DataType.UWORD, 99.0, Position1.DUMMY) + binexpr7.right shouldBe NumericLiteral(DataType.UWORD, 99.0, Position.DUMMY) } test("const folding multiple scenarios * and /") { @@ -190,27 +195,27 @@ class TestOptimization: FunSpec({ val mulR0Value = (stmts[3] as Assignment).value val binexpr0 = mulR0Value as BinaryExpression binexpr0.operator shouldBe "*" - binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position1.DUMMY) + binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position.DUMMY) val mulR1Value = (stmts[5] as Assignment).value val binexpr1 = mulR1Value as BinaryExpression binexpr1.operator shouldBe "*" - binexpr1.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position1.DUMMY) + binexpr1.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position.DUMMY) val divR2Value = (stmts[7] as Assignment).value val binexpr2 = divR2Value as BinaryExpression binexpr2.operator shouldBe "/" - binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position1.DUMMY) + binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position.DUMMY) val mulR3Value = (stmts[9] as Assignment).value val binexpr3 = mulR3Value as BinaryExpression binexpr3.operator shouldBe "*" - binexpr3.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position1.DUMMY) + binexpr3.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position.DUMMY) val mulR4Value = (stmts[11] as Assignment).value val binexpr4 = mulR4Value as BinaryExpression binexpr4.operator shouldBe "*" - binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position1.DUMMY) + binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position.DUMMY) val divR4Value = (stmts[12] as Assignment).value val binexpr4b = divR4Value as BinaryExpression binexpr4b.operator shouldBe "/" - binexpr4b.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position1.DUMMY) + binexpr4b.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position.DUMMY) } test("constantfolded and silently typecasted for initializervalues") { @@ -485,23 +490,23 @@ class TestOptimization: FunSpec({ val z6plus = statements[13] as Assignment z1decl.name shouldBe "z1" - z1init.value shouldBe NumericLiteral(DataType.UBYTE, 10.0, Position1.DUMMY) + z1init.value shouldBe NumericLiteral(DataType.UBYTE, 10.0, Position.DUMMY) z2decl.name shouldBe "z2" - z2init.value shouldBe NumericLiteral(DataType.UBYTE, 255.0, Position1.DUMMY) + z2init.value shouldBe NumericLiteral(DataType.UBYTE, 255.0, Position.DUMMY) z3decl.name shouldBe "z3" - z3init.value shouldBe NumericLiteral(DataType.UBYTE, 1.0, Position1.DUMMY) + z3init.value shouldBe NumericLiteral(DataType.UBYTE, 1.0, Position.DUMMY) z4decl.name shouldBe "z4" - z4init.value shouldBe NumericLiteral(DataType.UBYTE, 0.0, Position1.DUMMY) + z4init.value shouldBe NumericLiteral(DataType.UBYTE, 0.0, Position.DUMMY) z5decl.name shouldBe "z5" (z5init.value as? IdentifierReference)?.nameInSource shouldBe listOf("z1") z5plus.isAugmentable shouldBe true (z5plus.value as BinaryExpression).operator shouldBe "+" - (z5plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position1.DUMMY) + (z5plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position.DUMMY) z6decl.name shouldBe "z6" (z6init.value as? IdentifierReference)?.nameInSource shouldBe listOf("z1") z6plus.isAugmentable shouldBe true (z6plus.value as BinaryExpression).operator shouldBe "-" - (z6plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position1.DUMMY) + (z6plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position.DUMMY) } test("force_output option should work with optimizing memwrite assignment") { @@ -655,12 +660,12 @@ class TestOptimization: FunSpec({ stmts.filterIsInstance().size shouldBe 5 val assignXX1 = stmts[1] as Assignment assignXX1.target.identifier!!.nameInSource shouldBe listOf("xx") - assignXX1.value shouldBe NumericLiteral(DataType.UBYTE, 20.0, Position1.DUMMY) + assignXX1.value shouldBe NumericLiteral(DataType.UBYTE, 20.0, Position.DUMMY) val assignXX2 = stmts.last() as Assignment assignXX2.target.identifier!!.nameInSource shouldBe listOf("xx") val xxValue = assignXX2.value as BinaryExpression xxValue.operator shouldBe "+" (xxValue.left as? IdentifierReference)?.nameInSource shouldBe listOf("xx") - xxValue.right shouldBe NumericLiteral(DataType.UBYTE, 10.0, Position1.DUMMY) + xxValue.right shouldBe NumericLiteral(DataType.UBYTE, 10.0, Position.DUMMY) } }) diff --git a/compiler/test/TestPipes.kt b/compiler/test/TestPipes.kt index 2e78c9a91..32ac5a4a1 100644 --- a/compiler/test/TestPipes.kt +++ b/compiler/test/TestPipes.kt @@ -11,10 +11,10 @@ import prog8.ast.statements.Assignment import prog8.ast.statements.FunctionCallStatement import prog8.ast.statements.Pipe import prog8.ast.statements.VarDecl +import prog8.code.core.DataType +import prog8.code.core.Position import prog8.codegen.target.C64Target import prog8.compiler.astprocessing.AstPreprocessor -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Position import prog8.parser.Prog8Parser.parseModule import prog8.parser.SourceCode import prog8tests.helpers.* diff --git a/compiler/test/TestStringEncodings.kt b/compiler/test/TestStringEncodings.kt index 6282169ae..ec9048430 100644 --- a/compiler/test/TestStringEncodings.kt +++ b/compiler/test/TestStringEncodings.kt @@ -6,7 +6,6 @@ import com.github.michaelbull.result.getOrElse import io.kotest.assertions.withClue import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe -import io.kotest.matchers.shouldNot import io.kotest.matchers.shouldNotBe import io.kotest.matchers.string.shouldContain import prog8.codegen.target.C64Target diff --git a/compiler/test/TestSubroutines.kt b/compiler/test/TestSubroutines.kt index e1806cec4..4808e6e28 100644 --- a/compiler/test/TestSubroutines.kt +++ b/compiler/test/TestSubroutines.kt @@ -11,8 +11,8 @@ import prog8.ast.expressions.DirectMemoryRead import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.NumericLiteral import prog8.ast.statements.* +import prog8.code.core.DataType import prog8.codegen.target.C64Target -import prog8.compilerinterface.DataType import prog8tests.helpers.ErrorReporterForTests import prog8tests.helpers.compileText diff --git a/compiler/test/TestSymbolTable.kt b/compiler/test/TestSymbolTable.kt index 578892ce1..d2a460f64 100644 --- a/compiler/test/TestSymbolTable.kt +++ b/compiler/test/TestSymbolTable.kt @@ -4,6 +4,8 @@ import io.kotest.assertions.fail import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe import io.kotest.matchers.shouldNotBe +import prog8.code.core.DataType +import prog8.code.core.Position import prog8.compilerinterface.* class TestSymbolTable: FunSpec({ diff --git a/compiler/test/ZeropageTests.kt b/compiler/test/ZeropageTests.kt index b2c44fa88..e6f9f8773 100644 --- a/compiler/test/ZeropageTests.kt +++ b/compiler/test/ZeropageTests.kt @@ -12,6 +12,7 @@ import io.kotest.matchers.collections.shouldNotBeIn import io.kotest.matchers.comparables.shouldBeGreaterThan import io.kotest.matchers.shouldBe import io.kotest.matchers.shouldNotBe +import prog8.code.core.DataType import prog8.codegen.target.C64Target import prog8.codegen.target.Cx16Target import prog8.codegen.target.c64.C64Zeropage diff --git a/compiler/test/ast/TestIdentifierRef.kt b/compiler/test/ast/TestIdentifierRef.kt index 685dbb36f..586983098 100644 --- a/compiler/test/ast/TestIdentifierRef.kt +++ b/compiler/test/ast/TestIdentifierRef.kt @@ -9,7 +9,7 @@ import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.NumericLiteral import prog8.ast.expressions.PrefixExpression import prog8.ast.statements.* -import prog8.compilerinterface.Position +import prog8.code.core.Position import prog8.parser.Prog8Parser import prog8.parser.SourceCode import prog8tests.helpers.DummyFunctions diff --git a/compiler/test/ast/TestIntermediateAst.kt b/compiler/test/ast/TestIntermediateAst.kt index 015320ac5..63c7c07c0 100644 --- a/compiler/test/ast/TestIntermediateAst.kt +++ b/compiler/test/ast/TestIntermediateAst.kt @@ -4,9 +4,9 @@ import io.kotest.assertions.fail import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.ints.shouldBeGreaterThan import io.kotest.matchers.shouldBe +import prog8.code.ast.PtVariable import prog8.codegen.target.C64Target import prog8.compiler.IntermediateAstMaker -import prog8.compilerinterface.intermediate.PtVariable import prog8tests.helpers.compileText class TestIntermediateAst: FunSpec({ diff --git a/compiler/test/ast/TestProg8Parser.kt b/compiler/test/ast/TestProg8Parser.kt index 62905ad29..c7748f0cc 100644 --- a/compiler/test/ast/TestProg8Parser.kt +++ b/compiler/test/ast/TestProg8Parser.kt @@ -17,11 +17,11 @@ import prog8.ast.Node import prog8.ast.Program import prog8.ast.expressions.* import prog8.ast.statements.* +import prog8.code.core.DataType +import prog8.code.core.Encoding +import prog8.code.core.Position import prog8.codegen.target.C64Target import prog8.codegen.target.cbm.PetsciiEncoding -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Encoding -import prog8.compilerinterface.Position import prog8.parser.ParseError import prog8.parser.Prog8Parser.parseModule import prog8.parser.SourceCode diff --git a/compiler/test/ast/TestProgram.kt b/compiler/test/ast/TestProgram.kt index 3c5765bf1..09a677203 100644 --- a/compiler/test/ast/TestProgram.kt +++ b/compiler/test/ast/TestProgram.kt @@ -10,7 +10,7 @@ import io.kotest.matchers.types.shouldBeSameInstanceAs import prog8.ast.Module import prog8.ast.Program import prog8.ast.internedStringsModuleName -import prog8.compilerinterface.Position +import prog8.code.core.Position import prog8.parser.SourceCode import prog8tests.helpers.DummyFunctions import prog8tests.helpers.DummyMemsizer diff --git a/compiler/test/ast/TestSubroutines.kt b/compiler/test/ast/TestSubroutines.kt index a97545da4..19d0d0015 100644 --- a/compiler/test/ast/TestSubroutines.kt +++ b/compiler/test/ast/TestSubroutines.kt @@ -4,7 +4,7 @@ import io.kotest.core.spec.style.AnnotationSpec import io.kotest.matchers.shouldBe import prog8.ast.statements.Block import prog8.ast.statements.Subroutine -import prog8.compilerinterface.DataType +import prog8.code.core.DataType import prog8.parser.Prog8Parser.parseModule import prog8.parser.SourceCode diff --git a/compiler/test/ast/TestVarious.kt b/compiler/test/ast/TestVarious.kt index 79123150a..27f508263 100644 --- a/compiler/test/ast/TestVarious.kt +++ b/compiler/test/ast/TestVarious.kt @@ -4,8 +4,8 @@ import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe import io.kotest.matchers.shouldNotBe import prog8.ast.statements.InlineAssembly +import prog8.code.core.Position import prog8.codegen.target.C64Target -import prog8.compilerinterface.Position import prog8tests.helpers.compileText class TestVarious: FunSpec({ diff --git a/compiler/test/codegeneration/TestAsmGenSymbols.kt b/compiler/test/codegeneration/TestAsmGenSymbols.kt index 552afe261..9541d2016 100644 --- a/compiler/test/codegeneration/TestAsmGenSymbols.kt +++ b/compiler/test/codegeneration/TestAsmGenSymbols.kt @@ -8,11 +8,17 @@ import prog8.ast.expressions.AddressOf import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.NumericLiteral import prog8.ast.statements.* +import prog8.code.core.DataType +import prog8.code.core.Position +import prog8.code.core.RegisterOrPair import prog8.codegen.cpu6502.AsmGen import prog8.codegen.target.C64Target import prog8.codegen.target.c64.C64Zeropage import prog8.compiler.astprocessing.SymbolTableMaker -import prog8.compilerinterface.* +import prog8.compilerinterface.CbmPrgLauncherType +import prog8.compilerinterface.CompilationOptions +import prog8.compilerinterface.OutputType +import prog8.compilerinterface.ZeropageType import prog8.parser.SourceCode import prog8tests.helpers.DummyFunctions import prog8tests.helpers.DummyMemsizer diff --git a/compiler/test/helpers/Dummies.kt b/compiler/test/helpers/Dummies.kt index 948ac24e6..30fb525b9 100644 --- a/compiler/test/helpers/Dummies.kt +++ b/compiler/test/helpers/Dummies.kt @@ -4,9 +4,11 @@ import prog8.ast.IBuiltinFunctions import prog8.ast.expressions.Expression import prog8.ast.expressions.InferredTypes import prog8.ast.expressions.NumericLiteral -import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine -import prog8.compilerinterface.* +import prog8.code.core.* +import prog8.compilerinterface.ICompilationTarget +import prog8.compilerinterface.IMachineDefinition + internal object DummyFunctions : IBuiltinFunctions { override val names: Set = emptySet() diff --git a/compiler/test/helpers/ErrorReporterForTests.kt b/compiler/test/helpers/ErrorReporterForTests.kt index ee0675e36..4c96ff2e5 100644 --- a/compiler/test/helpers/ErrorReporterForTests.kt +++ b/compiler/test/helpers/ErrorReporterForTests.kt @@ -1,7 +1,7 @@ package prog8tests.helpers +import prog8.code.core.Position import prog8.compilerinterface.IErrorReporter -import prog8.compilerinterface.Position internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true, private val keepMessagesAfterReporting: Boolean=false): IErrorReporter { diff --git a/compilerAst/compilerAst.iml b/compilerAst/compilerAst.iml index 2aea16405..b871ba4e4 100644 --- a/compilerAst/compilerAst.iml +++ b/compilerAst/compilerAst.iml @@ -13,5 +13,6 @@ + \ No newline at end of file diff --git a/compilerAst/src/prog8/ast/AstToSourceTextConverter.kt b/compilerAst/src/prog8/ast/AstToSourceTextConverter.kt index 6b99a7fc9..8a6763ff1 100644 --- a/compilerAst/src/prog8/ast/AstToSourceTextConverter.kt +++ b/compilerAst/src/prog8/ast/AstToSourceTextConverter.kt @@ -4,7 +4,10 @@ import prog8.ast.antlr.escape import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.ast.walk.IAstVisitor -import prog8.compilerinterface.* +import prog8.code.core.DataType +import prog8.code.core.Encoding +import prog8.code.core.NumericDatatypes +import prog8.code.core.toHex /** diff --git a/compilerAst/src/prog8/ast/AstToplevel.kt b/compilerAst/src/prog8/ast/AstToplevel.kt index 7fedea955..536951fbc 100644 --- a/compilerAst/src/prog8/ast/AstToplevel.kt +++ b/compilerAst/src/prog8/ast/AstToplevel.kt @@ -7,8 +7,8 @@ import prog8.ast.expressions.NumericLiteral import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstVisitor -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Position +import prog8.code.core.DataType +import prog8.code.core.Position import prog8.parser.SourceCode const val internedStringsModuleName = "prog8_interned_strings" diff --git a/compilerAst/src/prog8/ast/Extensions.kt b/compilerAst/src/prog8/ast/Extensions.kt index 7ffa61081..afe06e22c 100644 --- a/compilerAst/src/prog8/ast/Extensions.kt +++ b/compilerAst/src/prog8/ast/Extensions.kt @@ -4,10 +4,10 @@ import prog8.ast.base.FatalAstException import prog8.ast.expressions.InferredTypes import prog8.ast.statements.VarDecl import prog8.ast.statements.VarDeclOrigin +import prog8.ast.statements.VarDeclType import prog8.ast.statements.ZeropageWish -import prog8.compilerinterface.DataType -import prog8.compilerinterface.Position -import prog8.compilerinterface.VarDeclType +import prog8.code.core.DataType +import prog8.code.core.Position fun Program.getTempVar(dt: DataType, altNames: Boolean=false): Pair, VarDecl> { diff --git a/compilerAst/src/prog8/ast/IBuiltinFunctions.kt b/compilerAst/src/prog8/ast/IBuiltinFunctions.kt index c2f4dc481..b322f068d 100644 --- a/compilerAst/src/prog8/ast/IBuiltinFunctions.kt +++ b/compilerAst/src/prog8/ast/IBuiltinFunctions.kt @@ -3,7 +3,7 @@ package prog8.ast import prog8.ast.expressions.Expression import prog8.ast.expressions.InferredTypes import prog8.ast.expressions.NumericLiteral -import prog8.compilerinterface.Position +import prog8.code.core.Position interface IBuiltinFunctions { val names: Set diff --git a/compilerAst/src/prog8/ast/Program.kt b/compilerAst/src/prog8/ast/Program.kt index 3b4d7f5e2..5091564d4 100644 --- a/compilerAst/src/prog8/ast/Program.kt +++ b/compilerAst/src/prog8/ast/Program.kt @@ -5,7 +5,10 @@ import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.StringLiteral import prog8.ast.statements.* import prog8.ast.walk.IAstVisitor -import prog8.compilerinterface.* +import prog8.code.core.DataType +import prog8.code.core.IMemSizer +import prog8.code.core.IStringEncoding +import prog8.code.core.Position import prog8.parser.SourceCode /*********** Everything starts from here, the Program; zero or more modules *************/ diff --git a/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt b/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt index 274f79ca2..eace01d50 100644 --- a/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt +++ b/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt @@ -2,10 +2,11 @@ package prog8.ast.antlr import org.antlr.v4.runtime.ParserRuleContext import org.antlr.v4.runtime.tree.TerminalNode -import prog8.ast.base.* +import prog8.ast.base.FatalAstException +import prog8.ast.base.SyntaxError import prog8.ast.expressions.* import prog8.ast.statements.* -import prog8.compilerinterface.* +import prog8.code.core.* import prog8.parser.Prog8ANTLRParser import prog8.parser.SourceCode import java.nio.file.Path diff --git a/compilerAst/src/prog8/ast/antlr/EscapeChars.kt b/compilerAst/src/prog8/ast/antlr/EscapeChars.kt index 56fed0a02..5d82e287a 100644 --- a/compilerAst/src/prog8/ast/antlr/EscapeChars.kt +++ b/compilerAst/src/prog8/ast/antlr/EscapeChars.kt @@ -1,7 +1,7 @@ package prog8.ast.antlr import prog8.ast.base.SyntaxError -import prog8.compilerinterface.Position +import prog8.code.core.Position fun escape(str: String): String { val es = str.map { diff --git a/compilerAst/src/prog8/ast/base/Errors.kt b/compilerAst/src/prog8/ast/base/Errors.kt index 7b2b20b11..7095d4dd9 100644 --- a/compilerAst/src/prog8/ast/base/Errors.kt +++ b/compilerAst/src/prog8/ast/base/Errors.kt @@ -1,7 +1,7 @@ package prog8.ast.base import prog8.ast.expressions.IdentifierReference -import prog8.compilerinterface.Position +import prog8.code.core.Position /** * A severe problem in the Ast (such as internal inconsistency or failed invariant) diff --git a/compilerAst/src/prog8/ast/expressions/AstExpressions.kt b/compilerAst/src/prog8/ast/expressions/AstExpressions.kt index 6469831a7..1be882c10 100644 --- a/compilerAst/src/prog8/ast/expressions/AstExpressions.kt +++ b/compilerAst/src/prog8/ast/expressions/AstExpressions.kt @@ -2,11 +2,13 @@ package prog8.ast.expressions import prog8.ast.* import prog8.ast.antlr.escape -import prog8.ast.base.* +import prog8.ast.base.ExpressionError +import prog8.ast.base.FatalAstException +import prog8.ast.base.UndefinedSymbolError import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstVisitor -import prog8.compilerinterface.* +import prog8.code.core.* import java.util.* import kotlin.math.abs import kotlin.math.round diff --git a/compilerAst/src/prog8/ast/expressions/InferredTypes.kt b/compilerAst/src/prog8/ast/expressions/InferredTypes.kt index c670b151a..f8b653e94 100644 --- a/compilerAst/src/prog8/ast/expressions/InferredTypes.kt +++ b/compilerAst/src/prog8/ast/expressions/InferredTypes.kt @@ -1,7 +1,6 @@ package prog8.ast.expressions -import prog8.ast.base.* -import prog8.compilerinterface.* +import prog8.code.core.* import java.util.* diff --git a/compilerAst/src/prog8/ast/statements/AstStatements.kt b/compilerAst/src/prog8/ast/statements/AstStatements.kt index cd8ac05cc..dffc1138b 100644 --- a/compilerAst/src/prog8/ast/statements/AstStatements.kt +++ b/compilerAst/src/prog8/ast/statements/AstStatements.kt @@ -1,11 +1,12 @@ package prog8.ast.statements import prog8.ast.* -import prog8.ast.base.* +import prog8.ast.base.FatalAstException +import prog8.ast.base.SyntaxError import prog8.ast.expressions.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstVisitor -import prog8.compilerinterface.* +import prog8.code.core.* interface INamedStatement { @@ -65,8 +66,6 @@ class BuiltinFunctionPlaceholder(override val name: String, override val positio override fun copy() = throw NotImplementedError("no support for duplicating a BuiltinFunctionStatementPlaceholder") } -data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?) - class Block(override val name: String, val address: UInt?, override var statements: MutableList, @@ -182,6 +181,12 @@ enum class VarDeclOrigin { AUTOGENERATED } +enum class VarDeclType { + VAR, + CONST, + MEMORY +} + class VarDecl(val type: VarDeclType, val origin: VarDeclOrigin, diff --git a/compilerAst/src/prog8/compilerinterface/Base.kt b/compilerAst/src/prog8/compilerinterface/Base.kt deleted file mode 100644 index e604b7dc2..000000000 --- a/compilerAst/src/prog8/compilerinterface/Base.kt +++ /dev/null @@ -1,212 +0,0 @@ -package prog8.compilerinterface - -import kotlin.io.path.Path -import kotlin.io.path.absolute -import kotlin.math.abs - - -/**************************** AST Data classes ****************************/ - -enum class DataType { - UBYTE, // pass by value - BYTE, // pass by value - UWORD, // pass by value - WORD, // pass by value - FLOAT, // pass by value - STR, // pass by reference - ARRAY_UB, // pass by reference - ARRAY_B, // pass by reference - ARRAY_UW, // pass by reference - ARRAY_W, // pass by reference - ARRAY_F, // pass by reference - UNDEFINED; - - /** - * is the type assignable to the given other type (perhaps via a typecast) without loss of precision? - */ - infix fun isAssignableTo(targetType: DataType) = - when(this) { - UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, FLOAT) - BYTE -> targetType.oneOf(BYTE, WORD, FLOAT) - UWORD -> targetType.oneOf(UWORD, FLOAT) - WORD -> targetType.oneOf(WORD, FLOAT) - FLOAT -> targetType == FLOAT - STR -> targetType.oneOf(STR, UWORD) - in ArrayDatatypes -> targetType == this - else -> false - } - - fun oneOf(vararg types: DataType) = this in types - - infix fun largerThan(other: DataType) = - when { - this == other -> false - this in ByteDatatypes -> false - this in WordDatatypes -> other in ByteDatatypes - this== STR && other== UWORD || this== UWORD && other== STR -> false - else -> true - } - - infix fun equalsSize(other: DataType) = - when { - this == other -> true - this in ByteDatatypes -> other in ByteDatatypes - this in WordDatatypes -> other in WordDatatypes - this== STR && other== UWORD || this== UWORD && other== STR -> true - else -> false - } -} - -enum class CpuRegister { - A, - X, - Y; - - fun asRegisterOrPair(): RegisterOrPair = when(this) { - A -> RegisterOrPair.A - X -> RegisterOrPair.X - Y -> RegisterOrPair.Y - } -} - -enum class RegisterOrPair { - A, - X, - Y, - AX, - AY, - XY, - FAC1, - FAC2, - // cx16 virtual registers: - R0, R1, R2, R3, R4, R5, R6, R7, - R8, R9, R10, R11, R12, R13, R14, R15; - - companion object { - val names by lazy { values().map { it.toString()} } - } - - fun asCpuRegister(): CpuRegister = when(this) { - A -> CpuRegister.A - X -> CpuRegister.X - Y -> CpuRegister.Y - else -> throw IllegalArgumentException("no cpu hardware register for $this") - } - -} // only used in parameter and return value specs in asm subroutines - -enum class Statusflag { - Pc, - Pz, // don't use - Pv, - Pn; // don't use - - companion object { - val names by lazy { values().map { it.toString()} } - } -} - -enum class BranchCondition { - CS, - CC, - EQ, - Z, - NE, - NZ, - VS, - VC, - MI, - NEG, - PL, - POS -} - -enum class VarDeclType { - VAR, - CONST, - MEMORY -} - -val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE) -val WordDatatypes = arrayOf(DataType.UWORD, DataType.WORD) -val IntegerDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD) -val NumericDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT) -val SignedDatatypes = arrayOf(DataType.BYTE, DataType.WORD, DataType.FLOAT) -val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F) -val StringlyDatatypes = arrayOf(DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B, DataType.UWORD) -val IterableDatatypes = arrayOf( - DataType.STR, - DataType.ARRAY_UB, DataType.ARRAY_B, - DataType.ARRAY_UW, DataType.ARRAY_W, - DataType.ARRAY_F -) -val PassByValueDatatypes = NumericDatatypes -val PassByReferenceDatatypes = IterableDatatypes -val ArrayToElementTypes = mapOf( - DataType.STR to DataType.UBYTE, - DataType.ARRAY_B to DataType.BYTE, - DataType.ARRAY_UB to DataType.UBYTE, - DataType.ARRAY_W to DataType.WORD, - DataType.ARRAY_UW to DataType.UWORD, - DataType.ARRAY_F to DataType.FLOAT -) -val ElementToArrayTypes = mapOf( - DataType.BYTE to DataType.ARRAY_B, - DataType.UBYTE to DataType.ARRAY_UB, - DataType.WORD to DataType.ARRAY_W, - DataType.UWORD to DataType.ARRAY_UW, - DataType.FLOAT to DataType.ARRAY_F -) -val Cx16VirtualRegisters = arrayOf( - RegisterOrPair.R0, RegisterOrPair.R1, RegisterOrPair.R2, RegisterOrPair.R3, - RegisterOrPair.R4, RegisterOrPair.R5, RegisterOrPair.R6, RegisterOrPair.R7, - RegisterOrPair.R8, RegisterOrPair.R9, RegisterOrPair.R10, RegisterOrPair.R11, - RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15 -) - - -data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) { - override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]" - fun toClickableStr(): String { - val path = Path(file).absolute().normalize() - return "file://$path:$line:$startCol:" - } - - companion object { - val DUMMY = Position("", 0, 0, 0) - } -} - - -fun Number.toHex(): String { - // 0..15 -> "0".."15" - // 16..255 -> "$10".."$ff" - // 256..65536 -> "$0100".."$ffff" - // negative values are prefixed with '-'. - val integer = this.toInt() - if(integer<0) - return '-' + abs(integer).toHex() - return when (integer) { - in 0 until 16 -> integer.toString() - in 0 until 0x100 -> "$"+integer.toString(16).padStart(2,'0') - in 0 until 0x10000 -> "$"+integer.toString(16).padStart(4,'0') - else -> throw IllegalArgumentException("number too large for 16 bits $this") - } -} - -fun UInt.toHex(): String { - // 0..15 -> "0".."15" - // 16..255 -> "$10".."$ff" - // 256..65536 -> "$0100".."$ffff" - return when (this) { - in 0u until 16u -> this.toString() - in 0u until 0x100u -> "$"+this.toString(16).padStart(2,'0') - in 0u until 0x10000u -> "$"+this.toString(16).padStart(4,'0') - else -> throw IllegalArgumentException("number too large for 16 bits $this") - } -} - - -interface IMemSizer { - fun memorySize(dt: DataType): Int -} diff --git a/compilerAst/src/prog8/parser/Prog8Parser.kt b/compilerAst/src/prog8/parser/Prog8Parser.kt index 0e6989091..7f7affa7c 100644 --- a/compilerAst/src/prog8/parser/Prog8Parser.kt +++ b/compilerAst/src/prog8/parser/Prog8Parser.kt @@ -5,7 +5,7 @@ import prog8.ast.Module import prog8.ast.antlr.toAst import prog8.ast.statements.Block import prog8.ast.statements.Directive -import prog8.compilerinterface.Position +import prog8.code.core.Position class ParseError(override var message: String, val position: Position, cause: RuntimeException): Exception(message, cause) diff --git a/compilerInterfaces/compilerInterfaces.iml b/compilerInterfaces/compilerInterfaces.iml index 47ad4485c..512383dd4 100644 --- a/compilerInterfaces/compilerInterfaces.iml +++ b/compilerInterfaces/compilerInterfaces.iml @@ -12,5 +12,6 @@ + \ No newline at end of file diff --git a/compilerInterfaces/src/prog8/compilerinterface/AstExtensions.kt b/compilerInterfaces/src/prog8/compilerinterface/AstExtensions.kt index 5d6378485..ccc21a5e4 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/AstExtensions.kt +++ b/compilerInterfaces/src/prog8/compilerinterface/AstExtensions.kt @@ -4,6 +4,7 @@ import prog8.ast.base.FatalAstException import prog8.ast.expressions.IdentifierReference import prog8.ast.expressions.NumericLiteral import prog8.ast.statements.AssignTarget +import prog8.ast.statements.VarDeclType fun AssignTarget.isIOAddress(machine: IMachineDefinition): Boolean { val memAddr = memoryAddress diff --git a/compilerInterfaces/src/prog8/compilerinterface/BuiltinFunctions.kt b/compilerInterfaces/src/prog8/compilerinterface/BuiltinFunctions.kt index 4e41298ae..84f83b2f5 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/BuiltinFunctions.kt +++ b/compilerInterfaces/src/prog8/compilerinterface/BuiltinFunctions.kt @@ -1,9 +1,12 @@ package prog8.compilerinterface import prog8.ast.Program -import prog8.ast.base.* +import prog8.ast.base.AstException +import prog8.ast.base.FatalAstException +import prog8.ast.base.SyntaxError import prog8.ast.expressions.* import prog8.ast.statements.VarDecl +import prog8.code.core.* import kotlin.math.* diff --git a/compilerInterfaces/src/prog8/compilerinterface/ICompilationTarget.kt b/compilerInterfaces/src/prog8/compilerinterface/ICompilationTarget.kt index dba83a876..e56863a18 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/ICompilationTarget.kt +++ b/compilerInterfaces/src/prog8/compilerinterface/ICompilationTarget.kt @@ -1,8 +1,11 @@ package prog8.compilerinterface import prog8.ast.expressions.Expression -import prog8.ast.statements.RegisterOrStatusflag import prog8.ast.statements.Subroutine +import prog8.code.core.Encoding +import prog8.code.core.IMemSizer +import prog8.code.core.IStringEncoding +import prog8.code.core.RegisterOrStatusflag interface ICompilationTarget: IStringEncoding, IMemSizer { diff --git a/compilerInterfaces/src/prog8/compilerinterface/IErrorReporter.kt b/compilerInterfaces/src/prog8/compilerinterface/IErrorReporter.kt index c6c310da2..912d0a442 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/IErrorReporter.kt +++ b/compilerInterfaces/src/prog8/compilerinterface/IErrorReporter.kt @@ -1,5 +1,7 @@ package prog8.compilerinterface +import prog8.code.core.Position + interface IErrorReporter { fun err(msg: String, position: Position) fun warn(msg: String, position: Position) diff --git a/compilerInterfaces/src/prog8/compilerinterface/SymbolTable.kt b/compilerInterfaces/src/prog8/compilerinterface/SymbolTable.kt index aadf3bb9b..a6dee5e52 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/SymbolTable.kt +++ b/compilerInterfaces/src/prog8/compilerinterface/SymbolTable.kt @@ -1,5 +1,9 @@ package prog8.compilerinterface +import prog8.code.core.DataType +import prog8.code.core.Encoding +import prog8.code.core.Position + /** * Tree structure containing all symbol definitions in the program diff --git a/compilerInterfaces/src/prog8/compilerinterface/Zeropage.kt b/compilerInterfaces/src/prog8/compilerinterface/Zeropage.kt index cb1f9a9da..7e3a9fc5e 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/Zeropage.kt +++ b/compilerInterfaces/src/prog8/compilerinterface/Zeropage.kt @@ -3,6 +3,7 @@ package prog8.compilerinterface import com.github.michaelbull.result.Err import com.github.michaelbull.result.Ok import com.github.michaelbull.result.Result +import prog8.code.core.* class ZeropageAllocationError(message: String) : Exception(message)