From 9bb5b454e4a3254e5f622ce1342d1ecf545811ed Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Thu, 18 Feb 2021 23:44:26 +0100 Subject: [PATCH] reduce dependencies on global compilaiontarget --- compiler/res/prog8lib/cx16/gfx2.p8 | 2 +- compiler/src/prog8/CompilerMain.kt | 3 +-- compiler/src/prog8/compiler/Compiler.kt | 19 +++++++++--------- .../compiler/target/ICompilationTarget.kt | 2 +- .../compiler/target/IMachineDefinition.kt | 6 +++--- .../c64/codegen/BuiltinFunctionsAsmGen.kt | 15 +++++++------- .../target/c64/codegen/FunctionCallAsmGen.kt | 2 +- .../c64/codegen/assignment/AsmAssignment.kt | 3 ++- .../codegen/assignment/AssignmentAsmGen.kt | 10 ++++----- .../assignment/AugmentableAssignmentAsmGen.kt | 6 +++--- .../src/prog8/optimizer/BinExprSplitter.kt | 4 ++-- .../optimizer/ConstantFoldingOptimizer.kt | 4 ++-- .../optimizer/ConstantIdentifierReplacer.kt | 4 ++-- compiler/src/prog8/optimizer/Extensions.kt | 15 +++++++------- .../src/prog8/optimizer/StatementOptimizer.kt | 9 +++++---- .../src/prog8/optimizer/UnusedCodeRemover.kt | 4 ++-- examples/cx16/vtui/VTUI0.3.BIN | Bin 935 -> 0 bytes examples/cx16/vtui/VTUI0.4.BIN | Bin 0 -> 940 bytes 18 files changed, 55 insertions(+), 53 deletions(-) delete mode 100644 examples/cx16/vtui/VTUI0.3.BIN create mode 100644 examples/cx16/vtui/VTUI0.4.BIN diff --git a/compiler/res/prog8lib/cx16/gfx2.p8 b/compiler/res/prog8lib/cx16/gfx2.p8 index 6e7868662..b075a292b 100644 --- a/compiler/res/prog8lib/cx16/gfx2.p8 +++ b/compiler/res/prog8lib/cx16/gfx2.p8 @@ -19,7 +19,7 @@ ; mode 3 = bitmap 320 x 240 x 16c (unsupported TODO not yet implemented) ; mode 4 = bitmap 320 x 240 x 256c ; mode 5 = bitmap 640 x 480 monochrome -; mode 6 = bitmap 640 x 480 x 4c (unsupported TODO being implemented) +; mode 6 = bitmap 640 x 480 x 4c ; mode 7 = bitmap 640 x 480 x 16c (unsupported due to lack of VRAM) ; mode 8 = bitmap 640 x 480 x 256c (unsupported due to lack of VRAM) diff --git a/compiler/src/prog8/CompilerMain.kt b/compiler/src/prog8/CompilerMain.kt index aa559280c..64c5c443c 100644 --- a/compiler/src/prog8/CompilerMain.kt +++ b/compiler/src/prog8/CompilerMain.kt @@ -8,7 +8,6 @@ import prog8.ast.base.AstException import prog8.compiler.CompilationResult import prog8.compiler.compileProgram import prog8.compiler.target.C64Target -import prog8.compiler.target.ICompilationTarget import prog8.compiler.target.Cx16Target import prog8.parser.ParsingFailedError import java.nio.file.FileSystems @@ -117,7 +116,7 @@ private fun compileMain(args: Array) { if (compilationResult.programName.isEmpty()) println("\nCan't start emulator because no program was assembled.") else { - ICompilationTarget.instance.machine.launchEmulator(compilationResult.programName) + compilationResult.compTarget.machine.launchEmulator(compilationResult.programName) } } } diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt index c43e38653..b63d320fe 100644 --- a/compiler/src/prog8/compiler/Compiler.kt +++ b/compiler/src/prog8/compiler/Compiler.kt @@ -59,6 +59,7 @@ class CompilerException(message: String?) : Exception(message) class CompilationResult(val success: Boolean, val programAst: Program, val programName: String, + val compTarget: ICompilationTarget, val importedFiles: List) @@ -92,7 +93,7 @@ fun compileProgram(filepath: Path, importedFiles = imported processAst(programAst, errors, compilationOptions, ICompilationTarget.instance) if (compilationOptions.optimize) - optimizeAst(programAst, errors, BuiltinFunctionsFacade(BuiltinFunctions)) + optimizeAst(programAst, errors, BuiltinFunctionsFacade(BuiltinFunctions), ICompilationTarget.instance) postprocessAst(programAst, errors, compilationOptions, ICompilationTarget.instance) // printAst(programAst) @@ -103,7 +104,7 @@ fun compileProgram(filepath: Path, System.out.flush() System.err.flush() println("\nTotal compilation+assemble time: ${totalTime / 1000.0} sec.") - return CompilationResult(true, programAst, programName, importedFiles) + return CompilationResult(true, programAst, programName, ICompilationTarget.instance, importedFiles) } catch (px: ParsingFailedError) { System.err.print("\u001b[91m") // bright red @@ -128,7 +129,7 @@ fun compileProgram(filepath: Path, } val failedProgram = Program("failed", mutableListOf(), BuiltinFunctionsFacade(BuiltinFunctions)) - return CompilationResult(false, failedProgram, programName, emptyList()) + return CompilationResult(false, failedProgram, programName, ICompilationTarget.instance, emptyList()) } private class BuiltinFunctionsFacade(functions: Map): IBuiltinFunctions { @@ -242,7 +243,7 @@ private fun processAst(programAst: Program, errors: ErrorReporter, compilerOptio println("Processing for target ${compTarget.name}...") programAst.checkIdentifiers(errors, compTarget) errors.handle() - programAst.constantFold(errors) + programAst.constantFold(errors, compTarget) errors.handle() programAst.reorderStatements(errors) errors.handle() @@ -255,21 +256,21 @@ private fun processAst(programAst: Program, errors: ErrorReporter, compilerOptio errors.handle() } -private fun optimizeAst(programAst: Program, errors: ErrorReporter, functions: IBuiltinFunctions) { +private fun optimizeAst(programAst: Program, errors: ErrorReporter, functions: IBuiltinFunctions, compTarget: ICompilationTarget) { // optimize the parse tree println("Optimizing...") while (true) { // keep optimizing expressions and statements until no more steps remain val optsDone1 = programAst.simplifyExpressions() - val optsDone2 = programAst.splitBinaryExpressions() - val optsDone3 = programAst.optimizeStatements(errors, functions) - programAst.constantFold(errors) // because simplified statements and expressions can result in more constants that can be folded away + val optsDone2 = programAst.splitBinaryExpressions(compTarget) + val optsDone3 = programAst.optimizeStatements(errors, functions, compTarget) + programAst.constantFold(errors, compTarget) // because simplified statements and expressions can result in more constants that can be folded away errors.handle() if (optsDone1 + optsDone2 + optsDone3 == 0) break } - val remover = UnusedCodeRemover(programAst, errors) + val remover = UnusedCodeRemover(programAst, errors, compTarget) remover.visit(programAst) remover.applyModifications() errors.handle() diff --git a/compiler/src/prog8/compiler/target/ICompilationTarget.kt b/compiler/src/prog8/compiler/target/ICompilationTarget.kt index 895c02784..e82770cf0 100644 --- a/compiler/src/prog8/compiler/target/ICompilationTarget.kt +++ b/compiler/src/prog8/compiler/target/ICompilationTarget.kt @@ -16,7 +16,7 @@ import prog8.compiler.target.cx16.CX16MachineDefinition import java.nio.file.Path -internal interface ICompilationTarget: IStringEncoding { +interface ICompilationTarget: IStringEncoding { val name: String val machine: IMachineDefinition override fun encodeString(str: String, altEncoding: Boolean): List diff --git a/compiler/src/prog8/compiler/target/IMachineDefinition.kt b/compiler/src/prog8/compiler/target/IMachineDefinition.kt index b8d8b5b27..ffc953c2c 100644 --- a/compiler/src/prog8/compiler/target/IMachineDefinition.kt +++ b/compiler/src/prog8/compiler/target/IMachineDefinition.kt @@ -4,17 +4,17 @@ import prog8.compiler.CompilationOptions import prog8.compiler.Zeropage -internal interface IMachineFloat { +interface IMachineFloat { fun toDouble(): Double fun makeFloatFillAsm(): String } -internal enum class CpuType { +enum class CpuType { CPU6502, CPU65c02 } -internal interface IMachineDefinition { +interface IMachineDefinition { val FLOAT_MAX_NEGATIVE: Double val FLOAT_MAX_POSITIVE: Double val FLOAT_MEM_SIZE: Int diff --git a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt index 438fbeaeb..7b6a0e8dd 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt @@ -68,7 +68,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val private fun funcMemory(fcall: IFunctionCall, discardResult: Boolean, resultToStack: Boolean, resultRegister: RegisterOrPair?) { if(discardResult || fcall !is FunctionCall) throw AssemblyError("should not discard result of memory allocation at $fcall") - val scope = fcall.definingScope() val nameRef = fcall.args[0] as IdentifierReference val name = (nameRef.targetVarDecl(program)!!.value as StringLiteralValue).value val size = (fcall.args[1] as NumericLiteralValue).number.toInt() @@ -85,7 +84,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val AsmAssignTarget(TargetStorageKind.STACK, program, asmgen, DataType.UWORD, null) else AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, null, program, asmgen) - val assign = AsmAssignment(src, target, false, fcall.position) + val assign = AsmAssignment(src, target, false, asmgen.compTarget, fcall.position) asmgen.translateNormalAssignment(assign) asmgen.slabs[name] = size } @@ -647,12 +646,12 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val val assignFirst = AsmAssignment( AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, datatype, variableAsmName = "P8ZP_SCRATCH_W2"), targetFromExpr(first, datatype), - false, first.position + false, asmgen.compTarget, first.position ) val assignSecond = AsmAssignment( AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, datatype, variableAsmName = "P8ZP_SCRATCH_W1"), targetFromExpr(second, datatype), - false, second.position + false, asmgen.compTarget, second.position ) asmgen.translateNormalAssignment(assignFirst) asmgen.translateNormalAssignment(assignSecond) @@ -664,12 +663,12 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val val assignFirst = AsmAssignment( AsmAssignSource(SourceStorageKind.STACK, program, asmgen, DataType.FLOAT), targetFromExpr(first, datatype), - false, first.position + false, asmgen.compTarget, first.position ) val assignSecond = AsmAssignment( AsmAssignSource(SourceStorageKind.STACK, program, asmgen, DataType.FLOAT), targetFromExpr(second, datatype), - false, second.position + false, asmgen.compTarget, second.position ) asmgen.translateNormalAssignment(assignFirst) asmgen.translateNormalAssignment(assignSecond) @@ -1288,7 +1287,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } } val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, conv.dt, null, variableAsmName = varname) - val assign = AsmAssignment(src, tgt, false, value.position) + val assign = AsmAssignment(src, tgt, false, asmgen.compTarget, value.position) asmgen.translateNormalAssignment(assign) } conv.reg != null -> { @@ -1304,7 +1303,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } } val tgt = AsmAssignTarget.fromRegisters(conv.reg, null, program, asmgen) - val assign = AsmAssignment(src, tgt, false, value.position) + val assign = AsmAssignment(src, tgt, false, asmgen.compTarget, value.position) asmgen.translateNormalAssignment(assign) } else -> throw AssemblyError("callconv") diff --git a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt index b583ebae1..241200804 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt @@ -318,7 +318,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg } else { AsmAssignSource.fromAstSource(value, program, asmgen).adjustSignedUnsigned(target) } - asmgen.translateNormalAssignment(AsmAssignment(src, target, false, Position.DUMMY)) + asmgen.translateNormalAssignment(AsmAssignment(src, target, false, asmgen.compTarget, Position.DUMMY)) } } } diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt index 503d2c88a..c9ff496a0 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt @@ -207,12 +207,13 @@ internal class AsmAssignSource(val kind: SourceStorageKind, internal class AsmAssignment(val source: AsmAssignSource, val target: AsmAssignTarget, val isAugmentable: Boolean, + compTarget: ICompilationTarget, val position: Position) { init { if(target.register !in setOf(RegisterOrPair.XY, RegisterOrPair.AX, RegisterOrPair.AY)) require(source.datatype != DataType.STRUCT) { "must not be placeholder datatype" } - require(ICompilationTarget.instance.memorySize(source.datatype) <= ICompilationTarget.instance.memorySize(target.datatype)) { + require(compTarget.memorySize(source.datatype) <= compTarget.memorySize(target.datatype)) { "source storage size must be less or equal to target datatype storage size" } } diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt index 9bc42c524..54056df8d 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt @@ -22,7 +22,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen val target = AsmAssignTarget.fromAstAssignment(assignment, program, asmgen) val source = AsmAssignSource.fromAstSource(assignment.value, program, asmgen).adjustSignedUnsigned(target) - val assign = AsmAssignment(source, target, assignment.isAugmentable, assignment.position) + val assign = AsmAssignment(source, target, assignment.isAugmentable, asmgen.compTarget, assignment.position) target.origAssign = assign if(assign.isAugmentable) @@ -441,7 +441,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen val lsb = FunctionCall(IdentifierReference(listOf("lsb"), value.position), mutableListOf(value), value.position) lsb.linkParents(value.parent) val src = AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, DataType.UBYTE, expression = lsb) - val assign = AsmAssignment(src, target, false, value.position) + val assign = AsmAssignment(src, target, false, asmgen.compTarget, value.position) translateNormalAssignment(assign) } @@ -2109,21 +2109,21 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen internal fun assignExpressionToRegister(expr: Expression, register: RegisterOrPair) { val src = AsmAssignSource.fromAstSource(expr, program, asmgen) val tgt = AsmAssignTarget.fromRegisters(register, null, program, asmgen) - val assign = AsmAssignment(src, tgt, false, expr.position) + val assign = AsmAssignment(src, tgt, false, asmgen.compTarget, expr.position) translateNormalAssignment(assign) } internal fun assignExpressionToVariable(expr: Expression, asmVarName: String, dt: DataType, scope: Subroutine?) { val src = AsmAssignSource.fromAstSource(expr, program, asmgen) val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, dt, scope, variableAsmName = asmVarName) - val assign = AsmAssignment(src, tgt, false, expr.position) + val assign = AsmAssignment(src, tgt, false, asmgen.compTarget, expr.position) translateNormalAssignment(assign) } internal fun assignVariableToRegister(asmVarName: String, register: RegisterOrPair) { val tgt = AsmAssignTarget.fromRegisters(register, null, program, asmgen) val src = AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, tgt.datatype, variableAsmName = asmVarName) - val assign = AsmAssignment(src, tgt, false, Position.DUMMY) + val assign = AsmAssignment(src, tgt, false, asmgen.compTarget, Position.DUMMY) translateNormalAssignment(assign) } } diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt index 91007b899..582196878 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt @@ -245,19 +245,19 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, when(target.datatype) { in ByteDatatypes -> { val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.A, null, program, asmgen) - val assign = AsmAssignment(target.origAssign.source, tgt, false, value.position) + val assign = AsmAssignment(target.origAssign.source, tgt, false, asmgen.compTarget, value.position) assignmentAsmGen.translateNormalAssignment(assign) assignmentAsmGen.assignRegisterByte(target, CpuRegister.A) } in WordDatatypes -> { val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen) - val assign = AsmAssignment(target.origAssign.source, tgt, false, value.position) + val assign = AsmAssignment(target.origAssign.source, tgt, false, asmgen.compTarget, value.position) assignmentAsmGen.translateNormalAssignment(assign) assignmentAsmGen.assignRegisterpairWord(target, RegisterOrPair.AY) } DataType.FLOAT -> { val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.FAC1, null, program, asmgen) - val assign = AsmAssignment(target.origAssign.source, tgt, false, value.position) + val assign = AsmAssignment(target.origAssign.source, tgt, false, asmgen.compTarget, value.position) assignmentAsmGen.translateNormalAssignment(assign) assignmentAsmGen.assignFAC1float(target) } diff --git a/compiler/src/prog8/optimizer/BinExprSplitter.kt b/compiler/src/prog8/optimizer/BinExprSplitter.kt index 517768a65..423ea23af 100644 --- a/compiler/src/prog8/optimizer/BinExprSplitter.kt +++ b/compiler/src/prog8/optimizer/BinExprSplitter.kt @@ -10,7 +10,7 @@ import prog8.ast.walk.IAstModification import prog8.compiler.target.ICompilationTarget -internal class BinExprSplitter(private val program: Program) : AstWalker() { +internal class BinExprSplitter(private val program: Program, private val compTarget: ICompilationTarget) : AstWalker() { private val noModifications = emptyList() // override fun after(decl: VarDecl, parent: Node): Iterable { @@ -80,7 +80,7 @@ X = BinExpr X = LeftExpr private fun isSimpleTarget(target: AssignTarget, program: Program) = if (target.identifier!=null || target.memoryAddress!=null) - ICompilationTarget.instance.isInRegularRAM(target, program) + compTarget.isInRegularRAM(target, program) else false diff --git a/compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt b/compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt index 372425c93..ed8dad11f 100644 --- a/compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt +++ b/compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt @@ -13,7 +13,7 @@ import prog8.compiler.target.ICompilationTarget import kotlin.math.pow -internal class ConstantFoldingOptimizer(private val program: Program) : AstWalker() { +internal class ConstantFoldingOptimizer(private val program: Program, private val compTarget: ICompilationTarget) : AstWalker() { private val noModifications = emptyList() override fun before(memread: DirectMemoryRead, parent: Node): Iterable { @@ -224,7 +224,7 @@ internal class ConstantFoldingOptimizer(private val program: Program) : AstWalke range.step } - return RangeExpr(fromCast.valueOrZero(), toCast.valueOrZero(), newStep, ICompilationTarget.instance, range.position) + return RangeExpr(fromCast.valueOrZero(), toCast.valueOrZero(), newStep, compTarget, range.position) } // adjust the datatype of a range expression in for loops to the loop variable. diff --git a/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt b/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt index c03349fec..6b0b14e7b 100644 --- a/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt +++ b/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt @@ -39,7 +39,7 @@ internal class VarConstantValueTypeAdjuster(private val program: Program, privat // Replace all constant identifiers with their actual value, // and the array var initializer values and sizes. // This is needed because further constant optimizations depend on those. -internal class ConstantIdentifierReplacer(private val program: Program, private val errors: ErrorReporter) : AstWalker() { +internal class ConstantIdentifierReplacer(private val program: Program, private val errors: ErrorReporter, private val compTarget: ICompilationTarget) : AstWalker() { private val noModifications = emptyList() override fun after(identifier: IdentifierReference, parent: Node): Iterable { @@ -192,7 +192,7 @@ internal class ConstantIdentifierReplacer(private val program: Program, private if(rangeExpr==null && litval!=null) { // arraysize initializer is a single int, and we know the size. val fillvalue = litval.number.toDouble() - if (fillvalue < ICompilationTarget.instance.machine.FLOAT_MAX_NEGATIVE || fillvalue > ICompilationTarget.instance.machine.FLOAT_MAX_POSITIVE) + if (fillvalue < compTarget.machine.FLOAT_MAX_NEGATIVE || fillvalue > compTarget.machine.FLOAT_MAX_POSITIVE) errors.err("float value overflow", litval.position) else { // create the array itself, filled with the fillvalue. diff --git a/compiler/src/prog8/optimizer/Extensions.kt b/compiler/src/prog8/optimizer/Extensions.kt index b4e0f1a8e..dad862b76 100644 --- a/compiler/src/prog8/optimizer/Extensions.kt +++ b/compiler/src/prog8/optimizer/Extensions.kt @@ -3,15 +3,16 @@ package prog8.optimizer import prog8.ast.IBuiltinFunctions import prog8.ast.Program import prog8.compiler.ErrorReporter +import prog8.compiler.target.ICompilationTarget -internal fun Program.constantFold(errors: ErrorReporter) { +internal fun Program.constantFold(errors: ErrorReporter, compTarget: ICompilationTarget) { val valuetypefixer = VarConstantValueTypeAdjuster(this, errors) valuetypefixer.visit(this) if(errors.isEmpty()) { valuetypefixer.applyModifications() - val replacer = ConstantIdentifierReplacer(this, errors) + val replacer = ConstantIdentifierReplacer(this, errors, compTarget) replacer.visit(this) if (errors.isEmpty()) { replacer.applyModifications() @@ -20,7 +21,7 @@ internal fun Program.constantFold(errors: ErrorReporter) { if(errors.isEmpty()) { valuetypefixer.applyModifications() - val optimizer = ConstantFoldingOptimizer(this) + val optimizer = ConstantFoldingOptimizer(this, compTarget) optimizer.visit(this) while (errors.isEmpty() && optimizer.applyModifications() > 0) { optimizer.visit(this) @@ -39,8 +40,8 @@ internal fun Program.constantFold(errors: ErrorReporter) { } -internal fun Program.optimizeStatements(errors: ErrorReporter, functions: IBuiltinFunctions): Int { - val optimizer = StatementOptimizer(this, errors, functions) +internal fun Program.optimizeStatements(errors: ErrorReporter, functions: IBuiltinFunctions, compTarget: ICompilationTarget): Int { + val optimizer = StatementOptimizer(this, errors, functions, compTarget) optimizer.visit(this) val optimizationCount = optimizer.applyModifications() @@ -55,8 +56,8 @@ internal fun Program.simplifyExpressions() : Int { return opti.applyModifications() } -internal fun Program.splitBinaryExpressions() : Int { - val opti = BinExprSplitter(this) +internal fun Program.splitBinaryExpressions(compTarget: ICompilationTarget) : Int { + val opti = BinExprSplitter(this, compTarget) opti.visit(this) return opti.applyModifications() } diff --git a/compiler/src/prog8/optimizer/StatementOptimizer.kt b/compiler/src/prog8/optimizer/StatementOptimizer.kt index d8d1954db..a58da52fa 100644 --- a/compiler/src/prog8/optimizer/StatementOptimizer.kt +++ b/compiler/src/prog8/optimizer/StatementOptimizer.kt @@ -17,7 +17,8 @@ import kotlin.math.floor internal class StatementOptimizer(private val program: Program, private val errors: ErrorReporter, - private val functions: IBuiltinFunctions + private val functions: IBuiltinFunctions, + private val compTarget: ICompilationTarget ) : AstWalker() { private val noModifications = emptyList() @@ -96,7 +97,7 @@ internal class StatementOptimizer(private val program: Program, if(string!=null) { val pos = functionCallStatement.position if (string.value.length == 1) { - val firstCharEncoded = ICompilationTarget.instance.encodeString(string.value, string.altEncoding)[0] + val firstCharEncoded = compTarget.encodeString(string.value, string.altEncoding)[0] val chrout = FunctionCallStatement( IdentifierReference(listOf("txt", "chrout"), pos), mutableListOf(NumericLiteralValue(DataType.UBYTE, firstCharEncoded.toInt(), pos)), @@ -104,7 +105,7 @@ internal class StatementOptimizer(private val program: Program, ) return listOf(IAstModification.ReplaceNode(functionCallStatement, chrout, parent)) } else if (string.value.length == 2) { - val firstTwoCharsEncoded = ICompilationTarget.instance.encodeString(string.value.take(2), string.altEncoding) + val firstTwoCharsEncoded = compTarget.encodeString(string.value.take(2), string.altEncoding) val chrout1 = FunctionCallStatement( IdentifierReference(listOf("txt", "chrout"), pos), mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[0].toInt(), pos)), @@ -212,7 +213,7 @@ internal class StatementOptimizer(private val program: Program, val size = sv.value.length if(size==1) { // loop over string of length 1 -> just assign the single character - val character = ICompilationTarget.instance.encodeString(sv.value, sv.altEncoding)[0] + val character = compTarget.encodeString(sv.value, sv.altEncoding)[0] val byte = NumericLiteralValue(DataType.UBYTE, character, iterable.position) val scope = AnonymousScope(mutableListOf(), forLoop.position) scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), byte, forLoop.position)) diff --git a/compiler/src/prog8/optimizer/UnusedCodeRemover.kt b/compiler/src/prog8/optimizer/UnusedCodeRemover.kt index 5beac5e7c..a5d69d838 100644 --- a/compiler/src/prog8/optimizer/UnusedCodeRemover.kt +++ b/compiler/src/prog8/optimizer/UnusedCodeRemover.kt @@ -14,7 +14,7 @@ import prog8.ast.walk.IAstModification import prog8.compiler.target.ICompilationTarget -internal class UnusedCodeRemover(private val program: Program, private val errors: ErrorReporter): AstWalker() { +internal class UnusedCodeRemover(private val program: Program, private val errors: ErrorReporter, private val compTarget: ICompilationTarget): AstWalker() { override fun before(program: Program, parent: Node): Iterable { val callgraph = CallGraph(program) @@ -96,7 +96,7 @@ internal class UnusedCodeRemover(private val program: Program, private val error val assign1 = stmtPairs[0] as? Assignment val assign2 = stmtPairs[1] as? Assignment if (assign1 != null && assign2 != null && !assign2.isAugmentable) { - if (assign1.target.isSameAs(assign2.target, program) && ICompilationTarget.instance.isInRegularRAM(assign1.target, program)) { + if (assign1.target.isSameAs(assign2.target, program) && compTarget.isInRegularRAM(assign1.target, program)) { if(assign2.target.identifier==null || !assign2.value.referencesIdentifier(*(assign2.target.identifier!!.nameInSource.toTypedArray()))) // only remove the second assignment if its value is a simple expression! when(assign2.value) { diff --git a/examples/cx16/vtui/VTUI0.3.BIN b/examples/cx16/vtui/VTUI0.3.BIN deleted file mode 100644 index 1855dbbbe6723c325755ff34e2eb0292e3313cbf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 935 zcmb_ZO=uHA6rP=(O?I~_LcIh8-6Rd#vmU$|yr}~UV!>1AV1)?&9JGQU?BziYO^H3J z2vej}959mhD2g|6dMI=7ASe_MrsQB*Pq|s&W@9XAk1os1_rCewyl>tkBtFfb6aI?u z4}@F7Lx*n@-X;7e;eEo-IDFROQx2~>{DH%tQGUYZgy^?G^?Pu&0}MRy^*hLE3VAIc zh$uPRy9)GakASOavF-v>Zk>R);uJSnQkbX9Y@N-!Pgp#}$T>WGnIwZduf@ z{UO?lB>uZ4*|57}u_VK0B!!7u1ygHFtv_vqE4<}!*D^Ykae0IJE+U9 z|75?5b|ir+iq|Q3m5s_`rH`K75yr7h-;5Uwwa4`x?A<-=-DB+IZ3uJ?LYUC!p#YQd z4ddD=eE}8MP;m(r7a@qh8D`7+3bL1xeS|E>yoV6#yO?<&3i=l2o-!Wh&Y`M~svfGg zG53p(AP0HyAxP__RR(6;B?)M?q4GnwDjeBXxeSilwdyq*YI2Ok9u8mJETug~kt!V2 zY?Y)6GCD0ckwKhEcDwR3LcES->-tM)sVWa2y>`ZD|F8Oss$663ifm5HY~8fK*4W}; v)Hr}2@yWsQGVM}JyDn<}!cDugPx$pexR{psp!Q%r#Ki{1)6B&_IPT&PYomXx diff --git a/examples/cx16/vtui/VTUI0.4.BIN b/examples/cx16/vtui/VTUI0.4.BIN new file mode 100644 index 0000000000000000000000000000000000000000..db1d23dcb1934415dd35e79a205c981d0f6fe0a6 GIT binary patch literal 940 zcmbtRJ%|%Q6rP!##NEvwM1(ZTCb^&ob{1Y|uu}&VL=h}*n-e4WQ;5oeu!Rp&T#ofB z3t@s}4+e}RSBf?k;#_eoXdx&Z2%cq=i6+INA5b8W%qmEeBZve-y_63B_t7j zBHj`4k%$5n--w8ah>7?`#Azz7Q*nff6I48+qRT|X5QM1Lz|>nX6a@|$Fx4B#Dh7v? z3zoykTyz=OvxtBZuu97S9vCeGnJyjjn7WlU9_JU>3Lo+X<0<#XI6jMLRX=nTTe8BXVuLfF)%q!x93a&n?qqvpY%IsmtX$vUT|i zUuo42cgASLk$7)cWjowUuP_>EP&pI2Il>;VNU_&nHm2~Pm5@W1NFnYWlSmTL<{ABdNOyMN5Ubfv1N>e1} z7%&VmFgn#FR}=-s{hE!c400)*v@4_#_mX}+uu~!l(ZBYBE;r=dLEBe!dj0>JKX1rY z-mlBfj7*>F;m=i$>qvL--8()yUSV4-WLpMm{=)U}#~$IA{~uyT;_viF&jW^7V|bbl Ju?J2M@dtZOferuw literal 0 HcmV?d00001