From 9e05e97d7f9caffead5984c65e11a5901b2e8192 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Sun, 7 Feb 2021 19:38:20 +0100 Subject: [PATCH] reducing ast dependencies --- compiler/src/prog8/compiler/Main.kt | 11 ++--- .../compiler/astprocessing/AstExtensions.kt | 7 ---- .../ImportedModuleDirectiveRemover.kt | 2 + .../compiler/target/IMachineDefinition.kt | 7 +++- .../target/c64/C64MachineDefinition.kt | 11 ++++- .../target/cx16/CX16MachineDefinition.kt | 11 ++++- compiler/src/prog8/parser/ModuleParsing.kt | 41 +++++++++++-------- 7 files changed, 56 insertions(+), 34 deletions(-) diff --git a/compiler/src/prog8/compiler/Main.kt b/compiler/src/prog8/compiler/Main.kt index bb8f71364..314c945d8 100644 --- a/compiler/src/prog8/compiler/Main.kt +++ b/compiler/src/prog8/compiler/Main.kt @@ -127,12 +127,13 @@ private class BuiltinFunctionsFacade(functions: Map): IBuilt } private fun parseImports(filepath: Path, errors: ErrorReporter): Triple> { - println("Compiler target: ${CompilationTarget.instance.name}. Parsing...") + val compilationTargetName = CompilationTarget.instance.name + println("Compiler target: $compilationTargetName. Parsing...") val importer = ModuleImporter() val bf = BuiltinFunctionsFacade(BuiltinFunctions) val programAst = Program(moduleName(filepath.fileName), mutableListOf(), bf) bf.program = programAst - importer.importModule(programAst, filepath) + importer.importModule(programAst, filepath, CompilationTarget.instance, compilationTargetName) errors.handle() val importedFiles = programAst.modules.filter { !it.source.startsWith("@embedded@") }.map { it.source } @@ -142,11 +143,11 @@ private fun parseImports(filepath: Path, errors: ErrorReporter): Triple() diff --git a/compiler/src/prog8/compiler/target/IMachineDefinition.kt b/compiler/src/prog8/compiler/target/IMachineDefinition.kt index 9ef6d1346..2427356c3 100644 --- a/compiler/src/prog8/compiler/target/IMachineDefinition.kt +++ b/compiler/src/prog8/compiler/target/IMachineDefinition.kt @@ -1,5 +1,6 @@ package prog8.compiler.target +import prog8.ast.IStringEncoding import prog8.ast.Program import prog8.compiler.CompilationOptions import prog8.compiler.Zeropage @@ -32,7 +33,11 @@ internal interface IMachineDefinition { fun initializeZeropage(compilerOptions: CompilationOptions) fun getFloat(num: Number): IMachineFloat - fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program) + + // TODO don't do the importing here, just return a list of modules to import...: + fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program, + encoder: IStringEncoding, compilationTargetName: String) + fun launchEmulator(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 15eec445a..7d2bf2dcc 100644 --- a/compiler/src/prog8/compiler/target/c64/C64MachineDefinition.kt +++ b/compiler/src/prog8/compiler/target/c64/C64MachineDefinition.kt @@ -1,5 +1,6 @@ package prog8.compiler.target.c64 +import prog8.ast.IStringEncoding import prog8.ast.Program import prog8.compiler.* import prog8.compiler.target.CpuType @@ -30,9 +31,15 @@ internal object C64MachineDefinition: IMachineDefinition { override fun getFloat(num: Number) = Mflpt5.fromNumber(num) - override fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program) { + override fun importLibs( + compilerOptions: CompilationOptions, + importer: ModuleImporter, + program: Program, + encoder: IStringEncoding, + compilationTargetName: String) + { if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG) - importer.importLibraryModule(program, "syslib") + importer.importLibraryModule(program, "syslib", encoder, compilationTargetName) } override fun launchEmulator(programName: String) { diff --git a/compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt b/compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt index c1d92da94..e18847a4b 100644 --- a/compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt +++ b/compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt @@ -1,5 +1,6 @@ package prog8.compiler.target.cx16 +import prog8.ast.IStringEncoding import prog8.ast.Program import prog8.compiler.* import prog8.compiler.target.CpuType @@ -28,9 +29,15 @@ internal object CX16MachineDefinition: IMachineDefinition { override fun getFloat(num: Number) = C64MachineDefinition.Mflpt5.fromNumber(num) - override fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program) { + override fun importLibs( + compilerOptions: CompilationOptions, + importer: ModuleImporter, + program: Program, + encoder: IStringEncoding, + compilationTargetName: String) + { if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG) - importer.importLibraryModule(program, "syslib") + importer.importLibraryModule(program, "syslib", encoder, compilationTargetName) } override fun launchEmulator(programName: String) { diff --git a/compiler/src/prog8/parser/ModuleParsing.kt b/compiler/src/prog8/parser/ModuleParsing.kt index 9166fa583..06b11da0c 100644 --- a/compiler/src/prog8/parser/ModuleParsing.kt +++ b/compiler/src/prog8/parser/ModuleParsing.kt @@ -1,6 +1,7 @@ package prog8.parser import org.antlr.v4.runtime.* +import prog8.ast.IStringEncoding import prog8.ast.Module import prog8.ast.Program import prog8.ast.antlr.toAst @@ -8,8 +9,7 @@ import prog8.ast.base.Position import prog8.ast.base.SyntaxError import prog8.ast.statements.Directive import prog8.ast.statements.DirectiveArg -import prog8.compiler.astprocessing.checkImportedValid -import prog8.compiler.target.CompilationTarget +import prog8.compiler.astprocessing.ImportedModuleDirectiveRemover import prog8.pathFrom import java.io.InputStream import java.nio.file.Files @@ -28,7 +28,7 @@ internal fun moduleName(fileName: Path) = fileName.toString().substringBeforeLas internal class ModuleImporter { - internal fun importModule(program: Program, filePath: Path): Module { + internal fun importModule(program: Program, filePath: Path, encoder: IStringEncoding, compilationTargetName: String): Module { print("importing '${moduleName(filePath.fileName)}'") if(filePath.parent!=null) { var importloc = filePath.toString() @@ -43,14 +43,15 @@ internal class ModuleImporter { throw ParsingFailedError("No such file: $filePath") val input = CharStreams.fromPath(filePath) - return importModule(program, input, filePath, false) + return importModule(program, input, filePath, false, encoder, compilationTargetName) } - internal fun importLibraryModule(program: Program, name: String): Module? { + internal fun importLibraryModule(program: Program, name: String, + encoder: IStringEncoding, compilationTargetName: String): Module? { val import = Directive("%import", listOf( DirectiveArg("", name, 42, position = Position("<<>>", 0, 0, 0)) ), Position("<<>>", 0, 0, 0)) - return executeImportDirective(program, import, Paths.get("")) + return executeImportDirective(program, import, Paths.get(""), encoder, compilationTargetName) } private class MyErrorListener: ConsoleErrorListener() { @@ -65,7 +66,8 @@ internal class ModuleImporter { } } - private fun importModule(program: Program, stream: CharStream, modulePath: Path, isLibrary: Boolean): Module { + private fun importModule(program: Program, stream: CharStream, modulePath: Path, isLibrary: Boolean, + encoder: IStringEncoding, compilationTargetName: String): Module { val moduleName = moduleName(modulePath.fileName) val lexer = CustomLexer(modulePath, stream) lexer.removeErrorListeners() @@ -84,7 +86,7 @@ internal class ModuleImporter { // tokens.commentTokens().forEach { println(it) } // convert to Ast - val moduleAst = parseTree.toAst(moduleName, isLibrary, modulePath, CompilationTarget.instance) + val moduleAst = parseTree.toAst(moduleName, isLibrary, modulePath, encoder) moduleAst.program = program moduleAst.linkParents(program.namespace) program.modules.add(moduleAst) @@ -94,13 +96,14 @@ internal class ModuleImporter { lines.asSequence() .mapIndexed { i, it -> i to it } .filter { (it.second as? Directive)?.directive == "%import" } - .forEach { executeImportDirective(program, it.second as Directive, modulePath) } + .forEach { executeImportDirective(program, it.second as Directive, modulePath, encoder, compilationTargetName) } moduleAst.statements = lines return moduleAst } - private fun executeImportDirective(program: Program, import: Directive, source: Path): Module? { + private fun executeImportDirective(program: Program, import: Directive, source: Path, + encoder: IStringEncoding, compilationTargetName: String): Module? { if(import.directive!="%import" || import.args.size!=1 || import.args[0].name==null) throw SyntaxError("invalid import directive", import.position) val moduleName = import.args[0].name!! @@ -111,27 +114,31 @@ internal class ModuleImporter { if(existing!=null) return null - val rsc = tryGetModuleFromResource("$moduleName.p8") + val rsc = tryGetModuleFromResource("$moduleName.p8", compilationTargetName) val importedModule = if(rsc!=null) { // load the module from the embedded resource val (resource, resourcePath) = rsc resource.use { println("importing '$moduleName' (library)") - importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$resourcePath"), true) + importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$resourcePath"), + true, encoder, compilationTargetName) } } else { val modulePath = tryGetModuleFromFile(moduleName, source, import.position) - importModule(program, modulePath) + importModule(program, modulePath, encoder, compilationTargetName) } - importedModule.checkImportedValid() + // TODO don't do this via an AstWalker: + val imr = ImportedModuleDirectiveRemover() + imr.visit(importedModule, importedModule.parent) + imr.applyModifications() + return importedModule } - private fun tryGetModuleFromResource(name: String): Pair? { - val target = CompilationTarget.instance.name - val targetSpecificPath = "/prog8lib/$target/$name" + private fun tryGetModuleFromResource(name: String, compilationTargetName: String): Pair? { + val targetSpecificPath = "/prog8lib/$compilationTargetName/$name" val targetSpecificResource = object{}.javaClass.getResourceAsStream(targetSpecificPath) if(targetSpecificResource!=null) return Pair(targetSpecificResource, targetSpecificPath)