introduced codeAst and codeCore modules to reduce dependencies

.idea/modules.xml

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

.idea/vcs.xml

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

codeAst/codeAst.iml

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

codeAst/src/prog8/code/ast/AstBase.kt

@@ -1,10 +1,11 @@
-package prog8.compilerinterface.intermediate
+package prog8.code.ast
 
-import prog8.compilerinterface.IMemSizer
+import prog8.code.core.IMemSizer
-import prog8.compilerinterface.IStringEncoding
+import prog8.code.core.IStringEncoding
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 
-// TODO : once the CodeGen doesn't need the old Ast anymore, get rid of the 'Pt' prefixes.
+
+// TODO : once the CodeGen doesn't need the old Ast anymore, get rid of the 'Pt' prefixes ?
 
 
 sealed class PtNode(val position: Position, val children: MutableList<PtNode> = mutableListOf()) {

codeAst/src/prog8/code/ast/AstExpressions.kt

@@ -1,8 +1,8 @@
-package prog8.compilerinterface.intermediate
+package prog8.code.ast
 
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
-import prog8.compilerinterface.Encoding
+import prog8.code.core.Encoding
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 
 
 class PtAddressOf(position: Position) : PtNode(position) {

codeAst/src/prog8/code/ast/AstStatements.kt

@@ -1,9 +1,6 @@
-package prog8.compilerinterface.intermediate
+package prog8.code.ast
 
-import prog8.ast.statements.AssignmentOrigin
+import prog8.code.core.*
-import prog8.ast.statements.RegisterOrStatusflag
-import prog8.ast.statements.SubroutineParameter
-import prog8.compilerinterface.*
 
 
 class PtAsmSub(
@@ -23,7 +20,7 @@ class PtAsmSub(
 
 class PtSub(
     name: String,
-    val parameters: List<SubroutineParameter>,
+    val parameters: List<PtSubroutineParameter>,
     val returntypes: List<DataType>,
     val inline: Boolean,
     position: Position
@@ -34,16 +31,21 @@ class PtSub(
 }
 
 
-class PtAssignment(val augmentable: Boolean,
+class PtSubroutineParameter(val name: String, val type: DataType, position: Position): PtNode(position) {
-                   val origin: AssignmentOrigin,        // TODO is this ever used in the codegen?
+    override fun printProperties() {
-                   position: Position) : PtNode(position) {
+        print("$type $name")
+    }
+}
+
+
+class PtAssignment(val augmentable: Boolean, position: Position) : PtNode(position) {
     val target: PtAssignTarget
         get() = children[0] as PtAssignTarget
     val value: PtNode
         get() = children[1]
 
     override fun printProperties() {
-        print("aug=$augmentable  origin=$origin")
+        print("aug=$augmentable")
     }
 }
 

codeCore/codeCore.iml

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

codeCore/src/prog8/code/core/Enumerations.kt

@@ -0,0 +1,153 @@
+package prog8.code.core
+
+enum class DataType {
+    UBYTE,              // pass by value
+    BYTE,               // pass by value
+    UWORD,              // pass by value
+    WORD,               // pass by value
+    FLOAT,              // pass by value
+    STR,                // pass by reference
+    ARRAY_UB,           // pass by reference
+    ARRAY_B,            // pass by reference
+    ARRAY_UW,           // pass by reference
+    ARRAY_W,            // pass by reference
+    ARRAY_F,            // pass by reference
+    UNDEFINED;
+
+    /**
+     * is the type assignable to the given other type (perhaps via a typecast) without loss of precision?
+     */
+    infix fun isAssignableTo(targetType: DataType) =
+        when(this) {
+            UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, FLOAT)
+            BYTE -> targetType.oneOf(BYTE, WORD, FLOAT)
+            UWORD -> targetType.oneOf(UWORD, FLOAT)
+            WORD -> targetType.oneOf(WORD, FLOAT)
+            FLOAT -> targetType == FLOAT
+            STR -> targetType.oneOf(STR, UWORD)
+            in ArrayDatatypes -> targetType == this
+            else -> false
+        }
+
+    fun oneOf(vararg types: DataType) = this in types
+
+    infix fun largerThan(other: DataType) =
+        when {
+            this == other -> false
+            this in ByteDatatypes -> false
+            this in WordDatatypes -> other in ByteDatatypes
+            this== STR && other== UWORD || this== UWORD && other== STR -> false
+            else -> true
+        }
+
+    infix fun equalsSize(other: DataType) =
+        when {
+            this == other -> true
+            this in ByteDatatypes -> other in ByteDatatypes
+            this in WordDatatypes -> other in WordDatatypes
+            this== STR && other== UWORD || this== UWORD && other== STR -> true
+            else -> false
+        }
+}
+
+enum class CpuRegister {
+    A,
+    X,
+    Y;
+
+    fun asRegisterOrPair(): RegisterOrPair = when(this) {
+        A -> RegisterOrPair.A
+        X -> RegisterOrPair.X
+        Y -> RegisterOrPair.Y
+    }
+}
+
+enum class RegisterOrPair {
+    A,
+    X,
+    Y,
+    AX,
+    AY,
+    XY,
+    FAC1,
+    FAC2,
+    // cx16 virtual registers:
+    R0, R1, R2, R3, R4, R5, R6, R7,
+    R8, R9, R10, R11, R12, R13, R14, R15;
+
+    companion object {
+        val names by lazy { values().map { it.toString()} }
+    }
+
+    fun asCpuRegister(): CpuRegister = when(this) {
+        A -> CpuRegister.A
+        X -> CpuRegister.X
+        Y -> CpuRegister.Y
+        else -> throw IllegalArgumentException("no cpu hardware register for $this")
+    }
+
+}       // only used in parameter and return value specs in asm subroutines
+
+enum class Statusflag {
+    Pc,
+    Pz,     // don't use
+    Pv,
+    Pn;     // don't use
+
+    companion object {
+        val names by lazy { values().map { it.toString()} }
+    }
+}
+
+enum class BranchCondition {
+    CS,
+    CC,
+    EQ,
+    Z,
+    NE,
+    NZ,
+    VS,
+    VC,
+    MI,
+    NEG,
+    PL,
+    POS
+}
+
+
+val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE)
+val WordDatatypes = arrayOf(DataType.UWORD, DataType.WORD)
+val IntegerDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
+val NumericDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
+val SignedDatatypes =  arrayOf(DataType.BYTE, DataType.WORD, DataType.FLOAT)
+val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F)
+val StringlyDatatypes = arrayOf(DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B, DataType.UWORD)
+val IterableDatatypes = arrayOf(
+    DataType.STR,
+    DataType.ARRAY_UB, DataType.ARRAY_B,
+    DataType.ARRAY_UW, DataType.ARRAY_W,
+    DataType.ARRAY_F
+)
+val PassByValueDatatypes = NumericDatatypes
+val PassByReferenceDatatypes = IterableDatatypes
+val ArrayToElementTypes = mapOf(
+    DataType.STR to DataType.UBYTE,
+    DataType.ARRAY_B to DataType.BYTE,
+    DataType.ARRAY_UB to DataType.UBYTE,
+    DataType.ARRAY_W to DataType.WORD,
+    DataType.ARRAY_UW to DataType.UWORD,
+    DataType.ARRAY_F to DataType.FLOAT
+)
+val ElementToArrayTypes = mapOf(
+    DataType.BYTE to DataType.ARRAY_B,
+    DataType.UBYTE to DataType.ARRAY_UB,
+    DataType.WORD to DataType.ARRAY_W,
+    DataType.UWORD to DataType.ARRAY_UW,
+    DataType.FLOAT to DataType.ARRAY_F
+)
+val Cx16VirtualRegisters = arrayOf(
+    RegisterOrPair.R0, RegisterOrPair.R1, RegisterOrPair.R2, RegisterOrPair.R3,
+    RegisterOrPair.R4, RegisterOrPair.R5, RegisterOrPair.R6, RegisterOrPair.R7,
+    RegisterOrPair.R8, RegisterOrPair.R9, RegisterOrPair.R10, RegisterOrPair.R11,
+    RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15
+)

codeCore/src/prog8/code/core/IMemSizer.kt

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

codeCore/src/prog8/code/core/IStringEncoding.kt

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

codeCore/src/prog8/code/core/Position.kt

@@ -0,0 +1,16 @@
+package prog8.code.core
+
+import kotlin.io.path.Path
+import kotlin.io.path.absolute
+
+data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
+    override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
+    fun toClickableStr(): String {
+        val path = Path(file).absolute().normalize()
+        return "file://$path:$line:$startCol:"
+    }
+
+    companion object {
+        val DUMMY = Position("<dummy>", 0, 0, 0)
+    }
+}

codeCore/src/prog8/code/core/RegisterOrStatusflag.kt

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

codeCore/src/prog8/code/core/ToHex.kt

@@ -0,0 +1,31 @@
+package prog8.code.core
+
+import kotlin.math.abs
+
+fun Number.toHex(): String {
+    //  0..15 -> "0".."15"
+    //  16..255 -> "$10".."$ff"
+    //  256..65536 -> "$0100".."$ffff"
+    // negative values are prefixed with '-'.
+    val integer = this.toInt()
+    if(integer<0)
+        return '-' + abs(integer).toHex()
+    return when (integer) {
+        in 0 until 16 -> integer.toString()
+        in 0 until 0x100 -> "$"+integer.toString(16).padStart(2,'0')
+        in 0 until 0x10000 -> "$"+integer.toString(16).padStart(4,'0')
+        else -> throw IllegalArgumentException("number too large for 16 bits $this")
+    }
+}
+
+fun UInt.toHex(): String {
+    //  0..15 -> "0".."15"
+    //  16..255 -> "$10".."$ff"
+    //  256..65536 -> "$0100".."$ffff"
+    return when (this) {
+        in 0u until 16u -> this.toString()
+        in 0u until 0x100u -> "$"+this.toString(16).padStart(2,'0')
+        in 0u until 0x10000u -> "$"+this.toString(16).padStart(4,'0')
+        else -> throw IllegalArgumentException("number too large for 16 bits $this")
+    }
+}

codeGenCpu6502/codeGenCpu6502.iml

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

codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt

@@ -2,9 +2,10 @@ package prog8.codegen.cpu6502
 
 import com.github.michaelbull.result.fold
 import prog8.ast.*
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
+import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.*
 import prog8.compilerinterface.*
 import prog8.parser.SourceCode

codeGenCpu6502/src/prog8/codegen/cpu6502/AsmOptimizer.kt

@@ -3,8 +3,8 @@ package prog8.codegen.cpu6502
 import prog8.ast.Program
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.VarDecl
+import prog8.ast.statements.VarDeclType
 import prog8.compilerinterface.IMachineDefinition
-import prog8.compilerinterface.VarDeclType
 
 
 // note: see https://wiki.nesdev.org/w/index.php/6502_assembly_optimisations

codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt

@@ -3,12 +3,12 @@ package prog8.codegen.cpu6502
 import prog8.ast.IFunctionCall
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.ArrayIndex
 import prog8.ast.statements.BuiltinFunctionCallStatement
 import prog8.ast.statements.DirectMemoryWrite
 import prog8.ast.statements.Subroutine
+import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.*
 import prog8.compilerinterface.*
 

codeGenCpu6502/src/prog8/codegen/cpu6502/ExpressionsAsmGen.kt

@@ -1,9 +1,10 @@
 package prog8.codegen.cpu6502
 
 import prog8.ast.Program
-import prog8.ast.base.*
 import prog8.ast.expressions.*
-import prog8.compilerinterface.*
+import prog8.code.core.*
+import prog8.compilerinterface.AssemblyError
+import prog8.compilerinterface.CpuType
 import kotlin.math.absoluteValue
 
 internal class ExpressionsAsmGen(private val program: Program,

codeGenCpu6502/src/prog8/codegen/cpu6502/ForLoopsAsmGen.kt

@@ -5,7 +5,12 @@ import prog8.ast.Program
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.RangeExpression
 import prog8.ast.statements.ForLoop
-import prog8.compilerinterface.*
+import prog8.code.core.ArrayToElementTypes
+import prog8.code.core.DataType
+import prog8.code.core.RegisterOrPair
+import prog8.code.core.toHex
+import prog8.compilerinterface.AssemblyError
+import prog8.compilerinterface.Zeropage
 import kotlin.math.absoluteValue
 
 internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen, private val zeropage: Zeropage) {

codeGenCpu6502/src/prog8/codegen/cpu6502/FunctionCallAsmGen.kt

@@ -8,11 +8,12 @@ import prog8.ast.expressions.Expression
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.*
+import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.AsmAssignSource
 import prog8.codegen.cpu6502.assignment.AsmAssignTarget
 import prog8.codegen.cpu6502.assignment.AsmAssignment
 import prog8.codegen.cpu6502.assignment.TargetStorageKind
-import prog8.compilerinterface.*
+import prog8.compilerinterface.AssemblyError
 
 
 internal class FunctionCallAsmGen(private val program: Program, private val asmgen: AsmGen) {

codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt

@@ -4,7 +4,8 @@ import prog8.ast.Program
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.PostIncrDecr
-import prog8.compilerinterface.*
+import prog8.code.core.*
+import prog8.compilerinterface.AssemblyError
 
 
 internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) {

codeGenCpu6502/src/prog8/codegen/cpu6502/ProgramAndVarsGen.kt

@@ -2,8 +2,8 @@ package prog8.codegen.cpu6502
 
 import prog8.ast.Program
 import prog8.ast.antlr.escape
-import prog8.ast.base.*
 import prog8.ast.statements.*
+import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.AsmAssignTarget
 import prog8.codegen.cpu6502.assignment.TargetStorageKind
 import prog8.compilerinterface.*

codeGenCpu6502/src/prog8/codegen/cpu6502/VariableAllocator.kt

@@ -2,6 +2,9 @@ package prog8.codegen.cpu6502
 
 import com.github.michaelbull.result.fold
 import com.github.michaelbull.result.onSuccess
+import prog8.code.core.ArrayDatatypes
+import prog8.code.core.DataType
+import prog8.code.core.IntegerDatatypes
 import prog8.compilerinterface.*
 
 

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt

@@ -3,8 +3,9 @@ package prog8.codegen.cpu6502.assignment
 import prog8.ast.Program
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
+import prog8.code.core.*
 import prog8.codegen.cpu6502.AsmGen
-import prog8.compilerinterface.*
+import prog8.compilerinterface.AssemblyError
 
 
 internal enum class TargetStorageKind {

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt

@@ -1,12 +1,14 @@
 package prog8.codegen.cpu6502.assignment
 
 import prog8.ast.Program
-import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
+import prog8.code.core.*
 import prog8.codegen.cpu6502.AsmGen
 import prog8.codegen.cpu6502.VariableAllocator
-import prog8.compilerinterface.*
+import prog8.compilerinterface.AssemblyError
+import prog8.compilerinterface.CpuType
+import prog8.compilerinterface.builtinFunctionReturnType
 
 
 internal class AssignmentAsmGen(private val program: Program, 

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt

@@ -1,12 +1,14 @@
 package prog8.codegen.cpu6502.assignment
 
 import prog8.ast.Program
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.Subroutine
+import prog8.code.core.*
 import prog8.codegen.cpu6502.AsmGen
 import prog8.codegen.cpu6502.VariableAllocator
-import prog8.compilerinterface.*
+import prog8.compilerinterface.AssemblyError
+import prog8.compilerinterface.CpuType
 
 
 internal class AugmentableAssignmentAsmGen(private val program: Program,

codeGenExperimental6502/codeGenExperimental6502.iml

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

codeGenExperimental6502/src/prog8/codegen/experimental6502/AsmGen.kt

@@ -1,12 +1,14 @@
 package prog8.codegen.experimental6502
 
+import prog8.code.ast.PtProgram
 import prog8.compilerinterface.*
-import prog8.compilerinterface.intermediate.PtProgram
+
 
 class AsmGen(internal val program: PtProgram,
              internal val errors: IErrorReporter,
              internal val symbolTable: SymbolTable,
-             internal val options: CompilationOptions): IAssemblyGenerator {
+             internal val options: CompilationOptions
+): IAssemblyGenerator {
 
     override fun compileToAssembly(): IAssemblyProgram? {
 

codeGenTargets/codeGenTargets.iml

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

codeGenTargets/src/prog8/codegen/target/AtariTarget.kt

@@ -1,12 +1,12 @@
 package prog8.codegen.target
 
 import prog8.ast.expressions.Expression
-import prog8.ast.statements.RegisterOrStatusflag
 import prog8.ast.statements.Subroutine
+import prog8.code.core.*
 import prog8.codegen.target.atari.AtariMachineDefinition
 import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder
 import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk
-import prog8.compilerinterface.*
+import prog8.compilerinterface.ICompilationTarget
 
 
 class AtariTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {

codeGenTargets/src/prog8/codegen/target/C128Target.kt

@@ -1,16 +1,16 @@
 package prog8.codegen.target
 
 import prog8.ast.expressions.Expression
-import prog8.ast.statements.RegisterOrStatusflag
 import prog8.ast.statements.Subroutine
+import prog8.code.core.Encoding
+import prog8.code.core.IMemSizer
+import prog8.code.core.IStringEncoding
+import prog8.code.core.RegisterOrStatusflag
 import prog8.codegen.target.c128.C128MachineDefinition
 import prog8.codegen.target.cbm.CbmMemorySizer
 import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder
 import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk
-import prog8.compilerinterface.Encoding
 import prog8.compilerinterface.ICompilationTarget
-import prog8.compilerinterface.IMemSizer
-import prog8.compilerinterface.IStringEncoding
 
 
 class C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {

codeGenTargets/src/prog8/codegen/target/C64Target.kt

@@ -1,16 +1,16 @@
 package prog8.codegen.target
 
 import prog8.ast.expressions.Expression
-import prog8.ast.statements.RegisterOrStatusflag
 import prog8.ast.statements.Subroutine
+import prog8.code.core.Encoding
+import prog8.code.core.IMemSizer
+import prog8.code.core.IStringEncoding
+import prog8.code.core.RegisterOrStatusflag
 import prog8.codegen.target.c64.C64MachineDefinition
 import prog8.codegen.target.cbm.CbmMemorySizer
 import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder
 import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk
-import prog8.compilerinterface.Encoding
 import prog8.compilerinterface.ICompilationTarget
-import prog8.compilerinterface.IMemSizer
-import prog8.compilerinterface.IStringEncoding
 
 
 class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {

codeGenTargets/src/prog8/codegen/target/Cx16Target.kt

@@ -1,16 +1,16 @@
 package prog8.codegen.target
 
 import prog8.ast.expressions.Expression
-import prog8.ast.statements.RegisterOrStatusflag
 import prog8.ast.statements.Subroutine
+import prog8.code.core.Encoding
+import prog8.code.core.IMemSizer
+import prog8.code.core.IStringEncoding
+import prog8.code.core.RegisterOrStatusflag
 import prog8.codegen.target.cbm.CbmMemorySizer
 import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder
 import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk
 import prog8.codegen.target.cx16.CX16MachineDefinition
-import prog8.compilerinterface.Encoding
 import prog8.compilerinterface.ICompilationTarget
-import prog8.compilerinterface.IMemSizer
-import prog8.compilerinterface.IStringEncoding
 
 
 class Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {

codeGenTargets/src/prog8/codegen/target/Encoder.kt

@@ -1,13 +1,14 @@
 package prog8.codegen.target
 
 import com.github.michaelbull.result.fold
+import prog8.code.core.Encoding
+import prog8.code.core.IStringEncoding
 import prog8.codegen.target.cbm.AtasciiEncoding
 import prog8.codegen.target.cbm.IsoEncoding
 import prog8.codegen.target.cbm.PetsciiEncoding
-import prog8.compilerinterface.Encoding
-import prog8.compilerinterface.IStringEncoding
 import prog8.compilerinterface.InternalCompilerException
 
+
 internal object Encoder: IStringEncoding {
     override fun encodeString(str: String, encoding: Encoding): List<UByte> {
         val coded = when(encoding) {

codeGenTargets/src/prog8/codegen/target/cbm/AsmsubHelpers.kt

@@ -3,10 +3,10 @@ package prog8.codegen.target.cbm
 import prog8.ast.expressions.ArrayIndexedExpression
 import prog8.ast.expressions.BuiltinFunctionCall
 import prog8.ast.expressions.Expression
-import prog8.ast.statements.RegisterOrStatusflag
 import prog8.ast.statements.Subroutine
-import prog8.compilerinterface.Cx16VirtualRegisters
+import prog8.code.core.Cx16VirtualRegisters
-import prog8.compilerinterface.RegisterOrPair
+import prog8.code.core.RegisterOrPair
+import prog8.code.core.RegisterOrStatusflag
 
 
 internal fun asmsub6502ArgsEvalOrder(sub: Subroutine): List<Int> {

codeGenTargets/src/prog8/codegen/target/cbm/CbmMemorySizer.kt

@@ -1,6 +1,7 @@
 package prog8.codegen.target.cbm
 
-import prog8.compilerinterface.*
+import prog8.code.core.*
+
 
 internal object CbmMemorySizer: IMemSizer {
     override fun memorySize(dt: DataType): Int {

codeGenTargets/src/prog8/codegen/target/cx16/CX16Zeropage.kt

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

codeOptimizers/codeOptimizers.iml

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

codeOptimizers/src/prog8/optimizer/BinExprSplitter.kt

@@ -13,8 +13,8 @@ import prog8.ast.statements.Assignment
 import prog8.ast.statements.AssignmentOrigin
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
+import prog8.code.core.DataType
 import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.DataType
 import prog8.compilerinterface.ICompilationTarget
 import prog8.compilerinterface.isIOAddress
 

codeOptimizers/src/prog8/optimizer/ConstExprEvaluator.kt

@@ -1,11 +1,12 @@
 package prog8.optimizer
 
-import prog8.ast.base.*
+import prog8.ast.base.ExpressionError
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.NumericLiteral
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
-import prog8.compilerinterface.IntegerDatatypes
+import prog8.code.core.IntegerDatatypes
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 import kotlin.math.pow
 
 

codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -2,16 +2,18 @@ package prog8.optimizer
 
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.*
+import prog8.ast.base.ExpressionError
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.UndefinedSymbolError
 import prog8.ast.expressions.*
 import prog8.ast.statements.Assignment
 import prog8.ast.statements.ForLoop
 import prog8.ast.statements.VarDecl
+import prog8.ast.statements.VarDeclType
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
-import prog8.compilerinterface.IntegerDatatypes
+import prog8.code.core.IntegerDatatypes
-import prog8.compilerinterface.VarDeclType
 import kotlin.math.pow
 
 

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -2,12 +2,16 @@ package prog8.optimizer
 
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.UndefinedSymbolError
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.*
+import prog8.code.core.*
+import prog8.compilerinterface.ICompilationTarget
+import prog8.compilerinterface.IErrorReporter
+import prog8.compilerinterface.InternalCompilerException
 
 // Fix up the literal value's type to match that of the vardecl
 //   (also check range literal operands types before they get expanded into arrays for instance)
@@ -23,7 +27,7 @@ class VarConstantValueTypeAdjuster(private val program: Program, private val err
             if(declConstValue!=null && (decl.type== VarDeclType.VAR || decl.type==VarDeclType.CONST)
                 && declConstValue.type != decl.datatype) {
                 // avoid silent float roundings
-                if(decl.datatype in IntegerDatatypes && declConstValue.type==DataType.FLOAT) {
+                if(decl.datatype in IntegerDatatypes && declConstValue.type == DataType.FLOAT) {
                     errors.err("refused rounding of float to avoid loss of precision", decl.value!!.position)
                 } else {
                     // cast the numeric literal to the appropriate datatype of the variable

codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -6,10 +6,10 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
+import prog8.code.core.IntegerDatatypes
+import prog8.code.core.NumericDatatypes
 import prog8.compilerinterface.IErrorReporter
-import prog8.compilerinterface.IntegerDatatypes
-import prog8.compilerinterface.NumericDatatypes
 import kotlin.math.abs
 import kotlin.math.log2
 import kotlin.math.pow

codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt

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

codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -5,7 +5,11 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.*
+import prog8.code.core.DataType
+import prog8.compilerinterface.CallGraph
+import prog8.compilerinterface.ICompilationTarget
+import prog8.compilerinterface.IErrorReporter
+import prog8.compilerinterface.isIOAddress
 
 
 class UnusedCodeRemover(private val program: Program,

compiler/compiler.iml

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

compiler/src/prog8/compiler/Compiler.kt

@@ -11,6 +11,7 @@ import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.Directive
 import prog8.ast.statements.VarDecl
 import prog8.ast.walk.IAstVisitor
+import prog8.code.core.Position
 import prog8.codegen.target.AtariTarget
 import prog8.codegen.target.C128Target
 import prog8.codegen.target.C64Target

compiler/src/prog8/compiler/ErrorReporter.kt

@@ -1,7 +1,8 @@
 package prog8.compiler
 
+import prog8.code.core.Position
 import prog8.compilerinterface.IErrorReporter
-import prog8.compilerinterface.Position
+
 
 internal class ErrorReporter: IErrorReporter {
     private enum class MessageSeverity {

compiler/src/prog8/compiler/IntermediateAstMaker.kt

@@ -1,12 +1,11 @@
 package prog8.compiler
 
-import prog8.ast.Program
 import prog8.ast.Module
+import prog8.ast.Program
 import prog8.ast.base.FatalAstException
-import prog8.ast.statements.*
 import prog8.ast.expressions.*
-import prog8.compilerinterface.VarDeclType
+import prog8.ast.statements.*
-import prog8.compilerinterface.intermediate.*
+import prog8.code.ast.*
 
 
 class IntermediateAstMaker(val srcProgram: Program) {
@@ -94,7 +93,7 @@ class IntermediateAstMaker(val srcProgram: Program) {
     }
 
     private fun transform(srcAssign: Assignment): PtAssignment {
-        val assign = PtAssignment(srcAssign.isAugmentable, srcAssign.origin, srcAssign.position)
+        val assign = PtAssignment(srcAssign.isAugmentable, srcAssign.position)
         assign.add(transform(srcAssign.target))
         assign.add(transformExpression(srcAssign.value))
         return assign
@@ -284,7 +283,7 @@ class IntermediateAstMaker(val srcProgram: Program) {
 
     private fun transformSub(srcSub: Subroutine): PtSub {
         val sub = PtSub(srcSub.name,
-            srcSub.parameters,
+            srcSub.parameters.map { PtSubroutineParameter(it.name, it.type, it.position) },
             srcSub.returntypes,
             srcSub.inline,
             srcSub.position)

compiler/src/prog8/compiler/ModuleImporter.kt

@@ -6,8 +6,8 @@ import prog8.ast.Program
 import prog8.ast.base.SyntaxError
 import prog8.ast.statements.Directive
 import prog8.ast.statements.DirectiveArg
+import prog8.code.core.Position
 import prog8.compilerinterface.IErrorReporter
-import prog8.compilerinterface.Position
 import prog8.parser.Prog8Parser
 import prog8.parser.SourceCode
 import java.io.File

compiler/src/prog8/compiler/astprocessing/AstChecker.kt

@@ -1,10 +1,12 @@
 package prog8.compiler.astprocessing
 
 import prog8.ast.*
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.SyntaxError
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
+import prog8.code.core.*
 import prog8.compilerinterface.*
 import java.io.CharConversionException
 import java.io.File

compiler/src/prog8/compiler/astprocessing/AstExtensions.kt

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

compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt

@@ -8,10 +8,11 @@ import prog8.ast.expressions.FunctionCallExpression
 import prog8.ast.expressions.StringLiteral
 import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
+import prog8.code.core.Position
 import prog8.compilerinterface.BuiltinFunctions
 import prog8.compilerinterface.ICompilationTarget
 import prog8.compilerinterface.IErrorReporter
-import prog8.compilerinterface.Position
+
 
 internal class AstIdentifiersChecker(private val errors: IErrorReporter,
                                      private val program: Program,

compiler/src/prog8/compiler/astprocessing/AstPreprocessor.kt

@@ -8,13 +8,17 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.*
+import prog8.code.core.Encoding
+import prog8.code.core.NumericDatatypes
+import prog8.compilerinterface.ICompilationTarget
+import prog8.compilerinterface.IErrorReporter
+import prog8.compilerinterface.InternalCompilerException
 
 
 class AstPreprocessor(val program: Program, val errors: IErrorReporter, val compTarget: ICompilationTarget) : AstWalker() {
 
     override fun before(char: CharLiteral, parent: Node): Iterable<IAstModification> {
-        if(char.encoding==Encoding.DEFAULT)
+        if(char.encoding== Encoding.DEFAULT)
             char.encoding = compTarget.defaultEncoding
         return noModifications
     }

compiler/src/prog8/compiler/astprocessing/AstVariousTransforms.kt

@@ -12,7 +12,7 @@ import prog8.ast.statements.Subroutine
 import prog8.ast.statements.VarDecl
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
 
 
 internal class AstVariousTransforms(private val program: Program) : AstWalker() {
@@ -104,7 +104,7 @@ internal class AstVariousTransforms(private val program: Program) : AstWalker()
 
 internal fun replacePointerVarIndexWithMemreadOrMemwrite(program: Program, arrayIndexedExpression: ArrayIndexedExpression, parent: Node): Iterable<IAstModification> {
     val arrayVar = arrayIndexedExpression.arrayvar.targetVarDecl(program)
-    if(arrayVar!=null && arrayVar.datatype ==  DataType.UWORD) {
+    if(arrayVar!=null && arrayVar.datatype == DataType.UWORD) {
         // rewrite   pointervar[index]  into  @(pointervar+index)
         val indexer = arrayIndexedExpression.indexer
         val add = BinaryExpression(arrayIndexedExpression.arrayvar.copy(), "+", indexer.indexExpr, arrayIndexedExpression.position)

compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt

@@ -1,12 +1,15 @@
 package prog8.compiler.astprocessing
 
 import prog8.ast.*
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.ast.walk.IAstVisitor
+import prog8.code.core.DataType
+import prog8.code.core.NumericDatatypes
+import prog8.code.core.Position
 import prog8.compilerinterface.*
 
 internal class BeforeAsmAstChanger(val program: Program,

compiler/src/prog8/compiler/astprocessing/BeforeAsmTypecastCleaner.kt

@@ -8,7 +8,12 @@ import prog8.ast.statements.BuiltinFunctionCallStatement
 import prog8.ast.statements.FunctionCallStatement
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.*
+import prog8.code.core.ByteDatatypes
+import prog8.code.core.DataType
+import prog8.code.core.PassByReferenceDatatypes
+import prog8.code.core.WordDatatypes
+import prog8.compilerinterface.IErrorReporter
+
 
 internal class BeforeAsmTypecastCleaner(val program: Program,
                                         private val errors: IErrorReporter

compiler/src/prog8/compiler/astprocessing/CodeDesugarer.kt

@@ -8,8 +8,9 @@ import prog8.ast.expressions.PrefixExpression
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
+import prog8.code.core.Position
 import prog8.compilerinterface.IErrorReporter
-import prog8.compilerinterface.Position
+
 
 private var generatedLabelSequenceNumber: Int = 0
 

compiler/src/prog8/compiler/astprocessing/LiteralsToAutoVars.kt

@@ -11,8 +11,8 @@ import prog8.ast.statements.VarDecl
 import prog8.ast.statements.WhenChoice
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
-import prog8.compilerinterface.Encoding
+import prog8.code.core.Encoding
 import prog8.compilerinterface.ICompilationTarget
 import prog8.compilerinterface.IErrorReporter
 

compiler/src/prog8/compiler/astprocessing/StatementReorderer.kt

@@ -1,16 +1,21 @@
 package prog8.compiler.astprocessing
 
 import prog8.ast.*
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.*
+import prog8.code.core.*
+import prog8.compilerinterface.BuiltinFunctions
+import prog8.compilerinterface.CompilationOptions
+import prog8.compilerinterface.ICompilationTarget
+import prog8.compilerinterface.IErrorReporter
 
 internal class StatementReorderer(val program: Program,
                                   val errors: IErrorReporter,
-                                  private val options: CompilationOptions) : AstWalker() {
+                                  private val options: CompilationOptions
+) : AstWalker() {
     // Reorders the statements in a way the compiler needs.
     // - 'main' block must be the very first statement UNLESS it has an address set.
     // - library blocks are put last.
@@ -469,7 +474,8 @@ private fun tryReplaceCallNormalSubWithGosub(call: FunctionCallStatement, parent
 private fun tryReplaceCallAsmSubWithGosub(call: FunctionCallStatement,
                                           parent: Node,
                                           callee: Subroutine,
-                                          compTarget: ICompilationTarget): Iterable<IAstModification> {
+                                          compTarget: ICompilationTarget
+): Iterable<IAstModification> {
     val noModifications = emptyList<IAstModification>()
 
     if(callee.parameters.isEmpty()) {

compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt

@@ -5,6 +5,7 @@ import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
+import prog8.code.core.Position
 import prog8.compilerinterface.*
 import java.util.*
 

compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt

@@ -3,12 +3,18 @@ package prog8.compiler.astprocessing
 import prog8.ast.IFunctionCall
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.*
+import prog8.code.core.ArrayDatatypes
+import prog8.code.core.DataType
+import prog8.code.core.IterableDatatypes
+import prog8.code.core.PassByReferenceDatatypes
+import prog8.compilerinterface.BuiltinFunctions
+import prog8.compilerinterface.CompilationOptions
+import prog8.compilerinterface.IErrorReporter
 
 
 class TypecastsAdder(val program: Program, val options: CompilationOptions, val errors: IErrorReporter) : AstWalker() {

compiler/src/prog8/compiler/astprocessing/VariousCleanups.kt

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

compiler/src/prog8/compiler/astprocessing/VerifyFunctionArgTypes.kt

@@ -8,7 +8,11 @@ import prog8.ast.expressions.PipeExpression
 import prog8.ast.expressions.TypecastExpression
 import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
-import prog8.compilerinterface.*
+import prog8.code.core.DataType
+import prog8.code.core.Position
+import prog8.compilerinterface.BuiltinFunctions
+import prog8.compilerinterface.IErrorReporter
+import prog8.compilerinterface.builtinFunctionReturnType
 
 internal class VerifyFunctionArgTypes(val program: Program, val errors: IErrorReporter) : IAstVisitor {
 

compiler/test/TestBuiltinFunctions.kt

@@ -2,11 +2,10 @@ package prog8tests
 
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
+import prog8.code.core.DataType
+import prog8.code.core.NumericDatatypes
+import prog8.code.core.RegisterOrPair
 import prog8.compilerinterface.BuiltinFunctions
-import prog8.compilerinterface.DataType
-import prog8.compilerinterface.NumericDatatypes
-import prog8.compilerinterface.RegisterOrPair
-
 
 class TestBuiltinFunctions: FunSpec({
 

compiler/test/TestCompilerOnCharLit.kt

@@ -8,10 +8,10 @@ import io.kotest.matchers.types.instanceOf
 import prog8.ast.IFunctionCall
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
+import prog8.ast.statements.VarDeclType
+import prog8.code.core.DataType
+import prog8.code.core.Encoding
 import prog8.codegen.target.Cx16Target
-import prog8.compilerinterface.DataType
-import prog8.compilerinterface.Encoding
-import prog8.compilerinterface.VarDeclType
 import prog8tests.helpers.compileText
 
 

compiler/test/TestCompilerOnRanges.kt

@@ -12,12 +12,14 @@ import prog8.ast.expressions.NumericLiteral
 import prog8.ast.expressions.RangeExpression
 import prog8.ast.statements.ForLoop
 import prog8.ast.statements.VarDecl
+import prog8.code.core.DataType
+import prog8.code.core.Encoding
+import prog8.code.core.Position
 import prog8.codegen.target.C64Target
 import prog8.codegen.target.Cx16Target
-import prog8.compilerinterface.DataType
+import prog8tests.helpers.ErrorReporterForTests
-import prog8.compilerinterface.Encoding
+import prog8tests.helpers.cartesianProduct
-import prog8.compilerinterface.Position
+import prog8tests.helpers.compileText
-import prog8tests.helpers.*
 
 
 /**

compiler/test/TestCompilerOptionLibdirs.kt

@@ -6,7 +6,10 @@ import prog8.codegen.target.Cx16Target
 import prog8.compiler.CompilationResult
 import prog8.compiler.CompilerArguments
 import prog8.compiler.compileProgram
-import prog8tests.helpers.*
+import prog8tests.helpers.assumeReadableFile
+import prog8tests.helpers.fixturesDir
+import prog8tests.helpers.outputDir
+import prog8tests.helpers.workingDir
 import java.nio.file.Path
 import kotlin.io.path.absolute
 import kotlin.io.path.createTempFile

compiler/test/TestMemory.kt

@@ -10,14 +10,16 @@ import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.expressions.PrefixExpression
 import prog8.ast.statements.*
+import prog8.code.core.DataType
+import prog8.code.core.Position
 import prog8.codegen.target.C64Target
 import prog8.compiler.printProgram
-import prog8.compilerinterface.DataType
-import prog8.compilerinterface.Position
-import prog8.compilerinterface.VarDeclType
 import prog8.compilerinterface.isIOAddress
 import prog8.parser.SourceCode
-import prog8tests.helpers.*
+import prog8tests.helpers.DummyFunctions
+import prog8tests.helpers.DummyMemsizer
+import prog8tests.helpers.DummyStringEncoder
+import prog8tests.helpers.compileText
 
 
 class TestMemory: FunSpec({

compiler/test/TestNumbers.kt

@@ -6,10 +6,10 @@ import io.kotest.matchers.doubles.plusOrMinus
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
 import io.kotest.matchers.string.shouldContain
+import prog8.code.core.toHex
 import prog8.codegen.target.C64Target
 import prog8.codegen.target.cbm.Mflpt5
 import prog8.compilerinterface.InternalCompilerException
-import prog8.compilerinterface.toHex
 import prog8tests.helpers.ErrorReporterForTests
 import prog8tests.helpers.compileText
 

compiler/test/TestNumericLiteral.kt

@@ -10,9 +10,10 @@ import prog8.ast.expressions.ArrayLiteral
 import prog8.ast.expressions.InferredTypes
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.expressions.StringLiteral
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
-import prog8.compilerinterface.Encoding
+import prog8.code.core.Encoding
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
+
 
 class TestNumericLiteral: FunSpec({
 

compiler/test/TestOptimization.kt

@@ -13,12 +13,17 @@ import prog8.ast.ParentSentinel
 import prog8.ast.Program
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
+import prog8.code.core.DataType
+import prog8.code.core.Position
 import prog8.codegen.target.C64Target
 import prog8.compiler.astprocessing.processAstBeforeAsmGeneration
 import prog8.compiler.printProgram
-import prog8.compilerinterface.*
+import prog8.compilerinterface.CbmPrgLauncherType
+import prog8.compilerinterface.CompilationOptions
+import prog8.compilerinterface.OutputType
+import prog8.compilerinterface.ZeropageType
 import prog8tests.helpers.*
-import prog8.compilerinterface.Position.Companion as Position1
+
 
 class TestOptimization: FunSpec({
     test("remove empty subroutine except start") {
@@ -70,8 +75,8 @@ class TestOptimization: FunSpec({
     }
 
     test("generated constvalue from typecast inherits proper parent linkage") {
-        val number = NumericLiteral(DataType.UBYTE, 11.0, Position1.DUMMY)
+        val number = NumericLiteral(DataType.UBYTE, 11.0, Position.DUMMY)
-        val tc = TypecastExpression(number, DataType.BYTE, false, Position1.DUMMY)
+        val tc = TypecastExpression(number, DataType.BYTE, false, Position.DUMMY)
         val program = Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
         tc.linkParents(ParentSentinel)
         tc.parent shouldNotBe null
@@ -85,8 +90,8 @@ class TestOptimization: FunSpec({
     }
 
     test("generated constvalue from prefixexpr inherits proper parent linkage") {
-        val number = NumericLiteral(DataType.UBYTE, 11.0, Position1.DUMMY)
+        val number = NumericLiteral(DataType.UBYTE, 11.0, Position.DUMMY)
-        val pfx = PrefixExpression("-", number, Position1.DUMMY)
+        val pfx = PrefixExpression("-", number, Position.DUMMY)
         val program = Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
         pfx.linkParents(ParentSentinel)
         pfx.parent shouldNotBe null
@@ -137,23 +142,23 @@ class TestOptimization: FunSpec({
         val addR0value = (stmts[5] as Assignment).value
         val binexpr0 = addR0value as BinaryExpression
         binexpr0.operator shouldBe "+"
-        binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position1.DUMMY)
+        binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position.DUMMY)
         val addR2value = (stmts[7] as Assignment).value
         val binexpr2 = addR2value as BinaryExpression
         binexpr2.operator shouldBe "+"
-        binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position1.DUMMY)
+        binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position.DUMMY)
         val addR4value = (stmts[9] as Assignment).value
         val binexpr4 = addR4value as BinaryExpression
         binexpr4.operator shouldBe "+"
-        binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 22.0, Position1.DUMMY)
+        binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 22.0, Position.DUMMY)
         val subR5value = (stmts[11] as Assignment).value
         val binexpr5 = subR5value as BinaryExpression
         binexpr5.operator shouldBe "-"
-        binexpr5.right shouldBe NumericLiteral(DataType.UWORD, 1899.0, Position1.DUMMY)
+        binexpr5.right shouldBe NumericLiteral(DataType.UWORD, 1899.0, Position.DUMMY)
         val subR7value = (stmts[13] as Assignment).value
         val binexpr7 = subR7value as BinaryExpression
         binexpr7.operator shouldBe "+"
-        binexpr7.right shouldBe NumericLiteral(DataType.UWORD, 99.0, Position1.DUMMY)
+        binexpr7.right shouldBe NumericLiteral(DataType.UWORD, 99.0, Position.DUMMY)
     }
 
     test("const folding multiple scenarios * and /") {
@@ -190,27 +195,27 @@ class TestOptimization: FunSpec({
         val mulR0Value = (stmts[3] as Assignment).value
         val binexpr0 = mulR0Value as BinaryExpression
         binexpr0.operator shouldBe "*"
-        binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position1.DUMMY)
+        binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position.DUMMY)
         val mulR1Value = (stmts[5] as Assignment).value
         val binexpr1 = mulR1Value as BinaryExpression
         binexpr1.operator shouldBe "*"
-        binexpr1.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position1.DUMMY)
+        binexpr1.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position.DUMMY)
         val divR2Value = (stmts[7] as Assignment).value
         val binexpr2 = divR2Value as BinaryExpression
         binexpr2.operator shouldBe "/"
-        binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position1.DUMMY)
+        binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position.DUMMY)
         val mulR3Value = (stmts[9] as Assignment).value
         val binexpr3 = mulR3Value as BinaryExpression
         binexpr3.operator shouldBe "*"
-        binexpr3.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position1.DUMMY)
+        binexpr3.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position.DUMMY)
         val mulR4Value = (stmts[11] as Assignment).value
         val binexpr4 = mulR4Value as BinaryExpression
         binexpr4.operator shouldBe "*"
-        binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position1.DUMMY)
+        binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position.DUMMY)
         val divR4Value = (stmts[12] as Assignment).value
         val binexpr4b = divR4Value as BinaryExpression
         binexpr4b.operator shouldBe "/"
-        binexpr4b.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position1.DUMMY)
+        binexpr4b.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position.DUMMY)
     }
 
     test("constantfolded and silently typecasted for initializervalues") {
@@ -485,23 +490,23 @@ class TestOptimization: FunSpec({
         val z6plus = statements[13] as Assignment
 
         z1decl.name shouldBe "z1"
-        z1init.value shouldBe NumericLiteral(DataType.UBYTE, 10.0, Position1.DUMMY)
+        z1init.value shouldBe NumericLiteral(DataType.UBYTE, 10.0, Position.DUMMY)
         z2decl.name shouldBe "z2"
-        z2init.value shouldBe NumericLiteral(DataType.UBYTE, 255.0, Position1.DUMMY)
+        z2init.value shouldBe NumericLiteral(DataType.UBYTE, 255.0, Position.DUMMY)
         z3decl.name shouldBe "z3"
-        z3init.value shouldBe NumericLiteral(DataType.UBYTE, 1.0, Position1.DUMMY)
+        z3init.value shouldBe NumericLiteral(DataType.UBYTE, 1.0, Position.DUMMY)
         z4decl.name shouldBe "z4"
-        z4init.value shouldBe NumericLiteral(DataType.UBYTE, 0.0, Position1.DUMMY)
+        z4init.value shouldBe NumericLiteral(DataType.UBYTE, 0.0, Position.DUMMY)
         z5decl.name shouldBe "z5"
         (z5init.value as? IdentifierReference)?.nameInSource shouldBe listOf("z1")
         z5plus.isAugmentable shouldBe true
         (z5plus.value as BinaryExpression).operator shouldBe "+"
-        (z5plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position1.DUMMY)
+        (z5plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position.DUMMY)
         z6decl.name shouldBe "z6"
         (z6init.value as? IdentifierReference)?.nameInSource shouldBe listOf("z1")
         z6plus.isAugmentable shouldBe true
         (z6plus.value as BinaryExpression).operator shouldBe "-"
-        (z6plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position1.DUMMY)
+        (z6plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position.DUMMY)
     }
 
     test("force_output option should work with optimizing memwrite assignment") {
@@ -655,12 +660,12 @@ class TestOptimization: FunSpec({
         stmts.filterIsInstance<Assignment>().size shouldBe 5
         val assignXX1 = stmts[1] as Assignment
         assignXX1.target.identifier!!.nameInSource shouldBe listOf("xx")
-        assignXX1.value shouldBe NumericLiteral(DataType.UBYTE, 20.0, Position1.DUMMY)
+        assignXX1.value shouldBe NumericLiteral(DataType.UBYTE, 20.0, Position.DUMMY)
         val assignXX2 = stmts.last() as Assignment
         assignXX2.target.identifier!!.nameInSource shouldBe listOf("xx")
         val xxValue = assignXX2.value as BinaryExpression
         xxValue.operator shouldBe "+"
         (xxValue.left as? IdentifierReference)?.nameInSource shouldBe listOf("xx")
-        xxValue.right shouldBe NumericLiteral(DataType.UBYTE, 10.0, Position1.DUMMY)
+        xxValue.right shouldBe NumericLiteral(DataType.UBYTE, 10.0, Position.DUMMY)
     }
 })

compiler/test/TestPipes.kt

@@ -11,10 +11,10 @@ import prog8.ast.statements.Assignment
 import prog8.ast.statements.FunctionCallStatement
 import prog8.ast.statements.Pipe
 import prog8.ast.statements.VarDecl
+import prog8.code.core.DataType
+import prog8.code.core.Position
 import prog8.codegen.target.C64Target
 import prog8.compiler.astprocessing.AstPreprocessor
-import prog8.compilerinterface.DataType
-import prog8.compilerinterface.Position
 import prog8.parser.Prog8Parser.parseModule
 import prog8.parser.SourceCode
 import prog8tests.helpers.*

compiler/test/TestStringEncodings.kt

@@ -6,7 +6,6 @@ import com.github.michaelbull.result.getOrElse
 import io.kotest.assertions.withClue
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
-import io.kotest.matchers.shouldNot
 import io.kotest.matchers.shouldNotBe
 import io.kotest.matchers.string.shouldContain
 import prog8.codegen.target.C64Target

compiler/test/TestSubroutines.kt

@@ -11,8 +11,8 @@ import prog8.ast.expressions.DirectMemoryRead
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.*
+import prog8.code.core.DataType
 import prog8.codegen.target.C64Target
-import prog8.compilerinterface.DataType
 import prog8tests.helpers.ErrorReporterForTests
 import prog8tests.helpers.compileText
 

compiler/test/TestSymbolTable.kt

@@ -4,6 +4,8 @@ import io.kotest.assertions.fail
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
+import prog8.code.core.DataType
+import prog8.code.core.Position
 import prog8.compilerinterface.*
 
 class TestSymbolTable: FunSpec({

compiler/test/ZeropageTests.kt

@@ -12,6 +12,7 @@ import io.kotest.matchers.collections.shouldNotBeIn
 import io.kotest.matchers.comparables.shouldBeGreaterThan
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
+import prog8.code.core.DataType
 import prog8.codegen.target.C64Target
 import prog8.codegen.target.Cx16Target
 import prog8.codegen.target.c64.C64Zeropage

compiler/test/ast/TestIdentifierRef.kt

@@ -9,7 +9,7 @@ import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.expressions.PrefixExpression
 import prog8.ast.statements.*
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 import prog8.parser.Prog8Parser
 import prog8.parser.SourceCode
 import prog8tests.helpers.DummyFunctions

compiler/test/ast/TestIntermediateAst.kt

@@ -4,9 +4,9 @@ import io.kotest.assertions.fail
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.ints.shouldBeGreaterThan
 import io.kotest.matchers.shouldBe
+import prog8.code.ast.PtVariable
 import prog8.codegen.target.C64Target
 import prog8.compiler.IntermediateAstMaker
-import prog8.compilerinterface.intermediate.PtVariable
 import prog8tests.helpers.compileText
 
 class TestIntermediateAst: FunSpec({

compiler/test/ast/TestProg8Parser.kt

@@ -17,11 +17,11 @@ import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
+import prog8.code.core.DataType
+import prog8.code.core.Encoding
+import prog8.code.core.Position
 import prog8.codegen.target.C64Target
 import prog8.codegen.target.cbm.PetsciiEncoding
-import prog8.compilerinterface.DataType
-import prog8.compilerinterface.Encoding
-import prog8.compilerinterface.Position
 import prog8.parser.ParseError
 import prog8.parser.Prog8Parser.parseModule
 import prog8.parser.SourceCode

compiler/test/ast/TestProgram.kt

@@ -10,7 +10,7 @@ import io.kotest.matchers.types.shouldBeSameInstanceAs
 import prog8.ast.Module
 import prog8.ast.Program
 import prog8.ast.internedStringsModuleName
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 import prog8.parser.SourceCode
 import prog8tests.helpers.DummyFunctions
 import prog8tests.helpers.DummyMemsizer

compiler/test/ast/TestSubroutines.kt

@@ -4,7 +4,7 @@ import io.kotest.core.spec.style.AnnotationSpec
 import io.kotest.matchers.shouldBe
 import prog8.ast.statements.Block
 import prog8.ast.statements.Subroutine
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
 import prog8.parser.Prog8Parser.parseModule
 import prog8.parser.SourceCode
 

compiler/test/ast/TestVarious.kt

@@ -4,8 +4,8 @@ import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
 import prog8.ast.statements.InlineAssembly
+import prog8.code.core.Position
 import prog8.codegen.target.C64Target
-import prog8.compilerinterface.Position
 import prog8tests.helpers.compileText
 
 class TestVarious: FunSpec({

compiler/test/codegeneration/TestAsmGenSymbols.kt

@@ -8,11 +8,17 @@ import prog8.ast.expressions.AddressOf
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.*
+import prog8.code.core.DataType
+import prog8.code.core.Position
+import prog8.code.core.RegisterOrPair
 import prog8.codegen.cpu6502.AsmGen
 import prog8.codegen.target.C64Target
 import prog8.codegen.target.c64.C64Zeropage
 import prog8.compiler.astprocessing.SymbolTableMaker
-import prog8.compilerinterface.*
+import prog8.compilerinterface.CbmPrgLauncherType
+import prog8.compilerinterface.CompilationOptions
+import prog8.compilerinterface.OutputType
+import prog8.compilerinterface.ZeropageType
 import prog8.parser.SourceCode
 import prog8tests.helpers.DummyFunctions
 import prog8tests.helpers.DummyMemsizer

compiler/test/helpers/Dummies.kt

@@ -4,9 +4,11 @@ import prog8.ast.IBuiltinFunctions
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.InferredTypes
 import prog8.ast.expressions.NumericLiteral
-import prog8.ast.statements.RegisterOrStatusflag
 import prog8.ast.statements.Subroutine
-import prog8.compilerinterface.*
+import prog8.code.core.*
+import prog8.compilerinterface.ICompilationTarget
+import prog8.compilerinterface.IMachineDefinition
+
 
 internal object DummyFunctions : IBuiltinFunctions {
     override val names: Set<String> = emptySet()

compiler/test/helpers/ErrorReporterForTests.kt

@@ -1,7 +1,7 @@
 package prog8tests.helpers
 
+import prog8.code.core.Position
 import prog8.compilerinterface.IErrorReporter
-import prog8.compilerinterface.Position
 
 internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true, private val keepMessagesAfterReporting: Boolean=false): IErrorReporter {
 

compilerAst/compilerAst.iml

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

compilerAst/src/prog8/ast/AstToSourceTextConverter.kt

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

compilerAst/src/prog8/ast/AstToplevel.kt

@@ -7,8 +7,8 @@ import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstVisitor
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 import prog8.parser.SourceCode
 
 const val internedStringsModuleName = "prog8_interned_strings"

compilerAst/src/prog8/ast/Extensions.kt

@@ -4,10 +4,10 @@ import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.InferredTypes
 import prog8.ast.statements.VarDecl
 import prog8.ast.statements.VarDeclOrigin
+import prog8.ast.statements.VarDeclType
 import prog8.ast.statements.ZeropageWish
-import prog8.compilerinterface.DataType
+import prog8.code.core.DataType
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
-import prog8.compilerinterface.VarDeclType
 
 
 fun Program.getTempVar(dt: DataType, altNames: Boolean=false): Pair<List<String>, VarDecl> {

compilerAst/src/prog8/ast/IBuiltinFunctions.kt

@@ -3,7 +3,7 @@ package prog8.ast
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.InferredTypes
 import prog8.ast.expressions.NumericLiteral
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 
 interface IBuiltinFunctions {
     val names: Set<String>

compilerAst/src/prog8/ast/Program.kt

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

compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt

@@ -2,10 +2,11 @@ package prog8.ast.antlr
 
 import org.antlr.v4.runtime.ParserRuleContext
 import org.antlr.v4.runtime.tree.TerminalNode
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.SyntaxError
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
-import prog8.compilerinterface.*
+import prog8.code.core.*
 import prog8.parser.Prog8ANTLRParser
 import prog8.parser.SourceCode
 import java.nio.file.Path

compilerAst/src/prog8/ast/antlr/EscapeChars.kt

@@ -1,7 +1,7 @@
 package prog8.ast.antlr
 
 import prog8.ast.base.SyntaxError
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 
 fun escape(str: String): String {
     val es = str.map {

compilerAst/src/prog8/ast/base/Errors.kt

@@ -1,7 +1,7 @@
 package prog8.ast.base
 
 import prog8.ast.expressions.IdentifierReference
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 
 /**
  * A severe problem in the Ast (such as internal inconsistency or failed invariant)

compilerAst/src/prog8/ast/expressions/AstExpressions.kt

@@ -2,11 +2,13 @@ package prog8.ast.expressions
 
 import prog8.ast.*
 import prog8.ast.antlr.escape
-import prog8.ast.base.*
+import prog8.ast.base.ExpressionError
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.UndefinedSymbolError
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstVisitor
-import prog8.compilerinterface.*
+import prog8.code.core.*
 import java.util.*
 import kotlin.math.abs
 import kotlin.math.round

compilerAst/src/prog8/ast/expressions/InferredTypes.kt

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

compilerAst/src/prog8/ast/statements/AstStatements.kt

@@ -1,11 +1,12 @@
 package prog8.ast.statements
 
 import prog8.ast.*
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.SyntaxError
 import prog8.ast.expressions.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstVisitor
-import prog8.compilerinterface.*
+import prog8.code.core.*
 
 
 interface INamedStatement {
@@ -65,8 +66,6 @@ class BuiltinFunctionPlaceholder(override val name: String, override val positio
     override fun copy() = throw NotImplementedError("no support for duplicating a BuiltinFunctionStatementPlaceholder")
 }
 
-data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?)
-
 class Block(override val name: String,
             val address: UInt?,
             override var statements: MutableList<Statement>,
@@ -182,6 +181,12 @@ enum class VarDeclOrigin {
     AUTOGENERATED
 }
 
+enum class VarDeclType {
+    VAR,
+    CONST,
+    MEMORY
+}
+
 
 class VarDecl(val type: VarDeclType,
               val origin: VarDeclOrigin,

compilerAst/src/prog8/compilerinterface/Base.kt

@@ -1,212 +0,0 @@
-package prog8.compilerinterface
-
-import kotlin.io.path.Path
-import kotlin.io.path.absolute
-import kotlin.math.abs
-
-
-/**************************** AST Data classes ****************************/
-
-enum class DataType {
-    UBYTE,              // pass by value
-    BYTE,               // pass by value
-    UWORD,              // pass by value
-    WORD,               // pass by value
-    FLOAT,              // pass by value
-    STR,                // pass by reference
-    ARRAY_UB,           // pass by reference
-    ARRAY_B,            // pass by reference
-    ARRAY_UW,           // pass by reference
-    ARRAY_W,            // pass by reference
-    ARRAY_F,            // pass by reference
-    UNDEFINED;
-
-    /**
-     * is the type assignable to the given other type (perhaps via a typecast) without loss of precision?
-     */
-    infix fun isAssignableTo(targetType: DataType) =
-            when(this) {
-                UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, FLOAT)
-                BYTE -> targetType.oneOf(BYTE, WORD, FLOAT)
-                UWORD -> targetType.oneOf(UWORD, FLOAT)
-                WORD -> targetType.oneOf(WORD, FLOAT)
-                FLOAT -> targetType == FLOAT
-                STR -> targetType.oneOf(STR, UWORD)
-                in ArrayDatatypes -> targetType == this
-                else -> false
-            }
-
-    fun oneOf(vararg types: DataType) = this in types
-
-    infix fun largerThan(other: DataType) =
-            when {
-                this == other -> false
-                this in ByteDatatypes -> false
-                this in WordDatatypes -> other in ByteDatatypes
-                this== STR && other== UWORD || this== UWORD && other== STR -> false
-                else -> true
-            }
-
-    infix fun equalsSize(other: DataType) =
-            when {
-                this == other -> true
-                this in ByteDatatypes -> other in ByteDatatypes
-                this in WordDatatypes -> other in WordDatatypes
-                this== STR && other== UWORD || this== UWORD && other== STR -> true
-                else -> false
-            }
-}
-
-enum class CpuRegister {
-    A,
-    X,
-    Y;
-
-    fun asRegisterOrPair(): RegisterOrPair = when(this) {
-        A -> RegisterOrPair.A
-        X -> RegisterOrPair.X
-        Y -> RegisterOrPair.Y
-    }
-}
-
-enum class RegisterOrPair {
-    A,
-    X,
-    Y,
-    AX,
-    AY,
-    XY,
-    FAC1,
-    FAC2,
-    // cx16 virtual registers:
-    R0, R1, R2, R3, R4, R5, R6, R7,
-    R8, R9, R10, R11, R12, R13, R14, R15;
-
-    companion object {
-        val names by lazy { values().map { it.toString()} }
-    }
-
-    fun asCpuRegister(): CpuRegister = when(this) {
-        A -> CpuRegister.A
-        X -> CpuRegister.X
-        Y -> CpuRegister.Y
-        else -> throw IllegalArgumentException("no cpu hardware register for $this")
-    }
-
-}       // only used in parameter and return value specs in asm subroutines
-
-enum class Statusflag {
-    Pc,
-    Pz,     // don't use
-    Pv,
-    Pn;     // don't use
-
-    companion object {
-        val names by lazy { values().map { it.toString()} }
-    }
-}
-
-enum class BranchCondition {
-    CS,
-    CC,
-    EQ,
-    Z,
-    NE,
-    NZ,
-    VS,
-    VC,
-    MI,
-    NEG,
-    PL,
-    POS
-}
-
-enum class VarDeclType {
-    VAR,
-    CONST,
-    MEMORY
-}
-
-val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE)
-val WordDatatypes = arrayOf(DataType.UWORD, DataType.WORD)
-val IntegerDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
-val NumericDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
-val SignedDatatypes =  arrayOf(DataType.BYTE, DataType.WORD, DataType.FLOAT)
-val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F)
-val StringlyDatatypes = arrayOf(DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B, DataType.UWORD)
-val IterableDatatypes = arrayOf(
-    DataType.STR,
-    DataType.ARRAY_UB, DataType.ARRAY_B,
-    DataType.ARRAY_UW, DataType.ARRAY_W,
-    DataType.ARRAY_F
-)
-val PassByValueDatatypes = NumericDatatypes
-val PassByReferenceDatatypes = IterableDatatypes
-val ArrayToElementTypes = mapOf(
-        DataType.STR to DataType.UBYTE,
-        DataType.ARRAY_B to DataType.BYTE,
-        DataType.ARRAY_UB to DataType.UBYTE,
-        DataType.ARRAY_W to DataType.WORD,
-        DataType.ARRAY_UW to DataType.UWORD,
-        DataType.ARRAY_F to DataType.FLOAT
-)
-val ElementToArrayTypes = mapOf(
-        DataType.BYTE to DataType.ARRAY_B,
-        DataType.UBYTE to DataType.ARRAY_UB,
-        DataType.WORD to DataType.ARRAY_W,
-        DataType.UWORD to DataType.ARRAY_UW,
-        DataType.FLOAT to DataType.ARRAY_F
-)
-val Cx16VirtualRegisters = arrayOf(
-    RegisterOrPair.R0, RegisterOrPair.R1, RegisterOrPair.R2, RegisterOrPair.R3,
-    RegisterOrPair.R4, RegisterOrPair.R5, RegisterOrPair.R6, RegisterOrPair.R7,
-    RegisterOrPair.R8, RegisterOrPair.R9, RegisterOrPair.R10, RegisterOrPair.R11,
-    RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15
-)
-
-
-data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
-    override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
-    fun toClickableStr(): String {
-        val path = Path(file).absolute().normalize()
-        return "file://$path:$line:$startCol:"
-    }
-
-    companion object {
-        val DUMMY = Position("<dummy>", 0, 0, 0)
-    }
-}
-
-
-fun Number.toHex(): String {
-    //  0..15 -> "0".."15"
-    //  16..255 -> "$10".."$ff"
-    //  256..65536 -> "$0100".."$ffff"
-    // negative values are prefixed with '-'.
-    val integer = this.toInt()
-    if(integer<0)
-        return '-' + abs(integer).toHex()
-    return when (integer) {
-        in 0 until 16 -> integer.toString()
-        in 0 until 0x100 -> "$"+integer.toString(16).padStart(2,'0')
-        in 0 until 0x10000 -> "$"+integer.toString(16).padStart(4,'0')
-        else -> throw IllegalArgumentException("number too large for 16 bits $this")
-    }
-}
-
-fun UInt.toHex(): String {
-    //  0..15 -> "0".."15"
-    //  16..255 -> "$10".."$ff"
-    //  256..65536 -> "$0100".."$ffff"
-    return when (this) {
-        in 0u until 16u -> this.toString()
-        in 0u until 0x100u -> "$"+this.toString(16).padStart(2,'0')
-        in 0u until 0x10000u -> "$"+this.toString(16).padStart(4,'0')
-        else -> throw IllegalArgumentException("number too large for 16 bits $this")
-    }
-}
-
-
-interface IMemSizer {
-    fun memorySize(dt: DataType): Int
-}

compilerAst/src/prog8/parser/Prog8Parser.kt

@@ -5,7 +5,7 @@ import prog8.ast.Module
 import prog8.ast.antlr.toAst
 import prog8.ast.statements.Block
 import prog8.ast.statements.Directive
-import prog8.compilerinterface.Position
+import prog8.code.core.Position
 
 
 class ParseError(override var message: String, val position: Position, cause: RuntimeException): Exception(message, cause)