Codon/codon.js

This is a function I wrote to execute Codon programs. Given the program as the first parameter and the input as the second parameter, it will return the output. If there is an error compiling, it will log to the console and return no value. If the input is not specified, it will be prompted for every character.
function(program, input) {
 //compiler
 
 program = program.toUpperCase().replace(/#.+/gm, "").match(/\S{3}/gm); //split to groups of 3 characters and remove comments
 let compiled = "" //the codons compiled into characters 0-J
 
 for (codon in program) {
 let amino = ""
 switch (program[codon]) {
 case "GCU":
 case "GCC":
 case "GCA":
 case "GCC":
 amino = "0"; break; //alaline
 case "CGU":
 case "CGC":
 case "CGA":
 case "CGG":
 case "AGA":
 case "AGG":
 amino = "1"; break; //arginine
 case "AAU":
 case "AAC":
 amino = "2"; break; //asparagine
 case "GAU":
 case "GAC":
 amino = "3"; break; //aspartic acid
 case "UGU":
 case "UGC":
 amino = "4"; break; //cysteine
 case "CAA":
 case "CAG":
 amino = "5"; break; //glutamine
 case "GAA":
 case "GAG":
 amino = "6"; break; //glutamic acid
 case "GGU":
 case "GGC":
 case "GGA":
 case "GGG":
 amino = "7"; break; //glycine
 case "CAU":
 case "CAC":
 amino = "8"; break; //histidine
 case "AUU":
 case "AUC":
 case "AUA":
 amino = "9"; break; //Isoleucine
 case "UUA":
 case "UUG":
 case "CUU":
 case "CUC":
 case "CUA":
 case "CUG":
 amino = "A"; break; //Leucine
 case "AAA":
 case "AAG":
 amino = "B"; break; //Lysine
 case "AUG":
 amino = "C"; break; //Methionine
 case "UUU":
 case "UUC":
 amino = "D"; break; //phenylalanine
 case "CCU":
 case "CCC":
 case "CCA":
 case "CCG":
 amino = "E"; break; //proline
 case "UCU":
 case "UCC":
 case "UCA":
 case "UCG":
 case "AGU":
 case "AGC":
 amino = "F"; break; //serine
 case "ACU":
 case "ACC":
 case "ACA":
 case "ACG":
 amino = "G"; break; //threonine
 case "UGG":
 amino = "H"; break; //tryptophan
 case "UAU":
 case "UAC":
 amino = "I"; break; //tyrosine
 case "GUU":
 case "GUG":
 case "GUA":
 case "GUC":
 amino = "J"; break; //valine
 case "UAA":
 case "UAG":
 case "UGA":
 amino = "X"; break; //stop it
 }
 
 if (amino == "") { //if there is no matching amino for the codon
 console.log("error: invalid codon in index "+codon)
 return
 } else {
 compiled += amino
 }
 }
 
 let [start, end] = [compiled.indexOf("C"), compiled.indexOf("X")] //get first methionine and stop codons
 if (start == -1) { //if there's no start
 console.log("error: there is no start codon (AUG)")
 return
 } else if (end == -1) { //if there is no stop codon
 console.log("error: there is no stop codon")
 return
 }
 compiled = compiled.slice(start, end) //cut out anything before start and after stop
 //executor
 
 let out = ""
 let in_i = 0 //input indez
 let a = 0
 let b = 0
 let terminate = false //if true, terminate the program
 let flag = false
 let mem = [] //memory
 
 floor = x => Math.floor(x)
 null0 = x => (x != null || !isNaN(x) ? x : 0)
 for (let pc = 1; pc < compiled.length; pc++) { //start at 1 because of methionine
 switch (compiled[pc]) {
 case "0": //swap registers A and B
 b = [a, a = b][0]
 break
 case "1": //clone A to B
 b = a
 break
 case "2": //clone cell pointed by B to reg B
 a = null0(mem[floor(a)])
 break
 case "3": //clone reg A to cell pointed by B
 mem[floor(b)] = a
 break
 case "4": //flip flag
 flag = !flag
 break
 case "5": //immediate load 2 codons to A
 a = parseInt(compiled.slice(pc+1, pc+3), 20)
 pc+=2
 break
 case "6": //immediade load 4 codons
 a = parseInt(compiled.slice(pc+1, pc+5), 20)
 pc+=4
 break
 case "7": //jump
 if (flag) {
 pc += floor(a) - 1 //-1 to offset for loop increment
 pc = (pc < 0 ? 0 : pc > compiled.length ? compiled.length - 1 : pc) //out of bounds fix
 }
 break
 case "8": //input
 if (input) {
 a = input.charCodeAt(in_i++) || 0
 } else {
 a = prompt("enter character").charCodeAt(0) || 0
 }
 break
 case "9": //output
 out += String.fromCharCode(floor(a))
 break
 case "A": //add
 a += b
 break
 case "B": //sub
 a -= b
 break
 case "C": //terminate
 terminate = true
 case "D": //multiply
 a *= b
 break
 case "E": //divide
 a /= b
 break
 case "F": //round
 a = Math.round(a)
 break
 case "G": //negate
 a *= -1
 break
 case "H": //a > b
 flag = (a>b?true:false)
 break
 case "I": //a < b
 flag = (a
Category:Implementations