Finish alpha version of compiler
This commit is contained in:
Gabriel Tofvesson
parent
ca8716ac6d
commit
e6008f5d74
249
compiler.kt
249
compiler.kt
@ -11,7 +11,11 @@ enum class OpCode(val opcode: Int, val useM: Boolean, val useADR: Boolean, val u
|
||||
BNE(7, false, true),
|
||||
CMP(8, true, false),
|
||||
BEQ(9, false, true),
|
||||
HALT(15, false, false, false)
|
||||
HALT(15, false, false, false);
|
||||
|
||||
companion object {
|
||||
fun fromString(name: String) = OpCode.values().firstOrNull{ it.name == name }
|
||||
}
|
||||
}
|
||||
|
||||
enum class Mode(val id: Int) {
|
||||
@ -19,27 +23,35 @@ enum class Mode(val id: Int) {
|
||||
}
|
||||
|
||||
abstract class Instruction(val words: Int) {
|
||||
fun getData(insns: Iterable<Instruction>): ShortArray
|
||||
abstract fun getData(insns: Iterable<Instruction>): ShortArray
|
||||
}
|
||||
|
||||
class Label(val name: String): Instruction(0) {
|
||||
override fun getData(insns: Iterable<Instruction>) = ShortArray(0)
|
||||
}
|
||||
|
||||
class Immediate(val data: Short): Instruction(1) {
|
||||
override fun getData(insns: Iterable<Instruction>) = ShortArray(1){ data }
|
||||
}
|
||||
|
||||
class Operation(val code: OpCode, val reg: Int, val m: Mode, val adr: AddressReference, val immediate: Immediate? = null): Instruction(if(m == Mode.IMMEDIATE) 2 else 1) {
|
||||
constructor(val code: OpCode): this(code, 0, Mode.DIRECT, AddressReference(0))
|
||||
class Operation(val code: OpCode, val reg: Int, val m: Mode, val adr: AddressReference, val immediate: Short? = null): Instruction(if(m == Mode.IMMEDIATE) 2 else 1) {
|
||||
constructor(code: OpCode, reg: Int): this(code, reg, Mode.DIRECT, AddressReference(0)){
|
||||
if(code.useM || code.useADR)
|
||||
throw IllegalArgumentException("Not enough parameters specified for instruction: ${code.name}")
|
||||
}
|
||||
constructor(code: OpCode, m: Mode, adr: AddressReference, immediate: Short? = null): this(code, 0, m, adr, immediate){
|
||||
if(code.useReg)
|
||||
throw IllegalArgumentException("Not enough parameters specified for instruction: ${code.name}")
|
||||
}
|
||||
constructor(code: OpCode): this(code, 0, Mode.DIRECT, AddressReference(0)){
|
||||
if(code.useM || code.useADR || code.useReg)
|
||||
throw IllegalArgumentException("Not enough parameters specified for instruction: ${code.name}")
|
||||
}
|
||||
|
||||
init {
|
||||
if(m == Mode.IMMEDIATE && immediate == null)
|
||||
throw IllegalArgumentException("No immediate argument passed!")
|
||||
}
|
||||
|
||||
override fun getData(insns: Iterable<Instruction>): Short {
|
||||
return shortArrayOf(code.opcode
|
||||
override fun getData(insns: Iterable<Instruction>): ShortArray {
|
||||
val array = ShortArray(words)
|
||||
array[0] = code.opcode
|
||||
.and(0b1111)
|
||||
.shl(12)
|
||||
.or(
|
||||
@ -55,7 +67,9 @@ class Operation(val code: OpCode, val reg: Int, val m: Mode, val adr: AddressRef
|
||||
else 0
|
||||
)
|
||||
.toShort()
|
||||
)
|
||||
if(m == Mode.IMMEDIATE) array[1] = immediate!!
|
||||
|
||||
return array
|
||||
}
|
||||
}
|
||||
|
||||
@ -65,15 +79,204 @@ class AddressReference(private val label: Label?, private val absolute: Int?) {
|
||||
|
||||
fun getAddress(insns: Iterable<Instruction>): Int {
|
||||
if(absolute != null) return absolute
|
||||
insns.forEachIndexed{ index, insn ->
|
||||
if(insn == label)
|
||||
return@getAddress index*2
|
||||
}
|
||||
|
||||
throw RuntimeException("Label cannot be found in set of instructions!")
|
||||
var addrOff = 0
|
||||
for(insn in insns)
|
||||
if(insn == label) return addrOff
|
||||
else addrOff += insn.words
|
||||
|
||||
throw RuntimeException("Found reference to undeclared label!")
|
||||
}
|
||||
}
|
||||
|
||||
class CompilationUnit {
|
||||
private val instructions = ArrayList<Instruction>()
|
||||
private val labels = ArrayList<Label>()
|
||||
|
||||
fun declareLabel(name: String) {
|
||||
if(instructions.firstOrNull{ it is Label && it.name == name } != null)
|
||||
throw IllegalStateException("Attempt to declare the same label twice!")
|
||||
registerInstruction(getLabel(name))
|
||||
}
|
||||
|
||||
fun getLabel(name: String): Label {
|
||||
if(labels.firstOrNull{ it.name == name } == null)
|
||||
labels.add(Label(name))
|
||||
return labels.first{ it.name == name }
|
||||
}
|
||||
|
||||
fun registerInstruction(insn: Instruction){
|
||||
instructions.add(insn)
|
||||
}
|
||||
|
||||
fun compile(): ShortArray {
|
||||
var dat = 0
|
||||
for(insn in instructions)
|
||||
dat += insn.words
|
||||
|
||||
if(dat > 256)
|
||||
throw RuntimeException("Instruction overflow")
|
||||
|
||||
val rawData = ShortArray(dat)
|
||||
var index = 0
|
||||
|
||||
for(insn in instructions)
|
||||
for(short in insn.getData(instructions))
|
||||
rawData[index++] = short
|
||||
|
||||
return rawData
|
||||
}
|
||||
}
|
||||
|
||||
enum class ArgType {
|
||||
REG, LABEL, INDEX, NUMBER
|
||||
}
|
||||
|
||||
fun parseRegister(arg: String): Int? {
|
||||
if(!arg.toUpperCase().startsWith("GR")) return null
|
||||
try{
|
||||
val reg = Integer.parseInt(arg.substring(2))
|
||||
if(reg > 3 || reg < 0)
|
||||
throw IllegalArgumentException("Register index out of range!")
|
||||
return reg
|
||||
}catch(e: NumberFormatException){
|
||||
throw IllegalArgumentException("Invalid register value")
|
||||
}
|
||||
}
|
||||
|
||||
fun parseLabelReference(arg: String, unit: CompilationUnit): Pair<Label, Mode>? {
|
||||
if(arg.length < 2 || Character.isDigit(arg[1])) return null
|
||||
if(arg.startsWith("@")) return unit.getLabel(arg.substring(1)) to Mode.DIRECT
|
||||
if(arg.startsWith("*")) return unit.getLabel(arg.substring(1)) to Mode.INDIRECT
|
||||
return null
|
||||
}
|
||||
|
||||
fun parseIndex(arg: String): Pair<Int, Mode>? {
|
||||
if(arg.startsWith("[") && arg.endsWith("]")){
|
||||
val literal = arg.substring(1, arg.length - 1)
|
||||
return parseNumber(literal) to Mode.INDEXED
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
fun parseNumber(literal: String): Int {
|
||||
return if(literal.startsWith("0") && literal.length > 1){
|
||||
when(literal[1]){
|
||||
'x' -> Integer.parseInt(literal.substring(2), 16)
|
||||
'b' -> Integer.parseInt(literal.substring(2), 2)
|
||||
else -> Integer.parseInt(literal.substring(2), 8)
|
||||
}
|
||||
}else{
|
||||
Integer.parseInt(literal)
|
||||
}
|
||||
}
|
||||
|
||||
fun checkProperSize(number: Int, max: Int): Int {
|
||||
if(number > max || number < 0)
|
||||
throw IllegalArgumentException("Parsed value out of range!")
|
||||
return number
|
||||
}
|
||||
|
||||
fun parseNumberLiteral(arg: String): Pair<Int, Mode>? {
|
||||
if(arg.startsWith("$")) return checkProperSize(parseNumber(arg.substring(1)), 65535) to Mode.IMMEDIATE
|
||||
if(arg.startsWith("*")) return checkProperSize(parseNumber(arg.substring(1)), 255) to Mode.INDIRECT
|
||||
return try{
|
||||
checkProperSize(parseNumber(arg), 255) to Mode.DIRECT
|
||||
}catch(e: NumberFormatException){
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
fun parseInstruction(line: String, unit: CompilationUnit): Instruction? {
|
||||
if(line.length == 0) return null
|
||||
if(line.replace(" ", "").endsWith(":")){
|
||||
val label = line.substring(0, line.length - 1)
|
||||
if(label.toUpperCase().startsWith("GR") || label.startsWith("$") || label.startsWith("*") || label.startsWith("@"))
|
||||
throw IllegalArgumentException("Label uses reserved prefix")
|
||||
return unit.getLabel(label)
|
||||
}
|
||||
val firstSpace = line.indexOf(" ")
|
||||
if(firstSpace == -1){
|
||||
val opcode = OpCode.fromString(line.toUpperCase())
|
||||
if(opcode == null)
|
||||
throw IllegalArgumentException("Unknown instruction: $line")
|
||||
if(opcode.useReg || opcode.useADR || opcode.useM)
|
||||
throw IllegalArgumentException("Not enough arguments passed to $line")
|
||||
return Operation(opcode)
|
||||
}else{
|
||||
val opcode = OpCode.fromString(line.substring(0, firstSpace).toUpperCase())
|
||||
if(opcode == null)
|
||||
throw IllegalArgumentException("Unknown instruction: $line")
|
||||
val args = line.substring(firstSpace + 1).replace(" ", "").split(",").toTypedArray()
|
||||
when(args.size){
|
||||
1 -> {
|
||||
var arg = parseArguments(args[0], null, unit)
|
||||
return when(arg.first.first){
|
||||
ArgType.REG -> Operation(opcode, arg.first.second as Int)
|
||||
ArgType.LABEL -> Operation(opcode, (arg.first.second as Pair<Label, Mode>).second, AddressReference((arg.first.second as Pair<Label, Mode>).first))
|
||||
ArgType.INDEX -> Operation(opcode, (arg.first.second as Pair<Int, Mode>).second, AddressReference((arg.first.second as Pair<Int, Mode>).first))
|
||||
ArgType.NUMBER -> if((arg.first.second as Pair<Int, Mode>).second == Mode.IMMEDIATE)
|
||||
Operation(opcode, (arg.first.second as Pair<Int, Mode>).second, AddressReference(0), (arg.first.second as Pair<Int, Mode>).first.toShort())
|
||||
else Operation(opcode, (arg.first.second as Pair<Int, Mode>).second, AddressReference((arg.first.second as Pair<Int, Mode>).first))
|
||||
}
|
||||
}
|
||||
2 -> {
|
||||
val arg = parseArguments(args[0], args[1], unit)
|
||||
val first = arg.first
|
||||
val second = arg.second!!
|
||||
|
||||
if(first.first != ArgType.REG)
|
||||
throw IllegalArgumentException("First argument must be a register")
|
||||
|
||||
return when(second.first){
|
||||
ArgType.REG -> Operation(opcode, first.second as Int, Mode.values()[second.second as Int], AddressReference(0), 0)
|
||||
ArgType.LABEL -> Operation(opcode, first.second as Int, (second.second as Pair<Label, Mode>).second, AddressReference((second.second as Pair<Label, Mode>).first))
|
||||
ArgType.NUMBER -> if((second.second as Pair<Int, Mode>).second == Mode.IMMEDIATE)
|
||||
Operation(opcode, first.second as Int, (second.second as Pair<Int, Mode>).second, AddressReference(0), (second.second as Pair<Int, Mode>).first.toShort())
|
||||
else Operation(opcode, first.second as Int, (second.second as Pair<Int, Mode>).second, AddressReference((second.second as Pair<Int, Mode>).first))
|
||||
ArgType.INDEX -> Operation(opcode, first.second as Int, (second.second as Pair<Int, Mode>).second, AddressReference((second.second as Pair<Int, Mode>).first))
|
||||
}
|
||||
}
|
||||
else -> throw IllegalArgumentException("Too many arguments specified")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun parseArgument(arg: String, unit: CompilationUnit): Pair<ArgType, Any>? {
|
||||
var resolve: Any? = parseRegister(arg)
|
||||
if(resolve != null) return ArgType.REG to resolve
|
||||
resolve = parseIndex(arg)
|
||||
if(resolve != null) return ArgType.INDEX to resolve
|
||||
resolve = parseLabelReference(arg, unit)
|
||||
if(resolve != null) return ArgType.LABEL to resolve
|
||||
resolve = parseNumberLiteral(arg)
|
||||
if(resolve != null) return ArgType.NUMBER to resolve
|
||||
|
||||
return null // Unresolved
|
||||
}
|
||||
|
||||
fun parseArguments(arg0: String, arg1: String?, unit: CompilationUnit): Pair<Pair<ArgType, Any>, Pair<ArgType, Any>?> {
|
||||
val resolve0 = parseArgument(arg0, unit)
|
||||
if(resolve0 == null) throw IllegalArgumentException("Invalid argument: $arg0")
|
||||
|
||||
val resolve1 = if(arg1 != null) parseArgument(arg1, unit) else null
|
||||
if(arg1 != null && resolve1 == null) throw IllegalArgumentException("Invalid argument: $arg0")
|
||||
|
||||
return resolve0 to resolve1
|
||||
}
|
||||
|
||||
fun parseInstructions(fileData: String): ShortArray {
|
||||
val unit = CompilationUnit()
|
||||
val lines = fileData.replace("\r", "").replace("\t", "").split('\n').toTypedArray()
|
||||
for(index in lines.indices){
|
||||
val commentIndex = lines[index].indexOf("#")
|
||||
if(commentIndex > 0)
|
||||
lines[index] = lines[index].substring(0, commentIndex)
|
||||
val insn = parseInstruction(lines[index], unit)
|
||||
if(insn != null) unit.registerInstruction(insn)
|
||||
}
|
||||
return unit.compile()
|
||||
}
|
||||
|
||||
fun main(args: Array<String>){
|
||||
// Ensure correct argument length 'n stuff
|
||||
if(args.size != 1){
|
||||
@ -88,13 +291,9 @@ fun main(args: Array<String>){
|
||||
System.err.println("Given file doesn't exist!")
|
||||
System.exit(-2)
|
||||
}
|
||||
|
||||
val insns = ArrayList<Instruction>()
|
||||
insns.add(Operation(OpCode.LOAD, 0, Mode.DIRECT, AddressReference(1337)))
|
||||
insns.add(Operation(OpCode.HALT))
|
||||
|
||||
for(insn in parseInstructions("LOAD GR0,0xFF"))
|
||||
println(insn.toUHex())
|
||||
}
|
||||
|
||||
fun Array<Instruction>.compile(): Array<Short> {
|
||||
|
||||
}
|
||||
|
||||
fun Short.toUHex() = toInt().and(0xFFFF.toInt()).or(1.shl(30)).toString(16).substring(4)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user