Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2025-01-11 13:29:45 +00:00
Code Issues Projects Releases Wiki Activity

split intermediate representation into separate module

Browse Source
This commit is contained in:
Irmen de Jong 2022-08-27 13:06:44 +02:00
parent 97f4316653
commit 101b33c381
31 changed files with 183 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.idea/misc.xml generated
View File

@ -19,7 +19,7 @@
<component name="FrameworkDetectionExcludesConfiguration">
<type id="Python" />
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="11" project-jdk-type="JavaSDK">
<component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="11" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>

1
.idea/modules.xml generated
View File

@ -14,6 +14,7 @@
<module fileurl="file://$PROJECT_DIR$/docs/docs.iml" filepath="$PROJECT_DIR$/docs/docs.iml" />
<module fileurl="file://$PROJECT_DIR$/examples/examples.iml" filepath="$PROJECT_DIR$/examples/examples.iml" />
<module fileurl="file://$PROJECT_DIR$/httpCompilerService/httpCompilerService.iml" filepath="$PROJECT_DIR$/httpCompilerService/httpCompilerService.iml" />
<module fileurl="file://$PROJECT_DIR$/intermediate/intermediate.iml" filepath="$PROJECT_DIR$/intermediate/intermediate.iml" />
<module fileurl="file://$PROJECT_DIR$/parser/parser.iml" filepath="$PROJECT_DIR$/parser/parser.iml" />
<module fileurl="file://$PROJECT_DIR$/virtualmachine/virtualmachine.iml" filepath="$PROJECT_DIR$/virtualmachine/virtualmachine.iml" />
</modules>

1
codeGenExperimental/build.gradle
View File

@ -26,6 +26,7 @@ compileTestKotlin {
dependencies {
implementation project(':codeAst')
implementation project(':codeCore')
implementation project(':intermediate')
implementation project(':virtualmachine')
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
// implementation "org.jetbrains.kotlin:kotlin-reflect"

1
codeGenExperimental/codeGenExperimental.iml
View File

@ -13,5 +13,6 @@
<orderEntry type="module" module-name="codeAst" />
<orderEntry type="module" module-name="codeCore" />
<orderEntry type="module" module-name="virtualmachine" />
<orderEntry type="module" module-name="intermediate" />
</component>
</module>

11
codeGenExperimental/src/prog8/codegen/experimental/AssignmentGen.kt
View File

@ -1,9 +1,14 @@
package prog8.codegen.experimental
import prog8.code.ast.*
import prog8.code.core.*
import prog8.vm.Opcode
import prog8.vm.VmDataType
import prog8.code.core.AssemblyError
import prog8.code.core.DataType
import prog8.code.core.Position
import prog8.code.core.SignedDatatypes
import prog8.intermediate.IRCodeChunk
import prog8.intermediate.IRCodeInstruction
import prog8.intermediate.Opcode
import prog8.intermediate.VmDataType
internal class AssignmentGen(private val codeGen: CodeGen, private val expressionEval: ExpressionGen) {

4
codeGenExperimental/src/prog8/codegen/experimental/BuiltinFuncGen.kt
View File

@ -5,9 +5,9 @@ import prog8.code.ast.*
import prog8.code.core.AssemblyError
import prog8.code.core.DataType
import prog8.code.core.Position
import prog8.vm.Opcode
import prog8.intermediate.*
import prog8.vm.Syscall
import prog8.vm.VmDataType
internal class BuiltinFuncGen(private val codeGen: CodeGen, private val exprGen: ExpressionGen) {

7
codeGenExperimental/src/prog8/codegen/experimental/CodeGen.kt
View File

@ -5,8 +5,7 @@ import prog8.code.StStaticVariable
import prog8.code.SymbolTable
import prog8.code.ast.*
import prog8.code.core.*
import prog8.vm.Opcode
import prog8.vm.VmDataType
import prog8.intermediate.*
import kotlin.math.pow
@ -773,8 +772,8 @@ class CodeGen(internal val program: PtProgram,
is PtScopeVarsDecls -> { /* vars should be looked up via symbol table */ }
is PtSub -> {
val vmsub = IRSubroutine(child.scopedName, child.returntype, child.position)
for (child in child.children) {
vmsub += translateNode(child)
for (line in child.children) {
vmsub += translateNode(line)
}
vmblock += vmsub
}

3
codeGenExperimental/src/prog8/codegen/experimental/ExpressionGen.kt
View File

@ -5,8 +5,7 @@ import prog8.code.StStaticVariable
import prog8.code.StSub
import prog8.code.ast.*
import prog8.code.core.*
import prog8.vm.Opcode
import prog8.vm.VmDataType
import prog8.intermediate.*
internal class ExpressionGen(private val codeGen: CodeGen) {

1
codeGenVirtual/build.gradle
View File

@ -27,6 +27,7 @@ compileTestKotlin {
dependencies {
implementation project(':codeAst')
implementation project(':codeCore')
implementation project(':intermediate')
implementation project(':virtualmachine')
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
// implementation "org.jetbrains.kotlin:kotlin-reflect"

1
codeGenVirtual/codeGenVirtual.iml
View File

@ -15,5 +15,6 @@
<orderEntry type="module" module-name="codeAst" />
<orderEntry type="module" module-name="codeCore" />
<orderEntry type="module" module-name="virtualmachine" />
<orderEntry type="module" module-name="intermediate" />
</component>
</module>

8
codeGenVirtual/src/prog8/codegen/virtual/AssemblyProgram.kt
View File

@ -3,10 +3,10 @@ package prog8.codegen.virtual
import prog8.code.core.AssemblyError
import prog8.code.core.CompilationOptions
import prog8.code.core.IAssemblyProgram
import prog8.vm.Instruction
import prog8.vm.Opcode
import prog8.vm.OpcodesWithAddress
import prog8.vm.VmDataType
import prog8.intermediate.Instruction
import prog8.intermediate.Opcode
import prog8.intermediate.OpcodesWithAddress
import prog8.intermediate.VmDataType
import java.io.BufferedWriter
import java.nio.file.Path
import kotlin.io.path.bufferedWriter

8
codeGenVirtual/src/prog8/codegen/virtual/AssignmentGen.kt
View File

@ -1,9 +1,11 @@
package prog8.codegen.virtual
import prog8.code.ast.*
import prog8.code.core.*
import prog8.vm.Opcode
import prog8.vm.VmDataType
import prog8.code.core.AssemblyError
import prog8.code.core.DataType
import prog8.code.core.SignedDatatypes
import prog8.intermediate.Opcode
import prog8.intermediate.VmDataType
internal class AssignmentGen(private val codeGen: CodeGen, private val expressionEval: ExpressionGen) {

4
codeGenVirtual/src/prog8/codegen/virtual/BuiltinFuncGen.kt
View File

@ -4,9 +4,9 @@ import prog8.code.StStaticVariable
import prog8.code.ast.*
import prog8.code.core.AssemblyError
import prog8.code.core.DataType
import prog8.vm.Opcode
import prog8.intermediate.Opcode
import prog8.intermediate.VmDataType
import prog8.vm.Syscall
import prog8.vm.VmDataType
internal class BuiltinFuncGen(private val codeGen: CodeGen, private val exprGen: ExpressionGen) {

4
codeGenVirtual/src/prog8/codegen/virtual/CodeGen.kt
View File

@ -4,8 +4,8 @@ import prog8.code.StStaticVariable
import prog8.code.SymbolTable
import prog8.code.ast.*
import prog8.code.core.*
import prog8.vm.Opcode
import prog8.vm.VmDataType
import prog8.intermediate.Opcode
import prog8.intermediate.VmDataType
import kotlin.math.pow

4
codeGenVirtual/src/prog8/codegen/virtual/ExpressionGen.kt
View File

@ -5,8 +5,8 @@ import prog8.code.StStaticVariable
import prog8.code.StSub
import prog8.code.ast.*
import prog8.code.core.*
import prog8.vm.Opcode
import prog8.vm.VmDataType
import prog8.intermediate.Opcode
import prog8.intermediate.VmDataType
internal class ExpressionGen(private val codeGen: CodeGen) {

7
codeGenVirtual/src/prog8/codegen/virtual/VmPeepholeOptimizer.kt
View File

@ -1,9 +1,8 @@
package prog8.codegen.virtual
import prog8.vm.Instruction
import prog8.vm.Opcode
import prog8.vm.VmDataType
import prog8.intermediate.Instruction
import prog8.intermediate.Opcode
import prog8.intermediate.VmDataType
class VmPeepholeOptimizer(private val vmprog: AssemblyProgram) {
fun optimize() {

4
codeGenVirtual/test/TestVmPeepholeOpt.kt
View File

@ -5,8 +5,8 @@ import io.kotest.matchers.shouldBe
import prog8.code.SymbolTable
import prog8.code.ast.PtProgram
import prog8.codegen.virtual.*
import prog8.vm.Opcode
import prog8.vm.VmDataType
import prog8.intermediate.Opcode
import prog8.intermediate.VmDataType
import prog8tests.vm.helpers.DummyMemsizer
import prog8tests.vm.helpers.DummyStringEncoder

5
codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt
View File

@ -6,7 +6,10 @@ import prog8.ast.Program
import prog8.ast.base.FatalAstException
import prog8.ast.expressions.*
import prog8.ast.maySwapOperandOrder
import prog8.ast.statements.*
import prog8.ast.statements.AnonymousScope
import prog8.ast.statements.Assignment
import prog8.ast.statements.IfElse
import prog8.ast.statements.Jump
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification
import prog8.code.core.*

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

@ -1,8 +1,11 @@
package prog8.compiler.astprocessing
import prog8.ast.*
import prog8.ast.IStatementContainer
import prog8.ast.Node
import prog8.ast.Program
import prog8.ast.base.FatalAstException
import prog8.ast.expressions.*
import prog8.ast.getTempVar
import prog8.ast.statements.*
import prog8.ast.walk.AstWalker
import prog8.ast.walk.IAstModification

62
intermediate/build.gradle Normal file
View File

@ -0,0 +1,62 @@
plugins {
id 'java'
id 'application'
id "org.jetbrains.kotlin.jvm"
id "io.kotest" version "0.3.9"
}
java {
toolchain {
languageVersion = JavaLanguageVersion.of(javaVersion)
}
}
compileKotlin {
kotlinOptions {
jvmTarget = javaVersion
}
}
compileTestKotlin {
kotlinOptions {
jvmTarget = javaVersion
}
}
dependencies {
implementation project(':codeCore')
implementation project(':codeAst')
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.3.2'
}
sourceSets {
main {
java {
srcDirs = ["${project.projectDir}/src"]
}
resources {
srcDirs = ["${project.projectDir}/res"]
}
}
test {
java {
srcDir "${project.projectDir}/test"
}
}
}
test {
// Enable JUnit 5 (Gradle 4.6+).
useJUnitPlatform()
// Always run tests, even when nothing changed.
dependsOn 'cleanTest'
// Show test results.
testLogging {
events "skipped", "failed"
}
}

17
intermediate/intermediate.iml Normal file
View File

@ -0,0 +1,17 @@
<?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" />
<sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="KotlinJavaRuntime" level="project" />
<orderEntry type="module" module-name="codeAst" />
<orderEntry type="module" module-name="codeCore" />
<orderEntry type="library" name="io.kotest.assertions.core.jvm" level="project" />
<orderEntry type="library" name="io.kotest.runner.junit5.jvm" level="project" />
</component>
</module>

2
codeGenExperimental/src/prog8/codegen/experimental/IRFileWriter.kt → intermediate/src/prog8/intermediate/IRFileWriter.kt
View File

@ -1,4 +1,4 @@
package prog8.codegen.experimental
package prog8.intermediate
import prog8.code.core.*
import java.io.BufferedWriter

17
codeGenExperimental/src/prog8/codegen/experimental/IRPeepholeOptimizer.kt → intermediate/src/prog8/intermediate/IRPeepholeOptimizer.kt
View File

@ -1,9 +1,4 @@
package prog8.codegen.experimental
import prog8.vm.Instruction
import prog8.vm.Opcode
import prog8.vm.VmDataType
package prog8.intermediate
class IRPeepholeOptimizer(private val vmprog: IRProgram) {
fun optimize() {
@ -192,13 +187,3 @@ class IRPeepholeOptimizer(private val vmprog: IRProgram) {
return changed
}
}
private interface ICodeChange { // TODO not used? remove?
fun perform(block: IRCodeChunk)
class Remove(val idx: Int): ICodeChange {
override fun perform(block: IRCodeChunk) {
block.lines.removeAt(idx)
}
}
}

8
codeGenExperimental/src/prog8/codegen/experimental/IRProgram.kt → intermediate/src/prog8/intermediate/IRProgram.kt
View File

@ -1,4 +1,4 @@
package prog8.codegen.experimental
package prog8.intermediate
import prog8.code.SymbolTable
import prog8.code.ast.PtBlock
@ -6,10 +6,6 @@ import prog8.code.core.CompilationOptions
import prog8.code.core.DataType
import prog8.code.core.IStringEncoding
import prog8.code.core.Position
import prog8.vm.Instruction
import prog8.vm.Opcode
import prog8.vm.OpcodesWithAddress
import prog8.vm.VmDataType
import java.nio.file.Path
// TODO: move this Intermedate Representation into the actual compiler core, code gen modules can receive it as input rather than an Ast.
@ -76,7 +72,7 @@ class IRCodeInstruction(
fpReg2: Int?=null, // 0-$ffff
value: Int?=null, // 0-$ffff
fpValue: Float?=null,
labelSymbol: List<String>?=null // alternative to value for branch/call/jump labels
labelSymbol: List<String>?=null // alternative to value
): IRCodeLine() {
val ins = Instruction(opcode, type, reg1, reg2, fpReg1, fpReg2, value, fpValue, labelSymbol)

2
virtualmachine/src/prog8/vm/Instructions.kt → intermediate/src/prog8/intermediate/Instructions.kt
View File

@ -1,4 +1,4 @@
package prog8.vm
package prog8.intermediate
/*

2
virtualmachine/test/TestInstructions.kt → intermediate/test/TestInstructions.kt
View File

@ -2,7 +2,7 @@ import io.kotest.assertions.throwables.shouldThrow
import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.shouldBe
import io.kotest.matchers.shouldNotBe
import prog8.vm.*
import prog8.intermediate.*
class TestInstructions: FunSpec({

1
settings.gradle
View File

@ -2,6 +2,7 @@ include(
':parser',
':codeCore',
':codeAst',
':intermediate',
':compilerAst',
':codeOptimizers',
':virtualmachine',

1
virtualmachine/build.gradle
View File

@ -26,6 +26,7 @@ compileTestKotlin {
dependencies {
implementation project(':codeCore')
implementation project(':intermediate')
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.3.2'

1
virtualmachine/src/prog8/vm/Assembler.kt
View File

@ -1,6 +1,7 @@
package prog8.vm
import prog8.code.core.unescape
import prog8.intermediate.*
class Assembler {

89
virtualmachine/src/prog8/vm/VirtualMachine.kt
View File

@ -1,6 +1,9 @@
package prog8.vm
import prog8.code.target.virtual.IVirtualMachineRunner
import prog8.intermediate.Instruction
import prog8.intermediate.Opcode
import prog8.intermediate.VmDataType
import java.awt.Color
import java.awt.Toolkit
import java.util.*
@ -269,7 +272,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
throw IllegalArgumentException("can't POP a float")
}
}
setResultReg(i.reg1!!, value, i.type)
setResultReg(i.reg1!!, value, i.type!!)
pc++
}
@ -669,9 +672,9 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
private fun InsINC(i: Instruction) {
when(i.type!!) {
VmDataType.BYTE -> registers.setUB(i.reg1!!, (registers.getUB(i.reg1)+1u).toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, (registers.getUW(i.reg1)+1u).toUShort())
VmDataType.FLOAT -> registers.setFloat(i.fpReg1!!, registers.getFloat(i.fpReg1)+1f)
VmDataType.BYTE -> registers.setUB(i.reg1!!, (registers.getUB(i.reg1!!)+1u).toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, (registers.getUW(i.reg1!!)+1u).toUShort())
VmDataType.FLOAT -> registers.setFloat(i.fpReg1!!, registers.getFloat(i.fpReg1!!)+1f)
}
pc++
}
@ -688,27 +691,27 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
private fun InsDEC(i: Instruction) {
when(i.type!!) {
VmDataType.BYTE -> registers.setUB(i.reg1!!, (registers.getUB(i.reg1)-1u).toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, (registers.getUW(i.reg1)-1u).toUShort())
VmDataType.FLOAT -> registers.setFloat(i.fpReg1!!, registers.getFloat(i.fpReg1)-1f)
VmDataType.BYTE -> registers.setUB(i.reg1!!, (registers.getUB(i.reg1!!)-1u).toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, (registers.getUW(i.reg1!!)-1u).toUShort())
VmDataType.FLOAT -> registers.setFloat(i.fpReg1!!, registers.getFloat(i.fpReg1!!)-1f)
}
pc++
}
private fun InsDECM(i: Instruction) {
when(i.type!!) {
VmDataType.BYTE -> memory.setUB(i.value!!, (memory.getUB(i.value)-1u).toUByte())
VmDataType.WORD -> memory.setUW(i.value!!, (memory.getUW(i.value)-1u).toUShort())
VmDataType.FLOAT -> memory.setFloat(i.value!!, memory.getFloat(i.value)-1f)
VmDataType.BYTE -> memory.setUB(i.value!!, (memory.getUB(i.value!!)-1u).toUByte())
VmDataType.WORD -> memory.setUW(i.value!!, (memory.getUW(i.value!!)-1u).toUShort())
VmDataType.FLOAT -> memory.setFloat(i.value!!, memory.getFloat(i.value!!)-1f)
}
pc++
}
private fun InsNEG(i: Instruction) {
when(i.type!!) {
VmDataType.BYTE -> registers.setUB(i.reg1!!, (-registers.getUB(i.reg1).toInt()).toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, (-registers.getUW(i.reg1).toInt()).toUShort())
VmDataType.FLOAT -> registers.setFloat(i.fpReg1!!, -registers.getFloat(i.fpReg1))
VmDataType.BYTE -> registers.setUB(i.reg1!!, (-registers.getUB(i.reg1!!).toInt()).toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, (-registers.getUW(i.reg1!!).toInt()).toUShort())
VmDataType.FLOAT -> registers.setFloat(i.fpReg1!!, -registers.getFloat(i.fpReg1!!))
}
pc++
}
@ -731,7 +734,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
val left = registers.getFloat(i.fpReg1!!)
val right = registers.getFloat(i.fpReg2!!)
val result = arithFloat(left, "+", right)
registers.setFloat(i.fpReg1, result)
registers.setFloat(i.fpReg1!!, result)
}
}
pc++
@ -744,7 +747,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
VmDataType.FLOAT -> {
val left = registers.getFloat(i.fpReg1!!)
val result = arithFloat(left, "+", i.fpValue!!)
registers.setFloat(i.fpReg1, result)
registers.setFloat(i.fpReg1!!, result)
}
}
pc++
@ -773,7 +776,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
val left = registers.getFloat(i.fpReg1!!)
val right = registers.getFloat(i.fpReg2!!)
val result = arithFloat(left, "-", right)
registers.setFloat(i.fpReg1, result)
registers.setFloat(i.fpReg1!!, result)
}
}
pc++
@ -786,7 +789,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
VmDataType.FLOAT -> {
val left = registers.getFloat(i.fpReg1!!)
val result = arithFloat(left, "-", i.fpValue!!)
registers.setFloat(i.fpReg1, result)
registers.setFloat(i.fpReg1!!, result)
}
}
pc++
@ -815,7 +818,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
val left = registers.getFloat(i.fpReg1!!)
val right = registers.getFloat(i.fpReg2!!)
val result = arithFloat(left, "*", right)
registers.setFloat(i.fpReg1, result)
registers.setFloat(i.fpReg1!!, result)
}
}
pc++
@ -828,7 +831,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
VmDataType.FLOAT -> {
val left = registers.getFloat(i.fpReg1!!)
val result = arithFloat(left, "*", i.fpValue!!)
registers.setFloat(i.fpReg1, result)
registers.setFloat(i.fpReg1!!, result)
}
}
pc++
@ -885,7 +888,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
val left = registers.getFloat(i.fpReg1!!)
val right = registers.getFloat(i.fpReg2!!)
val result = arithFloat(left, "/", right)
registers.setFloat(i.fpReg1, result)
registers.setFloat(i.fpReg1!!, result)
}
}
pc++
@ -898,7 +901,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
VmDataType.FLOAT -> {
val left = registers.getFloat(i.fpReg1!!)
val result = arithFloat(left, "/", i.fpValue!!)
registers.setFloat(i.fpReg1, result)
registers.setFloat(i.fpReg1!!, result)
}
}
pc++
@ -1281,7 +1284,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
private fun InsEXT(i: Instruction) {
when(i.type!!){
VmDataType.BYTE -> registers.setUW(i.reg1!!, registers.getUB(i.reg1).toUShort())
VmDataType.BYTE -> registers.setUW(i.reg1!!, registers.getUB(i.reg1!!).toUShort())
VmDataType.WORD -> throw IllegalArgumentException("ext.w not yet supported, requires 32 bits registers")
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
}
@ -1290,7 +1293,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
private fun InsEXTS(i: Instruction) {
when(i.type!!){
VmDataType.BYTE -> registers.setSW(i.reg1!!, registers.getSB(i.reg1).toShort())
VmDataType.BYTE -> registers.setSW(i.reg1!!, registers.getSB(i.reg1!!).toShort())
VmDataType.WORD -> throw IllegalArgumentException("exts.w not yet supported, requires 32 bits registers")
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
}
@ -1309,8 +1312,8 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
private fun InsAND(i: Instruction) {
when(i.type!!) {
VmDataType.BYTE -> registers.setUB(i.reg1!!, registers.getUB(i.reg1) and i.value!!.toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, registers.getUW(i.reg1) and i.value!!.toUShort())
VmDataType.BYTE -> registers.setUB(i.reg1!!, registers.getUB(i.reg1!!) and i.value!!.toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, registers.getUW(i.reg1!!) and i.value!!.toUShort())
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
}
pc++
@ -1346,8 +1349,8 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
private fun InsOR(i: Instruction) {
when(i.type!!) {
VmDataType.BYTE -> registers.setUB(i.reg1!!, registers.getUB(i.reg1) or i.value!!.toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, registers.getUW(i.reg1) or i.value!!.toUShort())
VmDataType.BYTE -> registers.setUB(i.reg1!!, registers.getUB(i.reg1!!) or i.value!!.toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, registers.getUW(i.reg1!!) or i.value!!.toUShort())
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
}
pc++
@ -1383,8 +1386,8 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
private fun InsXOR(i: Instruction) {
when(i.type!!) {
VmDataType.BYTE -> registers.setUB(i.reg1!!, registers.getUB(i.reg1) xor i.value!!.toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, registers.getUW(i.reg1) xor i.value!!.toUShort())
VmDataType.BYTE -> registers.setUB(i.reg1!!, registers.getUB(i.reg1!!) xor i.value!!.toUByte())
VmDataType.WORD -> registers.setUW(i.reg1!!, registers.getUW(i.reg1!!) xor i.value!!.toUShort())
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
}
pc++
@ -1410,8 +1413,8 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
private fun InsINV(i: Instruction) {
when(i.type!!) {
VmDataType.BYTE -> registers.setUB(i.reg1!!, registers.getUB(i.reg1).inv())
VmDataType.WORD -> registers.setUW(i.reg1!!, registers.getUW(i.reg1).inv())
VmDataType.BYTE -> registers.setUB(i.reg1!!, registers.getUB(i.reg1!!).inv())
VmDataType.WORD -> registers.setUW(i.reg1!!, registers.getUW(i.reg1!!).inv())
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
}
pc++
@ -1462,12 +1465,12 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
VmDataType.BYTE -> {
val value = registers.getSB(i.reg1!!).toInt()
statusCarry = (value and 1)!=0
registers.setSB(i.reg1, (value shr 1).toByte())
registers.setSB(i.reg1!!, (value shr 1).toByte())
}
VmDataType.WORD -> {
val value = registers.getSW(i.reg1!!).toInt()
statusCarry = (value and 1)!=0
registers.setSW(i.reg1, (value shr 1).toShort())
registers.setSW(i.reg1!!, (value shr 1).toShort())
}
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
}
@ -1527,12 +1530,12 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
VmDataType.BYTE -> {
val value = registers.getUB(i.reg1!!).toInt()
statusCarry = (value and 1)!=0
registers.setUB(i.reg1, (value shr 1).toUByte())
registers.setUB(i.reg1!!, (value shr 1).toUByte())
}
VmDataType.WORD -> {
val value = registers.getUW(i.reg1!!).toInt()
statusCarry = (value and 1)!=0
registers.setUW(i.reg1, (value shr 1).toUShort())
registers.setUW(i.reg1!!, (value shr 1).toUShort())
}
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
}
@ -1597,12 +1600,12 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
VmDataType.BYTE -> {
val value = registers.getUB(i.reg1!!).toInt()
statusCarry = (value and 0x80)!=0
registers.setUB(i.reg1, (value shl 1).toUByte())
registers.setUB(i.reg1!!, (value shl 1).toUByte())
}
VmDataType.WORD -> {
val value = registers.getUW(i.reg1!!).toInt()
statusCarry = (value and 0x8000)!=0
registers.setUW(i.reg1, (value shl 1).toUShort())
registers.setUW(i.reg1!!, (value shl 1).toUShort())
}
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
}
@ -1638,7 +1641,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
(orig.toUInt().rotateRight(1) or carry).toUByte()
} else
orig.rotateRight(1)
registers.setUB(i.reg1, rotated)
registers.setUB(i.reg1!!, rotated)
}
VmDataType.WORD -> {
val orig = registers.getUW(i.reg1!!)
@ -1648,7 +1651,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
(orig.toUInt().rotateRight(1) or carry).toUShort()
} else
orig.rotateRight(1)
registers.setUW(i.reg1, rotated)
registers.setUW(i.reg1!!, rotated)
}
VmDataType.FLOAT -> {
throw IllegalArgumentException("can't ROR a float")
@ -1701,7 +1704,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
(orig.toUInt().rotateLeft(1) or carry).toUByte()
} else
orig.rotateLeft(1)
registers.setUB(i.reg1, rotated)
registers.setUB(i.reg1!!, rotated)
}
VmDataType.WORD -> {
val orig = registers.getUW(i.reg1!!)
@ -1711,7 +1714,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
(orig.toUInt().rotateLeft(1) or carry).toUShort()
} else
orig.rotateLeft(1)
registers.setUW(i.reg1, rotated)
registers.setUW(i.reg1!!, rotated)
}
VmDataType.FLOAT -> {
throw IllegalArgumentException("can't ROL a float")
@ -1771,7 +1774,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
VmDataType.BYTE -> {
val lsb = registers.getUB(i.reg1!!)
val msb = registers.getUB(i.reg2!!)
registers.setUW(i.reg1, ((msb.toInt() shl 8) or lsb.toInt()).toUShort())
registers.setUW(i.reg1!!, ((msb.toInt() shl 8) or lsb.toInt()).toUShort())
}
VmDataType.WORD -> throw IllegalArgumentException("concat.w not yet supported, requires 32-bits registers")
VmDataType.FLOAT -> throw IllegalArgumentException("invalid float type for this instruction $i")
@ -1822,7 +1825,7 @@ class VirtualMachine(val memory: Memory, program: List<Instruction>) {
private fun InsFPOW(i: Instruction) {
val value = registers.getFloat(i.fpReg1!!)
val exponent = registers.getFloat(i.fpReg2!!)
registers.setFloat(i.fpReg1, value.pow(exponent))
registers.setFloat(i.fpReg1!!, value.pow(exponent))
pc++
}

1
virtualmachine/virtualmachine.iml
View File

@ -13,5 +13,6 @@
<orderEntry type="library" name="io.kotest.assertions.core.jvm" level="project" />
<orderEntry type="library" name="io.kotest.runner.junit5.jvm" level="project" />
<orderEntry type="module" module-name="codeCore" />
<orderEntry type="module" module-name="intermediate" />
</component>
</module>