Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2025-08-14 07:26:05 +00:00
Code Issues Projects Releases Wiki Activity

reducing dependencies

Browse Source
This commit is contained in:
Irmen de Jong
2022-03-11 19:54:30 +01:00
parent e75d0c58a9
commit e51c274a18
65 changed files with 106 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
codeAst/src/prog8/code/SymbolTable.kt
View File

@@ -4,6 +4,7 @@ package prog8.code
import prog8.code.core.DataType
import prog8.code.core.Encoding
import prog8.code.core.Position
import prog8.code.core.ZeropageWish
/**
@@ -57,15 +58,6 @@ enum class StNodeType {
BUILTINFUNC
}
// TODO assumption: replicating this here (from the Ast namespace) allows us later to have 0 dependencies on the original Ast nodes/namespace
// same for DataType? or should those things be moved into a separate module 'elementary' that contains all shared enums and classes such as Position?
enum class StZeropageWish {
REQUIRE_ZEROPAGE,
PREFER_ZEROPAGE,
DONTCARE,
NOT_IN_ZEROPAGE
}
open class StNode(val name: String,
val type: StNodeType,
@@ -161,7 +153,7 @@ class StStaticVariable(name: String,
val initialStringValue: StString?,
val initialArrayValue: StArray?,
val arraysize: Int?,
val zpw: StZeropageWish,
val zpw: ZeropageWish,
position: Position) : StNode(name, StNodeType.STATICVAR, position) {
init {

1
codeAst/src/prog8/code/ast/AstBase.kt
View File

@@ -5,7 +5,6 @@ import prog8.code.core.IStringEncoding
import prog8.code.core.Position
// New (work-in-progress) simplified AST for the code generator.
// 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()) {

1
codeCore/build.gradle
View File

@@ -25,6 +25,7 @@ compileTestKotlin {
dependencies {
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
}
sourceSets {

1
codeCore/codeCore.iml
View File

@@ -8,5 +8,6 @@
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="KotlinJavaRuntime" level="project" />
<orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
</component>
</module>

5
compilerInterfaces/src/prog8/compilerinterface/CompilationOptions.kt → codeCore/src/prog8/code/core/CompilationOptions.kt
View File

@@ -1,8 +1,5 @@
package prog8.compilerinterface
package prog8.code.core
import prog8.code.core.CbmPrgLauncherType
import prog8.code.core.OutputType
import prog8.code.core.ZeropageType
import java.nio.file.Path
import kotlin.io.path.Path

7
codeCore/src/prog8/code/core/Enumerations.kt
View File

@@ -172,3 +172,10 @@ enum class ZeropageType {
FULL,
DONTUSE
}
enum class ZeropageWish {
REQUIRE_ZEROPAGE,
PREFER_ZEROPAGE,
DONTCARE,
NOT_IN_ZEROPAGE
}

13
codeCore/src/prog8/code/core/IAssemblyGenerator.kt
View File

@@ -1,23 +1,12 @@
package prog8.code.core
import java.nio.file.Path
interface IAssemblyGenerator {
fun compileToAssembly(): IAssemblyProgram?
}
interface IAssemblyProgram {
val name: String
fun assemble(options: AssemblerOptions): Boolean
fun assemble(options: CompilationOptions): Boolean
}
fun viceMonListName(baseFilename: String) = "$baseFilename.vice-mon-list"
class AssemblerOptions(
val output: OutputType,
var asmQuiet: Boolean = false,
var asmListfile: Boolean = false,
var outputDir: Path
)

11
codeCore/src/prog8/code/core/ICompilationTarget.kt Normal file
View File

@@ -0,0 +1,11 @@
package prog8.code.core
interface ICompilationTarget: IStringEncoding, IMemSizer {
val name: String
val machine: IMachineDefinition
val supportedEncodings: Set<Encoding>
val defaultEncoding: Encoding
override fun encodeString(str: String, encoding: Encoding): List<UByte>
override fun decodeString(bytes: List<UByte>, encoding: Encoding): String
}

2
compilerInterfaces/src/prog8/compilerinterface/IMachineDefinition.kt → codeCore/src/prog8/code/core/IMachineDefinition.kt
View File

@@ -1,4 +1,4 @@
package prog8.compilerinterface
package prog8.code.core
import java.nio.file.Path

4
compilerInterfaces/src/prog8/compilerinterface/Zeropage.kt → codeCore/src/prog8/code/core/Zeropage.kt
View File

@@ -1,8 +1,8 @@
package prog8.compilerinterface
package prog8.code.core
import com.github.michaelbull.result.Result
import com.github.michaelbull.result.Err
import com.github.michaelbull.result.Ok
import com.github.michaelbull.result.Result
import prog8.code.core.*

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

@@ -70,11 +70,6 @@ class AsmGen(internal val program: Program,
internal fun isTargetCpu(cpu: CpuType) = options.compTarget.machine.cpu == cpu
internal fun haveFPWRcall() = options.compTarget.name=="cx16"
internal fun asmsubArgsEvalOrder(sub: Subroutine) =
options.compTarget.asmsubArgsEvalOrder(sub)
internal fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
options.compTarget.asmsubArgsHaveRegisterClobberRisk(args, paramRegisters)
private var generatedLabelSequenceNumber: Int = 0
internal fun makeLabel(postfix: String): String {

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

@@ -4,7 +4,7 @@ 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.code.core.IMachineDefinition
// note: see https://wiki.nesdev.org/w/index.php/6502_assembly_optimisations

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

@@ -1,4 +1,4 @@
package prog8.codegen.target.cbm
package prog8.codegen.cpu6502
import prog8.ast.expressions.ArrayIndexedExpression
import prog8.ast.expressions.BuiltinFunctionCall
@@ -9,7 +9,7 @@ import prog8.code.core.RegisterOrPair
import prog8.code.core.RegisterOrStatusflag
internal fun asmsub6502ArgsEvalOrder(sub: Subroutine): List<Int> {
fun asmsub6502ArgsEvalOrder(sub: Subroutine): List<Int> {
val order = mutableListOf<Int>()
// order is:
// 1) cx16 virtual word registers,
@@ -37,7 +37,7 @@ internal fun asmsub6502ArgsEvalOrder(sub: Subroutine): List<Int> {
return order
}
internal fun asmsub6502ArgsHaveRegisterClobberRisk(args: List<Expression>,
fun asmsub6502ArgsHaveRegisterClobberRisk(args: List<Expression>,
paramRegisters: List<RegisterOrStatusflag>): Boolean {
fun isClobberRisk(expr: Expression): Boolean {
when (expr) {

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

@@ -4,7 +4,6 @@ import com.github.michaelbull.result.Ok
import com.github.michaelbull.result.Result
import com.github.michaelbull.result.mapError
import prog8.code.core.*
import prog8.compilerinterface.*
import prog8.parser.SourceCode
import java.io.File
import java.nio.file.Path
@@ -24,7 +23,7 @@ internal class AssemblyProgram(
private val viceMonListFile = outputDir.resolve(viceMonListName(name))
private val listFile = outputDir.resolve("$name.list")
override fun assemble(options: AssemblerOptions): Boolean {
override fun assemble(options: CompilationOptions): Boolean {
val assemblerCommand: List<String>

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

@@ -4,7 +4,7 @@ import prog8.ast.Program
import prog8.ast.expressions.*
import prog8.code.core.*
import prog8.code.core.AssemblyError
import prog8.compilerinterface.CpuType
import prog8.code.core.CpuType
import kotlin.math.absoluteValue
internal class ExpressionsAsmGen(private val program: Program,

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

@@ -10,7 +10,7 @@ import prog8.code.core.DataType
import prog8.code.core.RegisterOrPair
import prog8.code.core.toHex
import prog8.code.core.AssemblyError
import prog8.compilerinterface.Zeropage
import prog8.code.core.Zeropage
import kotlin.math.absoluteValue
internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen, private val zeropage: Zeropage) {

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

@@ -133,10 +133,10 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
if(sub.parameters.size==1) {
argumentViaRegister(sub, IndexedValue(0, sub.parameters.single()), call.args[0])
} else {
if(asmgen.asmsubArgsHaveRegisterClobberRisk(call.args, sub.asmParameterRegisters)) {
if(asmsub6502ArgsHaveRegisterClobberRisk(call.args, sub.asmParameterRegisters)) {
registerArgsViaCpuStackEvaluation(call, sub)
} else {
asmgen.asmsubArgsEvalOrder(sub).forEach {
asmsub6502ArgsEvalOrder(sub).forEach {
val param = sub.parameters[it]
val arg = call.args[it]
argumentViaRegister(sub, IndexedValue(it, param), arg)
@@ -154,7 +154,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
return
// use the cpu hardware stack as intermediate storage for the arguments.
val argOrder = asmgen.options.compTarget.asmsubArgsEvalOrder(callee)
val argOrder = asmsub6502ArgsEvalOrder(callee)
argOrder.reversed().forEach {
asmgen.pushCpuStack(callee.parameters[it].type, call.args[it])
}

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

@@ -2,9 +2,11 @@ package prog8.codegen.cpu6502
import com.github.michaelbull.result.fold
import com.github.michaelbull.result.onSuccess
import prog8.code.*
import prog8.code.StNode
import prog8.code.StNodeType
import prog8.code.StStaticVariable
import prog8.code.SymbolTable
import prog8.code.core.*
import prog8.compilerinterface.*
internal class VariableAllocator(private val symboltable: SymbolTable,
@@ -51,10 +53,10 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
val allVariables = collectAllVariables(symboltable)
val numberOfAllocatableVariables = allVariables.size
val varsRequiringZp = allVariables.filter { it.zpw == StZeropageWish.REQUIRE_ZEROPAGE }
val varsPreferringZp = allVariables.filter { it.zpw == StZeropageWish.PREFER_ZEROPAGE }
val varsDontCare = allVariables.filter { it.zpw == StZeropageWish.DONTCARE }
val numberOfExplicitNonZpVariables = allVariables.count { it.zpw == StZeropageWish.NOT_IN_ZEROPAGE }
val varsRequiringZp = allVariables.filter { it.zpw == ZeropageWish.REQUIRE_ZEROPAGE }
val varsPreferringZp = allVariables.filter { it.zpw == ZeropageWish.PREFER_ZEROPAGE }
val varsDontCare = allVariables.filter { it.zpw == ZeropageWish.DONTCARE }
val numberOfExplicitNonZpVariables = allVariables.count { it.zpw == ZeropageWish.NOT_IN_ZEROPAGE }
require(varsDontCare.size + varsRequiringZp.size + varsPreferringZp.size + numberOfExplicitNonZpVariables == numberOfAllocatableVariables)
var numVariablesAllocatedInZP = 0

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

@@ -7,7 +7,7 @@ import prog8.code.core.*
import prog8.codegen.cpu6502.AsmGen
import prog8.codegen.cpu6502.VariableAllocator
import prog8.code.core.AssemblyError
import prog8.compilerinterface.CpuType
import prog8.code.core.CpuType
import prog8.compilerinterface.builtinFunctionReturnType

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

@@ -8,7 +8,7 @@ import prog8.code.core.*
import prog8.codegen.cpu6502.AsmGen
import prog8.codegen.cpu6502.VariableAllocator
import prog8.code.core.AssemblyError
import prog8.compilerinterface.CpuType
import prog8.code.core.CpuType
internal class AugmentableAssignmentAsmGen(private val program: Program,

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

@@ -2,7 +2,7 @@ package prog8.codegen.experimental6502
import prog8.code.SymbolTable
import prog8.code.ast.PtProgram
import prog8.code.core.AssemblerOptions
import prog8.code.core.CompilationOptions
import prog8.code.core.IAssemblyGenerator
import prog8.code.core.IAssemblyProgram
import prog8.code.core.IErrorReporter
@@ -20,7 +20,7 @@ import prog8.code.core.IErrorReporter
class AsmGen(internal val program: PtProgram,
internal val errors: IErrorReporter,
internal val symbolTable: SymbolTable,
internal val options: AssemblerOptions // TODO this may not be enough, maybe we actually need the other CompilationOptions as well
internal val options: CompilationOptions
): IAssemblyGenerator {
override fun compileToAssembly(): IAssemblyProgram? {

4
codeGenExperimental6502/src/prog8/codegen/experimental6502/AssemblyProgram.kt
View File

@@ -1,12 +1,12 @@
package prog8.codegen.experimental6502
import prog8.code.core.AssemblerOptions
import prog8.code.core.CompilationOptions
import prog8.code.core.IAssemblyProgram
internal class AssemblyProgram(override val name: String) : IAssemblyProgram
{
override fun assemble(options: AssemblerOptions): Boolean {
override fun assemble(options: CompilationOptions): Boolean {
println("..todo: assemble code into binary..")
return false
}

2
codeGenTargets/build.gradle
View File

@@ -25,8 +25,6 @@ compileTestKotlin {
dependencies {
implementation project(':codeCore')
implementation project(':compilerAst')
implementation project(':compilerInterfaces')
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
// implementation "org.jetbrains.kotlin:kotlin-reflect"
implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"

2
codeGenTargets/codeGenTargets.iml
View File

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

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

@@ -1,12 +1,7 @@
package prog8.codegen.target
import prog8.ast.expressions.Expression
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.ICompilationTarget
class AtariTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
@@ -19,11 +14,6 @@ class AtariTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
const val NAME = "atari"
}
override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
asmsub6502ArgsEvalOrder(sub)
override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
asmsub6502ArgsHaveRegisterClobberRisk(args, paramRegisters)
override fun memorySize(dt: DataType): Int {
return when(dt) {
in ByteDatatypes -> 1

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

@@ -1,16 +1,11 @@
package prog8.codegen.target
import prog8.ast.expressions.Expression
import prog8.ast.statements.Subroutine
import prog8.code.core.Encoding
import prog8.code.core.ICompilationTarget
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.ICompilationTarget
class C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
@@ -22,9 +17,4 @@ class C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by C
companion object {
const val NAME = "c128"
}
override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
asmsub6502ArgsEvalOrder(sub)
override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
asmsub6502ArgsHaveRegisterClobberRisk(args, paramRegisters)
}

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

@@ -1,16 +1,11 @@
package prog8.codegen.target
import prog8.ast.expressions.Expression
import prog8.ast.statements.Subroutine
import prog8.code.core.Encoding
import prog8.code.core.ICompilationTarget
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.ICompilationTarget
class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
@@ -22,9 +17,4 @@ class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by Cb
companion object {
const val NAME = "c64"
}
override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
asmsub6502ArgsEvalOrder(sub)
override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
asmsub6502ArgsHaveRegisterClobberRisk(args, paramRegisters)
}

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

@@ -1,16 +1,11 @@
package prog8.codegen.target
import prog8.ast.expressions.Expression
import prog8.ast.statements.Subroutine
import prog8.code.core.Encoding
import prog8.code.core.ICompilationTarget
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.ICompilationTarget
class Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
@@ -22,9 +17,4 @@ class Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by C
companion object {
const val NAME = "cx16"
}
override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
asmsub6502ArgsEvalOrder(sub)
override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
asmsub6502ArgsHaveRegisterClobberRisk(args, paramRegisters)
}

4
codeGenTargets/src/prog8/codegen/target/atari/AtariMachineDefinition.kt
View File

@@ -1,9 +1,7 @@
package prog8.codegen.target.atari
import prog8.code.core.CbmPrgLauncherType
import prog8.code.core.OutputType
import prog8.code.core.*
import prog8.codegen.target.c64.normal6502instructions
import prog8.compilerinterface.*
import java.nio.file.Path

4
codeGenTargets/src/prog8/codegen/target/atari/AtariZeropage.kt
View File

@@ -1,9 +1,9 @@
package prog8.codegen.target.atari
import prog8.code.core.CompilationOptions
import prog8.code.core.ZeropageType
import prog8.compilerinterface.CompilationOptions
import prog8.code.core.InternalCompilerException
import prog8.compilerinterface.Zeropage
import prog8.code.core.Zeropage
class AtariZeropage(options: CompilationOptions) : Zeropage(options) {

5
codeGenTargets/src/prog8/codegen/target/c128/C128MachineDefinition.kt
View File

@@ -1,11 +1,8 @@
package prog8.codegen.target.c128
import prog8.code.core.CbmPrgLauncherType
import prog8.code.core.OutputType
import prog8.code.core.viceMonListName
import prog8.code.core.*
import prog8.codegen.target.c64.normal6502instructions
import prog8.codegen.target.cbm.Mflpt5
import prog8.compilerinterface.*
import java.nio.file.Path

4
codeGenTargets/src/prog8/codegen/target/c128/C128Zeropage.kt
View File

@@ -1,9 +1,9 @@
package prog8.codegen.target.c128
import prog8.code.core.CompilationOptions
import prog8.code.core.ZeropageType
import prog8.compilerinterface.CompilationOptions
import prog8.code.core.InternalCompilerException
import prog8.compilerinterface.Zeropage
import prog8.code.core.Zeropage
class C128Zeropage(options: CompilationOptions) : Zeropage(options) {

5
codeGenTargets/src/prog8/codegen/target/c64/C64MachineDefinition.kt
View File

@@ -1,10 +1,7 @@
package prog8.codegen.target.c64
import prog8.code.core.CbmPrgLauncherType
import prog8.code.core.OutputType
import prog8.code.core.viceMonListName
import prog8.code.core.*
import prog8.codegen.target.cbm.Mflpt5
import prog8.compilerinterface.*
import java.io.IOException
import java.nio.file.Path

4
codeGenTargets/src/prog8/codegen/target/c64/C64Zeropage.kt
View File

@@ -1,9 +1,9 @@
package prog8.codegen.target.c64
import prog8.code.core.CompilationOptions
import prog8.code.core.ZeropageType
import prog8.compilerinterface.CompilationOptions
import prog8.code.core.InternalCompilerException
import prog8.compilerinterface.Zeropage
import prog8.code.core.Zeropage
class C64Zeropage(options: CompilationOptions) : Zeropage(options) {

2
codeGenTargets/src/prog8/codegen/target/cbm/Mflpt5.kt
View File

@@ -1,6 +1,6 @@
package prog8.codegen.target.cbm
import prog8.compilerinterface.IMachineFloat
import prog8.code.core.IMachineFloat
import prog8.code.core.InternalCompilerException
import kotlin.math.absoluteValue
import kotlin.math.pow

5
codeGenTargets/src/prog8/codegen/target/cbm/PetsciiEncoding.kt
View File

@@ -3,7 +3,6 @@ package prog8.codegen.target.cbm
import com.github.michaelbull.result.Err
import com.github.michaelbull.result.Ok
import com.github.michaelbull.result.Result
import prog8.ast.antlr.escape
import java.io.CharConversionException
object PetsciiEncoding {
@@ -1077,7 +1076,7 @@ object PetsciiEncoding {
}
else -> {
val case = if (lowercase) "lower" else "upper"
throw CharConversionException("no ${case}Petscii character for '${escape(chr.toString())}' (${chr.code})")
throw CharConversionException("no ${case}Petscii character for '${chr}' (${chr.code})")
}
}
}
@@ -1120,7 +1119,7 @@ object PetsciiEncoding {
}
else -> {
val case = if (lowercase) "lower" else "upper"
throw CharConversionException("no ${case}Screencode character for '${escape(chr.toString())}' (${chr.code})")
throw CharConversionException("no ${case}Screencode character for '${chr}' (${chr.code})")
}
}
}

5
codeGenTargets/src/prog8/codegen/target/cx16/CX16MachineDefinition.kt
View File

@@ -1,10 +1,7 @@
package prog8.codegen.target.cx16
import prog8.code.core.CbmPrgLauncherType
import prog8.code.core.OutputType
import prog8.code.core.viceMonListName
import prog8.code.core.*
import prog8.codegen.target.cbm.Mflpt5
import prog8.compilerinterface.*
import java.nio.file.Path

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

@@ -1,10 +1,6 @@
package prog8.codegen.target.cx16
import prog8.code.core.DataType
import prog8.code.core.ZeropageType
import prog8.compilerinterface.CompilationOptions
import prog8.code.core.InternalCompilerException
import prog8.compilerinterface.Zeropage
import prog8.code.core.*
class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {

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

@@ -13,13 +13,12 @@ import prog8.ast.statements.Assignment
import prog8.ast.statements.AssignmentOrigin
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.CompilationOptions
import prog8.code.core.DataType
import prog8.compilerinterface.CompilationOptions
import prog8.compilerinterface.ICompilationTarget
import prog8.compilerinterface.isIOAddress
class BinExprSplitter(private val program: Program, private val options: CompilationOptions, private val compTarget: ICompilationTarget) : AstWalker() {
class BinExprSplitter(private val program: Program, private val options: CompilationOptions) : AstWalker() {
override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
@@ -115,7 +114,7 @@ X = BinExpr X = LeftExpr
private fun isSimpleTarget(target: AssignTarget) =
if (target.identifier!=null || target.memoryAddress!=null)
!target.isIOAddress(compTarget.machine)
!target.isIOAddress(options.compTarget.machine)
else
false

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

@@ -9,7 +9,6 @@ import prog8.ast.statements.*
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.*
import prog8.compilerinterface.ICompilationTarget
import prog8.code.core.IErrorReporter
import prog8.code.core.InternalCompilerException

8
codeOptimizers/src/prog8/optimizer/Extensions.kt
View File

@@ -2,8 +2,8 @@ package prog8.optimizer
import prog8.ast.IBuiltinFunctions
import prog8.ast.Program
import prog8.compilerinterface.CompilationOptions
import prog8.compilerinterface.ICompilationTarget
import prog8.code.core.CompilationOptions
import prog8.code.core.ICompilationTarget
import prog8.code.core.IErrorReporter
@@ -60,8 +60,8 @@ fun Program.simplifyExpressions(errors: IErrorReporter) : Int {
return opti.applyModifications()
}
fun Program.splitBinaryExpressions(options: CompilationOptions, compTarget: ICompilationTarget) : Int {
val opti = BinExprSplitter(this, options, compTarget)
fun Program.splitBinaryExpressions(options: CompilationOptions) : Int {
val opti = BinExprSplitter(this, options)
opti.visit(this)
return opti.applyModifications()
}

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

@@ -5,11 +5,7 @@ import prog8.ast.expressions.*
import prog8.ast.statements.*
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.ArrayDatatypes
import prog8.code.core.DataType
import prog8.code.core.IntegerDatatypes
import prog8.compilerinterface.ICompilationTarget
import prog8.code.core.IErrorReporter
import prog8.code.core.*
import kotlin.math.floor

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

@@ -6,8 +6,8 @@ import prog8.ast.statements.*
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.DataType
import prog8.code.core.ICompilationTarget
import prog8.compilerinterface.CallGraph
import prog8.compilerinterface.ICompilationTarget
import prog8.code.core.IErrorReporter
import prog8.compilerinterface.isIOAddress

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

@@ -315,7 +315,7 @@ private fun optimizeAst(program: Program, compilerOptions: CompilationOptions, e
while (true) {
// keep optimizing expressions and statements until no more steps remain
val optsDone1 = program.simplifyExpressions(errors)
val optsDone2 = program.splitBinaryExpressions(compilerOptions, compTarget)
val optsDone2 = program.splitBinaryExpressions(compilerOptions)
val optsDone3 = program.optimizeStatements(errors, functions, compTarget)
program.constantFold(errors, compTarget) // because simplified statements and expressions can result in more constants that can be folded away
errors.report()
@@ -361,13 +361,7 @@ private fun createAssemblyAndAssemble(program: Program,
errors.report()
return if(assembly!=null && errors.noErrors()) {
val options = AssemblerOptions(
compilerOptions.output,
compilerOptions.asmQuiet,
compilerOptions.asmListfile,
compilerOptions.outputDir
)
assembly.assemble(options)
assembly.assemble(compilerOptions)
} else {
false
}
@@ -410,13 +404,7 @@ internal fun asmGeneratorFor(program: Program,
// TODO for now, only use the new Intermediary Ast for this experimental codegen:
val intermediateAst = IntermediateAstMaker(program).transform()
val asmOptions = AssemblerOptions(
options.output,
options.asmQuiet,
options.asmListfile,
options.outputDir
)
return prog8.codegen.experimental6502.AsmGen(intermediateAst, errors, symbolTable, asmOptions)
return prog8.codegen.experimental6502.AsmGen(intermediateAst, errors, symbolTable, options)
}
} else {
if (options.compTarget.machine.cpu in arrayOf(CpuType.CPU6502, CpuType.CPU65c02))

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

@@ -9,11 +9,7 @@ import prog8.ast.statements.Directive
import prog8.ast.statements.VarDeclOrigin
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.DataType
import prog8.code.core.Encoding
import prog8.compilerinterface.CompilationOptions
import prog8.compilerinterface.ICompilationTarget
import prog8.code.core.IErrorReporter
import prog8.code.core.*
internal fun Program.checkValid(errors: IErrorReporter, compilerOptions: CompilationOptions) {

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

@@ -8,15 +8,16 @@ import prog8.ast.expressions.FunctionCallExpression
import prog8.ast.expressions.StringLiteral
import prog8.ast.statements.*
import prog8.ast.walk.IAstVisitor
import prog8.code.core.ICompilationTarget
import prog8.code.core.Position
import prog8.compilerinterface.BuiltinFunctions
import prog8.compilerinterface.ICompilationTarget
import prog8.code.core.IErrorReporter
internal class AstIdentifiersChecker(private val errors: IErrorReporter,
private val program: Program,
private val compTarget: ICompilationTarget) : IAstVisitor {
private val compTarget: ICompilationTarget
) : IAstVisitor {
private var blocks = mutableMapOf<String, Block>()
private fun nameError(name: String, position: Position, existing: Statement) {

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

@@ -8,11 +8,7 @@ import prog8.ast.expressions.*
import prog8.ast.statements.*
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.Encoding
import prog8.code.core.NumericDatatypes
import prog8.compilerinterface.ICompilationTarget
import prog8.code.core.IErrorReporter
import prog8.code.core.InternalCompilerException
import prog8.code.core.*
class AstPreprocessor(val program: Program, val errors: IErrorReporter, val compTarget: ICompilationTarget) : AstWalker() {

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

@@ -13,7 +13,7 @@ import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.DataType
import prog8.code.core.Encoding
import prog8.compilerinterface.ICompilationTarget
import prog8.code.core.ICompilationTarget
import prog8.code.core.IErrorReporter

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

@@ -8,9 +8,9 @@ import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.*
import prog8.compilerinterface.BuiltinFunctions
import prog8.compilerinterface.CompilationOptions
import prog8.compilerinterface.ICompilationTarget
import prog8.code.core.IErrorReporter
import prog8.codegen.cpu6502.asmsub6502ArgsEvalOrder
import prog8.codegen.cpu6502.asmsub6502ArgsHaveRegisterClobberRisk
internal class StatementReorderer(val program: Program,
val errors: IErrorReporter,
@@ -489,7 +489,7 @@ private fun tryReplaceCallAsmSubWithGosub(call: FunctionCallStatement,
scope.statements += FunctionCallStatement(IdentifierReference(listOf("rrestorex"), call.position), mutableListOf(), true, call.position)
}
return listOf(IAstModification.ReplaceNode(call, scope, parent))
} else if(!compTarget.asmsubArgsHaveRegisterClobberRisk(call.args, callee.asmParameterRegisters)) {
} else if(!asmsub6502ArgsHaveRegisterClobberRisk(call.args, callee.asmParameterRegisters)) {
// No register clobber risk, let the asmgen assign values to the registers directly.
// this is more efficient than first evaluating them to the stack.
// As complex expressions will be flagged as a clobber-risk, these will be simplified below.
@@ -530,7 +530,7 @@ private fun makeGosubWithArgsViaCpuStack(call: IFunctionCall,
)
}
val argOrder = compTarget.asmsubArgsEvalOrder(callee)
val argOrder = asmsub6502ArgsEvalOrder(callee)
val scope = AnonymousScope(mutableListOf(), position)
if(callee.shouldSaveX()) {
scope.statements += FunctionCallStatement(IdentifierReference(listOf("rsavex"), position), mutableListOf(), true, position)

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

@@ -52,7 +52,7 @@ internal class SymbolTableMaker: IAstVisitor {
val initialString = if(initialStringLit==null) null else Pair(initialStringLit.value, initialStringLit.encoding)
val initialArrayLit = decl.value as? ArrayLiteral
val initialArray = makeInitialArray(initialArrayLit)
StStaticVariable(decl.name, decl.datatype, initialNumeric, initialString, initialArray, decl.arraysize?.constIndex(), map(decl.zeropage), decl.position)
StStaticVariable(decl.name, decl.datatype, initialNumeric, initialString, initialArray, decl.arraysize?.constIndex(), decl.zeropage, decl.position)
}
VarDeclType.CONST -> StConstant(decl.name, decl.datatype, (decl.value as NumericLiteral).number, decl.position)
VarDeclType.MEMORY -> StMemVar(decl.name, decl.datatype, (decl.value as NumericLiteral).number.toUInt(), decl.position)
@@ -61,13 +61,6 @@ internal class SymbolTableMaker: IAstVisitor {
// st.origAstLinks[decl] = node
}
private fun map(zpw: ZeropageWish): StZeropageWish = when(zpw) {
ZeropageWish.REQUIRE_ZEROPAGE -> StZeropageWish.REQUIRE_ZEROPAGE
ZeropageWish.PREFER_ZEROPAGE -> StZeropageWish.PREFER_ZEROPAGE
ZeropageWish.DONTCARE -> StZeropageWish.DONTCARE
ZeropageWish.NOT_IN_ZEROPAGE -> StZeropageWish.NOT_IN_ZEROPAGE
}
private fun makeInitialArray(arrayLit: ArrayLiteral?): StArray? {
if(arrayLit==null)
return null

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

@@ -8,13 +8,8 @@ import prog8.ast.expressions.*
import prog8.ast.statements.*
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.ArrayDatatypes
import prog8.code.core.DataType
import prog8.code.core.IterableDatatypes
import prog8.code.core.PassByReferenceDatatypes
import prog8.code.core.*
import prog8.compilerinterface.BuiltinFunctions
import prog8.compilerinterface.CompilationOptions
import prog8.code.core.IErrorReporter
class TypecastsAdder(val program: Program, val options: CompilationOptions, val errors: IErrorReporter) : AstWalker() {

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

@@ -12,8 +12,8 @@ import prog8.ast.statements.FunctionCallStatement
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.ArrayDatatypes
import prog8.code.core.CompilationOptions
import prog8.code.core.DataType
import prog8.compilerinterface.CompilationOptions
import prog8.code.core.IErrorReporter

2
compiler/test/TestCompilerOnExamples.kt
View File

@@ -2,12 +2,12 @@ package prog8tests
import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.shouldNotBe
import prog8.code.core.ICompilationTarget
import prog8.codegen.target.C64Target
import prog8.codegen.target.Cx16Target
import prog8.compiler.CompilationResult
import prog8.compiler.CompilerArguments
import prog8.compiler.compileProgram
import prog8.compilerinterface.ICompilationTarget
import prog8tests.helpers.assumeDirectory
import prog8tests.helpers.cartesianProduct
import prog8tests.helpers.outputDir

1
compiler/test/TestMemory.kt
View File

@@ -12,6 +12,7 @@ import prog8.ast.expressions.PrefixExpression
import prog8.ast.statements.*
import prog8.code.core.DataType
import prog8.code.core.Position
import prog8.code.core.ZeropageWish
import prog8.codegen.target.C64Target
import prog8.compiler.printProgram
import prog8.compilerinterface.isIOAddress

1
compiler/test/TestOptimization.kt
View File

@@ -17,7 +17,6 @@ import prog8.code.core.*
import prog8.codegen.target.C64Target
import prog8.compiler.astprocessing.processAstBeforeAsmGeneration
import prog8.compiler.printProgram
import prog8.compilerinterface.CompilationOptions
import prog8tests.helpers.*

9
compiler/test/TestSymbolTable.kt
View File

@@ -7,6 +7,7 @@ import io.kotest.matchers.shouldNotBe
import prog8.code.*
import prog8.code.core.DataType
import prog8.code.core.Position
import prog8.code.core.ZeropageWish
class TestSymbolTable: FunSpec({
test("empty symboltable") {
@@ -77,10 +78,10 @@ private fun makeSt(): SymbolTable {
block1.add(sub12)
block1.add(StConstant("c1", DataType.UWORD, 12345.0, Position.DUMMY))
block1.add(StConstant("blockc", DataType.UWORD, 999.0, Position.DUMMY))
sub11.add(StStaticVariable("v1", DataType.BYTE, null, null, null, null, StZeropageWish.DONTCARE, Position.DUMMY))
sub11.add(StStaticVariable("v2", DataType.BYTE, null, null, null, null, StZeropageWish.DONTCARE, Position.DUMMY))
sub12.add(StStaticVariable("v1", DataType.BYTE, null, null, null, null, StZeropageWish.DONTCARE, Position.DUMMY))
sub12.add(StStaticVariable("v2", DataType.BYTE, null, null, null, null, StZeropageWish.DONTCARE, Position.DUMMY))
sub11.add(StStaticVariable("v1", DataType.BYTE, null, null, null, null, ZeropageWish.DONTCARE, Position.DUMMY))
sub11.add(StStaticVariable("v2", DataType.BYTE, null, null, null, null, ZeropageWish.DONTCARE, Position.DUMMY))
sub12.add(StStaticVariable("v1", DataType.BYTE, null, null, null, null, ZeropageWish.DONTCARE, Position.DUMMY))
sub12.add(StStaticVariable("v2", DataType.BYTE, null, null, null, null, ZeropageWish.DONTCARE, Position.DUMMY))
val block2 = StNode("block2", StNodeType.BLOCK, Position.DUMMY)
val sub21 = StNode("sub1", StNodeType.SUBROUTINE, Position.DUMMY)

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

@@ -20,6 +20,7 @@ import prog8.ast.statements.*
import prog8.code.core.DataType
import prog8.code.core.Encoding
import prog8.code.core.Position
import prog8.code.core.ZeropageWish
import prog8.codegen.target.C64Target
import prog8.codegen.target.cbm.PetsciiEncoding
import prog8.parser.ParseError

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

@@ -13,7 +13,6 @@ import prog8.codegen.cpu6502.AsmGen
import prog8.codegen.target.C64Target
import prog8.codegen.target.c64.C64Zeropage
import prog8.compiler.astprocessing.SymbolTableMaker
import prog8.compilerinterface.CompilationOptions
import prog8.parser.SourceCode
import prog8tests.helpers.DummyFunctions
import prog8tests.helpers.DummyMemsizer

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

@@ -6,8 +6,7 @@ import prog8.ast.expressions.InferredTypes
import prog8.ast.expressions.NumericLiteral
import prog8.ast.statements.Subroutine
import prog8.code.core.*
import prog8.compilerinterface.ICompilationTarget
import prog8.compilerinterface.IMachineDefinition
import prog8.code.core.IMachineDefinition
internal object DummyFunctions : IBuiltinFunctions {
@@ -59,15 +58,6 @@ internal object DummyCompilationTarget : ICompilationTarget {
throw NotImplementedError("dummy")
}
override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> {
throw NotImplementedError("dummy")
}
override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>,
paramRegisters: List<RegisterOrStatusflag>): Boolean {
throw NotImplementedError("dummy")
}
override fun memorySize(dt: DataType): Int {
throw NotImplementedError("dummy")
}

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

@@ -4,10 +4,7 @@ import prog8.ast.antlr.escape
import prog8.ast.expressions.*
import prog8.ast.statements.*
import prog8.ast.walk.IAstVisitor
import prog8.code.core.DataType
import prog8.code.core.Encoding
import prog8.code.core.NumericDatatypes
import prog8.code.core.toHex
import prog8.code.core.*
/**

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

@@ -5,9 +5,9 @@ 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.code.core.DataType
import prog8.code.core.Position
import prog8.code.core.ZeropageWish
fun Program.getTempVar(dt: DataType, altNames: Boolean=false): Pair<List<String>, VarDecl> {

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

@@ -5,10 +5,7 @@ import prog8.ast.expressions.IdentifierReference
import prog8.ast.expressions.StringLiteral
import prog8.ast.statements.*
import prog8.ast.walk.IAstVisitor
import prog8.code.core.DataType
import prog8.code.core.IMemSizer
import prog8.code.core.IStringEncoding
import prog8.code.core.Position
import prog8.code.core.*
import prog8.parser.SourceCode
/*********** Everything starts from here, the Program; zero or more modules *************/

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

@@ -166,13 +166,6 @@ class Break(override val position: Position) : Statement() {
}
enum class ZeropageWish {
REQUIRE_ZEROPAGE,
PREFER_ZEROPAGE,
DONTCARE,
NOT_IN_ZEROPAGE
}
enum class VarDeclOrigin {
USERCODE,
SUBROUTINEPARAM,

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

@@ -5,6 +5,7 @@ import prog8.ast.expressions.IdentifierReference
import prog8.ast.expressions.NumericLiteral
import prog8.ast.statements.AssignTarget
import prog8.ast.statements.VarDeclType
import prog8.code.core.IMachineDefinition
fun AssignTarget.isIOAddress(machine: IMachineDefinition): Boolean {
val memAddr = memoryAddress

23
compilerInterfaces/src/prog8/compilerinterface/ICompilationTarget.kt
View File

@@ -1,23 +0,0 @@
package prog8.compilerinterface
import prog8.ast.expressions.Expression
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 {
val name: String
val machine: IMachineDefinition
val supportedEncodings: Set<Encoding>
val defaultEncoding: Encoding
override fun encodeString(str: String, encoding: Encoding): List<UByte>
override fun decodeString(bytes: List<UByte>, encoding: Encoding): String
fun asmsubArgsEvalOrder(sub: Subroutine): List<Int>
fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>,
paramRegisters: List<RegisterOrStatusflag>): Boolean
}