diff --git a/compiler/src/prog8/CompilerMain.kt b/compiler/src/prog8/CompilerMain.kt index de274233d..a9027a4b0 100644 --- a/compiler/src/prog8/CompilerMain.kt +++ b/compiler/src/prog8/CompilerMain.kt @@ -31,7 +31,8 @@ fun pathFrom(stringPath: String, vararg rest: String): Path = FileSystems.getDe private fun compileMain(args: Array): Boolean { val cli = ArgParser("prog8compiler", prefixStyle = ArgParser.OptionPrefixStyle.JVM) - val startEmulator by cli.option(ArgType.Boolean, fullName = "emu", description = "auto-start emulator after successful compilation") + val startEmulator1 by cli.option(ArgType.Boolean, fullName = "emu", description = "auto-start emulator after successful compilation") + val startEmulator2 by cli.option(ArgType.Boolean, fullName = "emu2", description = "auto-start alternative emulator after successful compilation") val outputDir by cli.option(ArgType.String, fullName = "out", description = "directory for output files instead of current directory").default(".") val dontWriteAssembly by cli.option(ArgType.Boolean, fullName = "noasm", description="don't create assembly code") val dontOptimize by cli.option(ArgType.Boolean, fullName = "noopt", description = "don't perform any optimizations") @@ -119,13 +120,17 @@ private fun compileMain(args: Array): Boolean { return false } - if (startEmulator==true) { - if (compilationResult.programName.isEmpty()) + if(startEmulator1==true || startEmulator2==true) { + if (compilationResult.programName.isEmpty()) { println("\nCan't start emulator because no program was assembled.") - else { - compilationResult.compTarget.machine.launchEmulator(compilationResult.programName) + return true } } + + if (startEmulator1==true) + compilationResult.compTarget.machine.launchEmulator(1, compilationResult.programName) + else if (startEmulator2==true) + compilationResult.compTarget.machine.launchEmulator(2, compilationResult.programName) } } diff --git a/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt b/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt index 9d93627a2..f9f173ce2 100644 --- a/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt +++ b/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt @@ -1,6 +1,5 @@ package prog8.compiler.astprocessing -import prog8.ast.Module import prog8.ast.Program import prog8.ast.base.Position import prog8.ast.expressions.StringLiteralValue @@ -17,29 +16,20 @@ internal class AstIdentifiersChecker(private val program: Program, private val e errors.err("name conflict '$name', also defined in ${existing.position.file} line ${existing.position.line}", position) } - override fun visit(module: Module) { - blocks.clear() // blocks may be redefined within a different module - - super.visit(module) - } - override fun visit(block: Block) { if(block.name in compTarget.machine.opcodeNames) errors.err("can't use a cpu opcode name as a symbol: '${block.name}'", block.position) val existing = blocks[block.name] - if(existing!=null) - nameError(block.name, block.position, existing) + if(existing!=null) { + if(block.isInLibrary) + nameError(existing.name, existing.position, block) + else + nameError(block.name, block.position, existing) + } else blocks[block.name] = block - if(!block.isInLibrary) { - val libraries = program.modules.filter { it.isLibraryModule } - val libraryBlockNames = libraries.flatMap { it.statements.filterIsInstance().map { b -> b.name } } - if(block.name in libraryBlockNames) - errors.err("block is already defined in an included library module", block.position) - } - super.visit(block) } diff --git a/compiler/src/prog8/compiler/target/IMachineDefinition.kt b/compiler/src/prog8/compiler/target/IMachineDefinition.kt index ffc953c2c..ed7903238 100644 --- a/compiler/src/prog8/compiler/target/IMachineDefinition.kt +++ b/compiler/src/prog8/compiler/target/IMachineDefinition.kt @@ -32,6 +32,6 @@ interface IMachineDefinition { fun getFloat(num: Number): IMachineFloat fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List - fun launchEmulator(programName: String) + fun launchEmulator(selectedEmulator: Int, programName: String) fun isRegularRAMaddress(address: Int): Boolean } diff --git a/compiler/src/prog8/compiler/target/c64/C64MachineDefinition.kt b/compiler/src/prog8/compiler/target/c64/C64MachineDefinition.kt index 5f53595eb..638d29532 100644 --- a/compiler/src/prog8/compiler/target/c64/C64MachineDefinition.kt +++ b/compiler/src/prog8/compiler/target/c64/C64MachineDefinition.kt @@ -4,6 +4,7 @@ import prog8.compiler.* import prog8.compiler.target.CpuType import prog8.compiler.target.IMachineDefinition import prog8.compiler.target.IMachineFloat +import prog8.compiler.target.cbm.viceMonListPostfix import java.io.IOException import kotlin.math.absoluteValue import kotlin.math.pow @@ -35,10 +36,15 @@ internal object C64MachineDefinition: IMachineDefinition { emptyList() } - override fun launchEmulator(programName: String) { + override fun launchEmulator(selectedEmulator: Int, programName: String) { + if(selectedEmulator!=1) { + System.err.println("The c64 target only supports the main emulator (Vice).") + return + } + for(emulator in listOf("x64sc", "x64")) { println("\nStarting C-64 emulator $emulator...") - val cmdline = listOf(emulator, "-silent", "-moncommands", "$programName.vice-mon-list", + val cmdline = listOf(emulator, "-silent", "-moncommands", "$programName.$viceMonListPostfix", "-autostartprgmode", "1", "-autostart-warp", "-autostart", "$programName.prg") val processb = ProcessBuilder(cmdline).inheritIO() val process: Process diff --git a/compiler/src/prog8/compiler/target/cbm/AssemblyProgram.kt b/compiler/src/prog8/compiler/target/cbm/AssemblyProgram.kt index 024bd565c..db79dcbf0 100644 --- a/compiler/src/prog8/compiler/target/cbm/AssemblyProgram.kt +++ b/compiler/src/prog8/compiler/target/cbm/AssemblyProgram.kt @@ -6,11 +6,14 @@ import prog8.compiler.target.IAssemblyProgram import prog8.compiler.target.generatedLabelPrefix import java.nio.file.Path + +internal const val viceMonListPostfix = "vice-mon-list" + class AssemblyProgram(override val name: String, outputDir: Path, private val compTarget: String) : IAssemblyProgram { private val assemblyFile = outputDir.resolve("$name.asm") private val prgFile = outputDir.resolve("$name.prg") private val binFile = outputDir.resolve("$name.bin") - private val viceMonListFile = outputDir.resolve("$name.vice-mon-list") + private val viceMonListFile = outputDir.resolve("$name.$viceMonListPostfix") override fun assemble(options: CompilationOptions): Int { // add "-Wlong-branch" to see warnings about conversion of branch instructions to jumps (default = do this silently) diff --git a/compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt b/compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt index 8d1c8f5d7..0be7ec371 100644 --- a/compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt +++ b/compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt @@ -4,6 +4,7 @@ import prog8.compiler.* import prog8.compiler.target.CpuType import prog8.compiler.target.IMachineDefinition import prog8.compiler.target.c64.C64MachineDefinition +import prog8.compiler.target.cbm.viceMonListPostfix import java.io.IOException internal object CX16MachineDefinition: IMachineDefinition { @@ -32,10 +33,28 @@ internal object CX16MachineDefinition: IMachineDefinition { emptyList() } - override fun launchEmulator(programName: String) { - for(emulator in listOf("x16emu")) { + override fun launchEmulator(selectedEmulator: Int, programName: String) { + val emulatorName: String + val extraArgs: List + + when(selectedEmulator) { + 1 -> { + emulatorName = "x16emu" + extraArgs = emptyList() + } + 2 -> { + emulatorName = "box16" + extraArgs = listOf("-sym", "$programName.$viceMonListPostfix") + } + else -> { + System.err.println("Cx16 target only supports x16emu and box16 emulators.") + return + } + } + + for(emulator in listOf(emulatorName)) { println("\nStarting Commander X16 emulator $emulator...") - val cmdline = listOf(emulator, "-scale", "2", "-run", "-prg", "$programName.prg") + val cmdline = listOf(emulator, "-scale", "2", "-run", "-prg", "$programName.prg") + extraArgs val processb = ProcessBuilder(cmdline).inheritIO() val process: Process try { diff --git a/compiler/src/prog8/optimizer/UnusedCodeRemover.kt b/compiler/src/prog8/optimizer/UnusedCodeRemover.kt index 6493aa7ae..32f0ae010 100644 --- a/compiler/src/prog8/optimizer/UnusedCodeRemover.kt +++ b/compiler/src/prog8/optimizer/UnusedCodeRemover.kt @@ -20,7 +20,7 @@ internal class UnusedCodeRemover(private val program: Program, private val callgraph = CallGraph(program) override fun before(module: Module, parent: Node): Iterable { - return if (!module.isLibraryModule && (module.containsNoCodeNorVars() || callgraph.unused(module))) + return if (!module.isLibrary() && (module.containsNoCodeNorVars() || callgraph.unused(module))) listOf(IAstModification.Remove(module, module.definingScope())) else noModifications @@ -80,12 +80,12 @@ internal class UnusedCodeRemover(private val program: Program, val forceOutput = "force_output" in subroutine.definingBlock().options() if (subroutine !== program.entrypoint() && !forceOutput && !subroutine.inline && !subroutine.isAsmSubroutine) { if(callgraph.unused(subroutine)) { - if(!subroutine.definingModule().isLibraryModule) + if(!subroutine.definingModule().isLibrary()) errors.warn("removing unused subroutine '${subroutine.name}'", subroutine.position) return listOf(IAstModification.Remove(subroutine, subroutine.definingScope())) } if(subroutine.containsNoCodeNorVars()) { - if(!subroutine.definingModule().isLibraryModule) + if(!subroutine.definingModule().isLibrary()) errors.warn("removing empty subroutine '${subroutine.name}'", subroutine.position) val removals = mutableListOf(IAstModification.Remove(subroutine, subroutine.definingScope())) callgraph.calledBy[subroutine]?.let { diff --git a/compiler/test/AsmgenTests.kt b/compiler/test/AsmgenTests.kt index 6cd6ac808..8deeae874 100644 --- a/compiler/test/AsmgenTests.kt +++ b/compiler/test/AsmgenTests.kt @@ -74,7 +74,7 @@ locallabel: val varInBlock = VarDecl(VarDeclType.VAR, DataType.UWORD, ZeropageWish.DONTCARE, null, "var_outside", null, false, false, false, Position.DUMMY) val block = Block("main", null, mutableListOf(labelInBlock, varInBlock, subroutine), false, Position.DUMMY) - val module = Module("test", mutableListOf(block), Position.DUMMY, false, Path.of("")) + val module = Module("test", mutableListOf(block), Position.DUMMY, Path.of("")) module.linkParents(ParentSentinel) val program = Program("test", mutableListOf(module), DummyFunctions(), DummyMemsizer()) module.program = program diff --git a/compiler/test/TestMemory.kt b/compiler/test/TestMemory.kt index 0c266848a..b9ca856d5 100644 --- a/compiler/test/TestMemory.kt +++ b/compiler/test/TestMemory.kt @@ -98,7 +98,7 @@ class TestMemory { val target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY) val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY) val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY) - val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of("")) + val module = Module("test", mutableListOf(subroutine), Position.DUMMY, Path.of("")) module.linkParents(ParentSentinel) return target } @@ -117,7 +117,7 @@ class TestMemory { val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY) val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY) val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY) - val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of("")) + val module = Module("test", mutableListOf(subroutine), Position.DUMMY, Path.of("")) val program = Program("test", mutableListOf(module), DummyFunctions(), DummyMemsizer()) module.linkParents(ParentSentinel) assertTrue(C64Target.isInRegularRAM(target, program)) @@ -130,7 +130,7 @@ class TestMemory { val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY) val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY) val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY) - val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of("")) + val module = Module("test", mutableListOf(subroutine), Position.DUMMY, Path.of("")) val program = Program("test", mutableListOf(module), DummyFunctions(), DummyMemsizer()) module.linkParents(ParentSentinel) assertTrue(C64Target.isInRegularRAM(target, program)) @@ -143,7 +143,7 @@ class TestMemory { val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY) val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY) val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY) - val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of("")) + val module = Module("test", mutableListOf(subroutine), Position.DUMMY, Path.of("")) val program = Program("test", mutableListOf(module), DummyFunctions(), DummyMemsizer()) module.linkParents(ParentSentinel) assertFalse(C64Target.isInRegularRAM(target, program)) @@ -156,7 +156,7 @@ class TestMemory { val target = AssignTarget(null, arrayindexed, null, Position.DUMMY) val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY) val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY) - val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of("")) + val module = Module("test", mutableListOf(subroutine), Position.DUMMY, Path.of("")) val program = Program("test", mutableListOf(module), DummyFunctions(), DummyMemsizer()) module.linkParents(ParentSentinel) assertTrue(C64Target.isInRegularRAM(target, program)) @@ -170,7 +170,7 @@ class TestMemory { val target = AssignTarget(null, arrayindexed, null, Position.DUMMY) val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY) val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY) - val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of("")) + val module = Module("test", mutableListOf(subroutine), Position.DUMMY, Path.of("")) val program = Program("test", mutableListOf(module), DummyFunctions(), DummyMemsizer()) module.linkParents(ParentSentinel) assertTrue(C64Target.isInRegularRAM(target, program)) @@ -184,7 +184,7 @@ class TestMemory { val target = AssignTarget(null, arrayindexed, null, Position.DUMMY) val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY) val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY) - val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of("")) + val module = Module("test", mutableListOf(subroutine), Position.DUMMY, Path.of("")) val program = Program("test", mutableListOf(module), DummyFunctions(), DummyMemsizer()) module.linkParents(ParentSentinel) assertFalse(C64Target.isInRegularRAM(target, program)) diff --git a/compilerAst/src/prog8/ast/AstToSourceCode.kt b/compilerAst/src/prog8/ast/AstToSourceCode.kt index dd70c53bc..71fb3d7a5 100644 --- a/compilerAst/src/prog8/ast/AstToSourceCode.kt +++ b/compilerAst/src/prog8/ast/AstToSourceCode.kt @@ -24,7 +24,7 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program): } override fun visit(module: Module) { - if(!module.isLibraryModule) { + if(!module.isLibrary()) { outputln("; ----------- module: ${module.name} -----------") super.visit(module) } diff --git a/compilerAst/src/prog8/ast/AstToplevel.kt b/compilerAst/src/prog8/ast/AstToplevel.kt index 3e53e2e3b..216d0bcb5 100644 --- a/compilerAst/src/prog8/ast/AstToplevel.kt +++ b/compilerAst/src/prog8/ast/AstToplevel.kt @@ -6,6 +6,8 @@ import prog8.ast.statements.* import prog8.ast.walk.AstWalker import prog8.ast.walk.IAstVisitor import java.nio.file.Path +import java.nio.file.Paths +import kotlin.io.path.name import kotlin.math.abs const val internedStringsModuleName = "prog8_interned_strings" @@ -263,7 +265,7 @@ class Program(val name: String, init { // insert a container module for all interned strings later if(modules.firstOrNull()?.name != internedStringsModuleName) { - val internedStringsModule = Module(internedStringsModuleName, mutableListOf(), Position.DUMMY, true, Path.of("")) + val internedStringsModule = Module(internedStringsModuleName, mutableListOf(), Position.DUMMY, Path.of("")) modules.add(0, internedStringsModule) val block = Block(internedStringsModuleName, null, mutableListOf(), true, Position.DUMMY) internedStringsModule.statements.add(block) @@ -340,7 +342,6 @@ class Program(val name: String, class Module(override val name: String, override var statements: MutableList, override val position: Position, - val isLibraryModule: Boolean, val source: Path) : Node, INameScope { override lateinit var parent: Node @@ -364,10 +365,20 @@ class Module(override val name: String, replacement.parent = this } - override fun toString() = "Module(name=$name, pos=$position, lib=$isLibraryModule)" + override fun toString() = "Module(name=$name, pos=$position, lib=${isLibrary()})" fun accept(visitor: IAstVisitor) = visitor.visit(this) fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent) + + companion object { + fun pathForResource(resourcePath: String): Path { + return Paths.get("@embedded@/$resourcePath") + } + + fun isLibrary(source: Path) = source.name=="" || source.startsWith("@embedded@/") + } + + fun isLibrary() = isLibrary(source) } diff --git a/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt b/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt index efe9f81a7..fc07eece1 100644 --- a/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt +++ b/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt @@ -19,11 +19,11 @@ import java.nio.file.Path private data class NumericLiteral(val number: Number, val datatype: DataType) -internal fun prog8Parser.ModuleContext.toAst(name: String, isLibrary: Boolean, source: Path, encoding: IStringEncoding) : Module { +internal fun prog8Parser.ModuleContext.toAst(name: String, source: Path, encoding: IStringEncoding) : Module { val nameWithoutSuffix = if(name.endsWith(".p8")) name.substringBeforeLast('.') else name val directives = this.directive().map { it.toAst() } - val blocks = this.block().map { it.toAst(isLibrary, encoding) } - return Module(nameWithoutSuffix, (directives + blocks).toMutableList(), toPosition(), isLibrary, source) + val blocks = this.block().map { it.toAst(Module.isLibrary(source), encoding) } + return Module(nameWithoutSuffix, (directives + blocks).toMutableList(), toPosition(), source) } private fun ParserRuleContext.toPosition() : Position { diff --git a/compilerAst/src/prog8/parser/ModuleParsing.kt b/compilerAst/src/prog8/parser/ModuleParsing.kt index efae7049e..94faa6ee4 100644 --- a/compilerAst/src/prog8/parser/ModuleParsing.kt +++ b/compilerAst/src/prog8/parser/ModuleParsing.kt @@ -44,7 +44,7 @@ class ModuleImporter(private val program: Program, if(!Files.isReadable(filePath)) throw ParsingFailedError("No such file: $filePath") - return importModule(CharStreams.fromPath(filePath), filePath, false) + return importModule(CharStreams.fromPath(filePath), filePath) } fun importLibraryModule(name: String): Module? { @@ -68,7 +68,7 @@ class ModuleImporter(private val program: Program, } } - private fun importModule(stream: CharStream, modulePath: Path, isLibrary: Boolean): Module { + private fun importModule(stream: CharStream, modulePath: Path): Module { val moduleName = moduleName(modulePath.fileName) val lexer = CustomLexer(modulePath, stream) lexer.removeErrorListeners() @@ -87,7 +87,7 @@ class ModuleImporter(private val program: Program, // tokens.commentTokens().forEach { println(it) } // convert to Ast - val moduleAst = parseTree.toAst(moduleName, isLibrary, modulePath, encoder) + val moduleAst = parseTree.toAst(moduleName, modulePath, encoder) moduleAst.program = program moduleAst.linkParents(program.namespace) program.modules.add(moduleAst) @@ -122,7 +122,7 @@ class ModuleImporter(private val program: Program, resource.use { println("importing '$moduleName' (library)") val content = it.reader().readText().replace("\r\n", "\n") - importModule(CharStreams.fromString(content), Paths.get("@embedded@/$resourcePath"), true) + importModule(CharStreams.fromString(content), Module.pathForResource(resourcePath)) } } else { val modulePath = tryGetModuleFromFile(moduleName, source, import.position) diff --git a/compilerAst/test/TestAntlrParser.kt b/compilerAst/test/TestAntlrParser.kt index 4cdef99fa..bb90bfb34 100644 --- a/compilerAst/test/TestAntlrParser.kt +++ b/compilerAst/test/TestAntlrParser.kt @@ -249,7 +249,7 @@ main { // parser.removeErrorListeners() // parser.addErrorListener(MyErrorListener()) - val ast = parser.module().toAst("test", false, Path.of(""), DummyEncoding) + val ast = parser.module().toAst("test", Path.of(""), DummyEncoding) assertIs(ast.statements.first()) assertEquals((ast.statements.first() as Block).name, "main") } diff --git a/docs/source/index.rst b/docs/source/index.rst index dfa87772e..030467b18 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -166,7 +166,9 @@ For MacOS you can use the Homebrew system to install a recent version of OpenJDK Finally: an **emulator** (or a real machine ofcourse) to test and run your programs on. In C64 mode, the compiler assumes the presence of the `Vice emulator `_. -If you're targeting the CommanderX16 instead, there's the `x16emu `_. +If you're targeting the CommanderX16 instead, there's a choice of the official `x16emu `_ +and the unofficial `box16 `_ (you can select which one you want to launch +using the ``-emu`` or ``-emu2`` command line options) .. attention:: **Commander-X16 V38 versus V39** diff --git a/docs/source/todo.rst b/docs/source/todo.rst index 9991ff8a4..53215de3e 100644 --- a/docs/source/todo.rst +++ b/docs/source/todo.rst @@ -3,6 +3,10 @@ TODO For next release ^^^^^^^^^^^^^^^^ +- rename libdirs option to srcdirs? +- can we derive module.name from module.source (taking just the filename base)? +- can Position.file be a Path- making the source variable for nodes unnecessary? + - refactor code to improve testability and other things, see [CompilerDevelopment](CompilerDevelopment.md) - simplify cx16.joystick_get2() once this cx16 rom issue is resolved: https://github.com/commanderx16/x16-rom/issues/203 @@ -24,6 +28,9 @@ Future - refactor the compiler optimizers into own project submodule - make it possible to use cpu opcodes such as 'nop' as variable names by prefixing all asm vars with something such as ``v_`` - [problematic due to 64tass:] add a compiler option to not remove unused subroutines. this allows for building library programs. But this won't work with 64tass's .proc ... + Perhaps replace all uses of .proc/.pend by .block/.bend will fix that? + (but we lose the optimizing aspect of the assembler where it strips out unused code. + There's not really a dynamic switch possible as all assembly lib code is static and uses one or the other) - introduce byte-index operator to avoid index multiplications in loops over arrays? see https://www.reddit.com/r/programming/comments/alhj59/creating_a_programming_language_and_cross/eg898b9?utm_source=share&utm_medium=web2x&context=3 diff --git a/gradle.properties b/gradle.properties index 36138d2ae..da410ff62 100644 --- a/gradle.properties +++ b/gradle.properties @@ -2,3 +2,4 @@ org.gradle.caching=true org.gradle.console=rich org.gradle.parallel=true org.gradle.daemon=true +kotlin.code.style=official