Apple-2-SW
/
prog8
mirror of https://github.com/irmen/prog8.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

introduced codeAst and codeCore modules to reduce dependencies

This commit is contained in:
Irmen de Jong 2022-03-10 22:38:16 +01:00
parent 844ad09464
commit 9a798360f4
107 changed files with 564 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.idea/modules.xml
View File

@ -2,6 +2,8 @@
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/codeAst/codeAst.iml" filepath="$PROJECT_DIR$/codeAst/codeAst.iml" />
<module fileurl="file://$PROJECT_DIR$/codeCore/codeCore.iml" filepath="$PROJECT_DIR$/codeCore/codeCore.iml" />
<module fileurl="file://$PROJECT_DIR$/codeGenCpu6502/codeGenCpu6502.iml" filepath="$PROJECT_DIR$/codeGenCpu6502/codeGenCpu6502.iml" />
<module fileurl="file://$PROJECT_DIR$/codeGenExperimental6502/codeGenExperimental6502.iml" filepath="$PROJECT_DIR$/codeGenExperimental6502/codeGenExperimental6502.iml" />
<module fileurl="file://$PROJECT_DIR$/codeGenTargets/codeGenTargets.iml" filepath="$PROJECT_DIR$/codeGenTargets/codeGenTargets.iml" />

2
.idea/vcs.xml
View File

@ -3,4 +3,4 @@
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
</component>
</project>
</project>

13
codeAst/codeAst.iml Normal file
View File

@ -0,0 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="KotlinJavaRuntime" level="project" />
<orderEntry type="module" module-name="codeCore" />
</component>
</module>

11
compilerInterfaces/src/prog8/compilerinterface/intermediate/AstBase.kt → codeAst/src/prog8/code/ast/AstBase.kt
View File

@ -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<PtNode> = mutableListOf()) {

8
compilerInterfaces/src/prog8/compilerinterface/intermediate/AstExpressions.kt → codeAst/src/prog8/code/ast/AstExpressions.kt
View File

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

22
compilerInterfaces/src/prog8/compilerinterface/intermediate/AstStatements.kt → codeAst/src/prog8/code/ast/AstStatements.kt
View File

@ -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<SubroutineParameter>,
val parameters: List<PtSubroutineParameter>,
val returntypes: List<DataType>,
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")
}
}

12
codeCore/codeCore.iml Normal file
View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="KotlinJavaRuntime" level="project" />
</component>
</module>

153
codeCore/src/prog8/code/core/Enumerations.kt Normal file
View File

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

5
codeCore/src/prog8/code/core/IMemSizer.kt Normal file
View File

@ -0,0 +1,5 @@
package prog8.code.core
interface IMemSizer {
fun memorySize(dt: DataType): Int
}

2
compilerAst/src/prog8/compilerinterface/IStringEncoding.kt → codeCore/src/prog8/code/core/IStringEncoding.kt
View File

@ -1,4 +1,4 @@
package prog8.compilerinterface
package prog8.code.core
enum class Encoding(val prefix: String) {
DEFAULT("default"), // depends on compilation target

16
codeCore/src/prog8/code/core/Position.kt Normal file
View File

@ -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("<dummy>", 0, 0, 0)
}
}

3
codeCore/src/prog8/code/core/RegisterOrStatusflag.kt Normal file
View File

@ -0,0 +1,3 @@
package prog8.code.core
data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?)

31
codeCore/src/prog8/code/core/ToHex.kt Normal file
View File

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

1
codeGenCpu6502/codeGenCpu6502.iml
View File

@ -12,5 +12,6 @@
<orderEntry type="module" module-name="compilerAst" />
<orderEntry type="module" module-name="compilerInterfaces" />
<orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
<orderEntry type="module" module-name="codeCore" />
</component>
</module>

3
codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt
View File

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

2
codeGenCpu6502/src/prog8/codegen/cpu6502/AsmOptimizer.kt
View File

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

2
codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt
View File

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

5
codeGenCpu6502/src/prog8/codegen/cpu6502/ExpressionsAsmGen.kt
View File

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

7
codeGenCpu6502/src/prog8/codegen/cpu6502/ForLoopsAsmGen.kt
View File

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

3
codeGenCpu6502/src/prog8/codegen/cpu6502/FunctionCallAsmGen.kt
View File

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

3
codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt
View File

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

2
codeGenCpu6502/src/prog8/codegen/cpu6502/ProgramAndVarsGen.kt
View File

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

3
codeGenCpu6502/src/prog8/codegen/cpu6502/VariableAllocator.kt
View File

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

3
codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt
View File

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

6
codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt
View File

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

6
codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt
View File

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

1
codeGenExperimental6502/codeGenExperimental6502.iml
View File

@ -11,5 +11,6 @@
<orderEntry type="library" name="KotlinJavaRuntime" level="project" />
<orderEntry type="module" module-name="compilerInterfaces" />
<orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
<orderEntry type="module" module-name="codeAst" />
</component>
</module>

6
codeGenExperimental6502/src/prog8/codegen/experimental6502/AsmGen.kt
View File

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

3
codeGenTargets/codeGenTargets.iml
View File

@ -10,7 +10,8 @@
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="KotlinJavaRuntime" level="project" />
<orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
<orderEntry type="module" module-name="compilerInterfaces" />
<orderEntry type="module" module-name="codeCore" />
<orderEntry type="module" module-name="compilerAst" />
<orderEntry type="module" module-name="compilerInterfaces" />
</component>
</module>

4
codeGenTargets/src/prog8/codegen/target/AtariTarget.kt
View File

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

8
codeGenTargets/src/prog8/codegen/target/C128Target.kt
View File

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

8
codeGenTargets/src/prog8/codegen/target/C64Target.kt
View File

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

8
codeGenTargets/src/prog8/codegen/target/Cx16Target.kt
View File

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

5
codeGenTargets/src/prog8/codegen/target/Encoder.kt
View File

@ -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<UByte> {
val coded = when(encoding) {

6
codeGenTargets/src/prog8/codegen/target/cbm/AsmsubHelpers.kt
View File

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

3
codeGenTargets/src/prog8/codegen/target/cbm/CbmMemorySizer.kt
View File

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

7
codeGenTargets/src/prog8/codegen/target/cx16/CX16Zeropage.kt
View File

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

1
codeOptimizers/codeOptimizers.iml
View File

@ -11,5 +11,6 @@
<orderEntry type="library" name="KotlinJavaRuntime" level="project" />
<orderEntry type="module" module-name="compilerInterfaces" />
<orderEntry type="module" module-name="compilerAst" />
<orderEntry type="module" module-name="codeCore" />
</component>
</module>

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

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

9
codeOptimizers/src/prog8/optimizer/ConstExprEvaluator.kt
View File

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

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

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

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

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

6
codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt
View File

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

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

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

6
codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt
View File

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

3
compiler/compiler.iml
View File

@ -22,5 +22,8 @@
<orderEntry type="library" name="antlr.antlr4" level="project" />
<orderEntry type="module" module-name="codeGenCpu6502" />
<orderEntry type="module" module-name="codeGenExperimental6502" />
<orderEntry type="module" module-name="codeCore" />
<orderEntry type="module" module-name="codeAst" />
<orderEntry type="module" module-name="codeAst" />
</component>
</module>

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

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

3
compiler/src/prog8/compiler/ErrorReporter.kt
View File

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

11
compiler/src/prog8/compiler/IntermediateAstMaker.kt
View File

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

2
compiler/src/prog8/compiler/ModuleImporter.kt
View File

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

4
compiler/src/prog8/compiler/astprocessing/AstChecker.kt
View File

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

6
compiler/src/prog8/compiler/astprocessing/AstExtensions.kt
View File

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

3
compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt
View File

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

8
compiler/src/prog8/compiler/astprocessing/AstPreprocessor.kt
View File

@ -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<IAstModification> {
if(char.encoding==Encoding.DEFAULT)
if(char.encoding== Encoding.DEFAULT)
char.encoding = compTarget.defaultEncoding
return noModifications
}

4
compiler/src/prog8/compiler/astprocessing/AstVariousTransforms.kt
View File

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

5
compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt
View File

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

7
compiler/src/prog8/compiler/astprocessing/BeforeAsmTypecastCleaner.kt
View File

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

3
compiler/src/prog8/compiler/astprocessing/CodeDesugarer.kt
View File

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

4
compiler/src/prog8/compiler/astprocessing/LiteralsToAutoVars.kt
View File

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

14
compiler/src/prog8/compiler/astprocessing/StatementReorderer.kt
View File

@ -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<IAstModification> {
compTarget: ICompilationTarget
): Iterable<IAstModification> {
val noModifications = emptyList<IAstModification>()
if(callee.parameters.isEmpty()) {

1
compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt
View File

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

10
compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt
View File

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

4
compiler/src/prog8/compiler/astprocessing/VariousCleanups.kt
View File

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

6
compiler/src/prog8/compiler/astprocessing/VerifyFunctionArgTypes.kt
View File

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

7
compiler/test/TestBuiltinFunctions.kt
View File

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

6
compiler/test/TestCompilerOnCharLit.kt
View File

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

10
compiler/test/TestCompilerOnRanges.kt
View File

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

5
compiler/test/TestCompilerOptionLibdirs.kt
View File

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

10
compiler/test/TestMemory.kt
View File

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

2
compiler/test/TestNumbers.kt
View File

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

7
compiler/test/TestNumericLiteral.kt
View File

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

55
compiler/test/TestOptimization.kt
View File

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

4
compiler/test/TestPipes.kt
View File

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

1
compiler/test/TestStringEncodings.kt
View File

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

2
compiler/test/TestSubroutines.kt
View File

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

2
compiler/test/TestSymbolTable.kt
View File

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

1
compiler/test/ZeropageTests.kt
View File

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

2
compiler/test/ast/TestIdentifierRef.kt
View File

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

2
compiler/test/ast/TestIntermediateAst.kt
View File

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

6
compiler/test/ast/TestProg8Parser.kt
View File

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

2
compiler/test/ast/TestProgram.kt
View File

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

2
compiler/test/ast/TestSubroutines.kt
View File

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

2
compiler/test/ast/TestVarious.kt
View File

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

8
compiler/test/codegeneration/TestAsmGenSymbols.kt
View File

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

6
compiler/test/helpers/Dummies.kt
View File

@ -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<String> = emptySet()

2
compiler/test/helpers/ErrorReporterForTests.kt
View File

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

1
compilerAst/compilerAst.iml
View File

@ -13,5 +13,6 @@
<orderEntry type="module" module-name="parser" />
<orderEntry type="library" name="antlr.antlr4" level="project" />
<orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
<orderEntry type="module" module-name="codeCore" />
</component>
</module>

5
compilerAst/src/prog8/ast/AstToSourceTextConverter.kt
View File

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

4
compilerAst/src/prog8/ast/AstToplevel.kt
View File

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

6
compilerAst/src/prog8/ast/Extensions.kt
View File

@ -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<List<String>, VarDecl> {

2
compilerAst/src/prog8/ast/IBuiltinFunctions.kt
View File

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

5
compilerAst/src/prog8/ast/Program.kt
View File

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

5
compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt
View File

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

2
compilerAst/src/prog8/ast/antlr/EscapeChars.kt
View File

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

2
compilerAst/src/prog8/ast/base/Errors.kt
View File

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

6
compilerAst/src/prog8/ast/expressions/AstExpressions.kt
View File

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

3
compilerAst/src/prog8/ast/expressions/InferredTypes.kt
View File

@ -1,7 +1,6 @@
package prog8.ast.expressions
import prog8.ast.base.*
import prog8.compilerinterface.*
import prog8.code.core.*
import java.util.*

13
compilerAst/src/prog8/ast/statements/AstStatements.kt
View File

@ -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<Statement>,
@ -182,6 +181,12 @@ enum class VarDeclOrigin {
AUTOGENERATED
}
enum class VarDeclType {
VAR,
CONST,
MEMORY
}
class VarDecl(val type: VarDeclType,
val origin: VarDeclOrigin,

212
compilerAst/src/prog8/compilerinterface/Base.kt
View File

@ -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("<dummy>", 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
}

2
compilerAst/src/prog8/parser/Prog8Parser.kt
View File

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

Some files were not shown because too many files have changed in this diff Show More