230 lines
9 KiB
OCaml
230 lines
9 KiB
OCaml
(*naloga instruction modula je ustvarjanje instructionLista, torej vsebine T zapisa*)
|
|
(*sem spada izbira nacina naslavljanja, dolocanje ali je operand simbol itd..*)
|
|
|
|
open SemanticAnalyzer
|
|
open Simtab
|
|
open OpcodeTable
|
|
|
|
(*podatki o base naslavljanju*)
|
|
type base_info = {
|
|
is_base : bool;
|
|
valueB : int
|
|
}
|
|
|
|
type operand =
|
|
| R of register
|
|
| RR of register * register
|
|
| RN of register * int (*register in število*)
|
|
| N of int (*številski operand*)
|
|
| S of string (*simbol*)
|
|
| None
|
|
|
|
|
|
let string_is_symbol (s : string) : bool * operand =
|
|
try
|
|
let n = int_of_string s in
|
|
false, N n
|
|
with Failure _ -> true, S s
|
|
|
|
(*preveri ali je operand iz mnemonic_type simbol ali stevilo*)
|
|
let operand_is_symbol (x : lineSemantic) : (bool * operand * int) option = (*vrne isSymbol, operand in dolzino ukaza, ali none, če ukaza/direktive ne bomo zapisali v T file*)
|
|
match x.mnem with
|
|
| MnemonicD -> None
|
|
| MnemonicDn s -> let (issym, operand) = string_is_symbol s in Some (issym, operand, x.len)
|
|
| MnemonicF1 -> Some (false, None, x.len)
|
|
| MnemonicF2n n -> Some (false, N n, x.len)
|
|
| MnemonicF2r r1 -> Some (false, R r1, x.len)
|
|
| MnemonicF2rn (r1, n) -> Some (false, RN (r1, n), x.len)
|
|
| MnemonicF2rr (r1, r2) -> Some (false, RR (r1, r2), x.len)
|
|
| MnemonicF3 -> Some (false, None, x.len)
|
|
| MnemonicF3m s -> let (issym, operand) = string_is_symbol s in Some (issym, operand, x.len)
|
|
| MnemonicF4m s -> let (issym, operand) = string_is_symbol s in Some (issym, operand, x.len)
|
|
| MnemonicSd s -> let (issym, operand) = string_is_symbol s in Some (issym, operand, x.len)
|
|
| MnemonicSn _ -> None(*RESW in RESB že drugje obdelamo*)
|
|
| COMMENT -> None (*Comment ze obdelamo drugje*)
|
|
|
|
(*helper funkcija za registre*)
|
|
let int_of_reg (reg : register) : int =
|
|
match reg with
|
|
| A -> 0
|
|
| X -> 1
|
|
| L -> 2
|
|
| B -> 3
|
|
| S -> 4
|
|
| T -> 5
|
|
| F -> 6
|
|
| PC -> 8
|
|
| SW -> 9
|
|
|
|
(*helper funkcija*)
|
|
let int_to_hex_width (width : int) (n : int) : string =
|
|
let s = Printf.sprintf "%X" n in
|
|
let len = String.length s in
|
|
if len >= width then (String.sub s (len - width) width)
|
|
else String.make (width - len) '0' ^ s
|
|
|
|
let char_to_hex c =
|
|
Printf.sprintf "%02X" (Char.code c)
|
|
|
|
(*preveri ali laho pc relativno nasljavljas in vrni disp*)
|
|
let is_pc_relative (loc : int) (target : int) : bool * int =
|
|
let pc = loc + 3 in
|
|
let disp = target - pc in
|
|
if disp >= -2048 && disp <= 2047 then
|
|
(true, disp)
|
|
else
|
|
(false, 0)
|
|
|
|
(*preveri ali lahko bazno naslavljamo*)
|
|
let is_base_relative (target : int) (valueB : int) : bool * int =
|
|
let disp = valueB - target in
|
|
if disp >= 0 && disp <= 4095 then
|
|
(true, disp)
|
|
else
|
|
(false, 0)
|
|
|
|
(*preveri ali gre v direktno naslavljanje 0 <= addr <= 4095*)
|
|
let is_direct (target: int) : bool * int =
|
|
if target >= 0 && target <= 4095 then
|
|
true, target
|
|
else
|
|
false, 0
|
|
|
|
(*vrne xbpe in disp*)
|
|
let get_xbpe_disp (x : bool) (loc : int option) (target : int) (base_info : base_info) : int * int =
|
|
let location = match loc with | None -> failwith "location of instructin in None" | Some i -> i in
|
|
(*probamo pc relativno*)
|
|
let p, disp = is_pc_relative location target in
|
|
if p then
|
|
let x_int = if x then 8 else 0 in
|
|
let p_int = 2 in
|
|
let xbpe = x_int + p_int in
|
|
xbpe, disp
|
|
(*ce je bazno omogoceno in deluje*)
|
|
else
|
|
|
|
let b, disp = is_base_relative base_info.valueB target in
|
|
if base_info.is_base && b then
|
|
let x_int = if x then 8 else 0 in
|
|
let b_int = 4 in
|
|
let xbpe = x_int + b_int in
|
|
xbpe, disp
|
|
(*če gre direktno*)
|
|
else
|
|
let direct, disp = is_direct target in
|
|
if direct then
|
|
let x_int = if x then 8 else 0 in
|
|
let xbpe = x_int in
|
|
xbpe, disp
|
|
else
|
|
failwith (Printf.sprintf "No adressing mode is appropriate for target %d" target)
|
|
|
|
|
|
|
|
(*naredi binaren zapis F1 oz string nibblov celotnega ukaza*)
|
|
let get_bin_instruction_F1 (opcode : int) : string =
|
|
int_to_hex_width 2 opcode
|
|
|
|
(*naredi binaren zapis F2 oz string nibblov celotnega ukaza*)
|
|
let get_bin_instruction_F2 (opcode : int) (operand : operand) : string =
|
|
match operand with
|
|
| RR (r1, r2) -> (int_to_hex_width 2 opcode) ^ (int_to_hex_width 1 (int_of_reg r1)) ^ (int_to_hex_width 1 (int_of_reg r2))
|
|
| RN (r1, n) -> (int_to_hex_width 2 opcode) ^ (int_to_hex_width 1 (int_of_reg r1)) ^ (int_to_hex_width 1 n)
|
|
| R r1 -> (int_to_hex_width 2 opcode) ^ (int_to_hex_width 1 (int_of_reg r1)) ^ (int_to_hex_width 1 0) (*r2 -> 0*)
|
|
| N n -> (int_to_hex_width 2 opcode) ^ (int_to_hex_width 1 n) ^ (int_to_hex_width 1 0)
|
|
| _ -> failwith "invalid operand type for F2 instruction"
|
|
|
|
let get_bin_instruction_F3 (opcode : int) (simtab : symtab) (operand : operand)
|
|
(loc : int option) (x : bool) (n : bool) (i : bool) (base_info : base_info) : string =
|
|
let oppcode_with_ni = match (n, i) with
|
|
| (false, false) -> opcode + 0
|
|
| (false, true) -> opcode + 1
|
|
| (true, false) -> opcode + 2
|
|
| (true, true ) -> opcode + 3
|
|
in
|
|
match operand with
|
|
| None -> (int_to_hex_width 2 oppcode_with_ni) ^ (int_to_hex_width 4 0) (*RSUB damo z disp = 0*)
|
|
| N n ->
|
|
let xbpe = if x then 8 else 0 in (*ce imamo stevilsko vrednost uporabimo direktno naslavljanje*)
|
|
(int_to_hex_width 2 oppcode_with_ni) ^ (int_to_hex_width 1 xbpe) ^ (int_to_hex_width 3 n)
|
|
| S s ->
|
|
(*poiscemo naslov simbola, dolocimo xbpe in disp*)
|
|
let operand = Hashtbl.find simtab s in
|
|
let xbpe, disp = get_xbpe_disp x loc operand base_info in
|
|
(int_to_hex_width 2 oppcode_with_ni) ^ (int_to_hex_width 1 xbpe) ^ (int_to_hex_width 3 disp)
|
|
| _ -> ""
|
|
|
|
let get_bin_instruction_F4 (opcode : int) (simtab : symtab) (operand : operand) (x : bool) (n : bool) (i : bool) : string =
|
|
let oppcode_with_ni = match (n, i) with
|
|
| (false, false) -> opcode + 0
|
|
| (false, true) -> opcode + 1
|
|
| (true, false) -> opcode + 2
|
|
| (true, true ) -> opcode + 3
|
|
in
|
|
let xbpe = if x then 9 else 1 in (*pri F4 imamo le direktno, zato je p = 0, b = 0, e=1*)
|
|
match operand with
|
|
| None -> (int_to_hex_width 2 oppcode_with_ni) ^ (int_to_hex_width 6 0) (*RSUB damo z disp = 0*)
|
|
| N n -> (int_to_hex_width 2 oppcode_with_ni) ^ (int_to_hex_width 1 xbpe) ^ (int_to_hex_width 5 n)
|
|
| S s -> let operand = Hashtbl.find simtab s in (int_to_hex_width 2 oppcode_with_ni) ^ (int_to_hex_width 1 xbpe) ^ (int_to_hex_width 5 operand)
|
|
| _ -> ""
|
|
|
|
(*vrni bin zapis instrukcij tipa F1, F2, F3, F4*)
|
|
let create_opcode (simtab : symtab) (opcodeTab : opcodeTab) (opcode : mnemonic)
|
|
(operand : operand) (formatLen : int) (loc : int option) (x : bool) (n : bool) (i : bool) (base_info: base_info): string =
|
|
(*izberi nacin naslavljanja in naredi string ukaza*)
|
|
match formatLen with
|
|
| 1 -> get_bin_instruction_F1 (find_opcode opcodeTab opcode)
|
|
| 2 -> get_bin_instruction_F2 (find_opcode opcodeTab opcode) operand
|
|
| 3 -> get_bin_instruction_F3 (find_opcode opcodeTab opcode) simtab operand loc x n i base_info
|
|
| 4 -> get_bin_instruction_F4 (find_opcode opcodeTab opcode) simtab operand x n i
|
|
| _ -> ""
|
|
|
|
(*opcode BYTE direktive*)
|
|
let create_opcode_byte (operand : string) : string =
|
|
if String.length operand < 3 then
|
|
failwith "Invalid BYTE operand, use X'...' or C'...'!"
|
|
else
|
|
match operand.[0] with
|
|
| 'C' ->
|
|
(* e.g., C'EOF' *)
|
|
let content = String.sub operand 2 (String.length operand - 3) in
|
|
let len = String.length content in
|
|
if len <> 1 then failwith "BYTE C'...' has to have a operand of length 1 inside hte '...' brackets!" else
|
|
String.concat "" (List.init (String.length content) (fun i -> char_to_hex content.[i]))
|
|
| 'X' ->
|
|
(* e.g., X'F1' *)
|
|
let hex = String.sub operand 2 (String.length operand - 3) in
|
|
if String.length hex >= 6 then
|
|
failwith "WORD X'...' has to have a operand of length <= 6 inside hte '...' brackets!"
|
|
else String.make (2 - String.length hex) '0' ^ hex
|
|
| _ ->
|
|
let n = int_of_string operand in
|
|
Printf.sprintf "%02X" n
|
|
|
|
let create_opcode_word (operand : string) : string =
|
|
if String.length operand = 0 then
|
|
failwith "Invalid WORD operand use X'...' or C'...'!"
|
|
else
|
|
match operand.[0] with
|
|
| 'C' ->
|
|
(* WORD as C'...' *)
|
|
let content = String.sub operand 2 (String.length operand - 3) in
|
|
let len = String.length content in
|
|
if len <> 3 then failwith "WORD C'...' has to have a operand of length 3 inside hte '...' brackets!" else
|
|
let hex = String.concat "" (List.init len (fun i -> char_to_hex content.[i])) in
|
|
(* pad to 6 hex digits for WORD *)
|
|
if String.length hex >= 6 then hex else String.make (6 - String.length hex) '0' ^ hex
|
|
| 'X' ->
|
|
(* WORD as X'...' *)
|
|
let hex = String.sub operand 2 (String.length operand - 3) in
|
|
if String.length hex >= 6 then
|
|
failwith "WORD X'...' has to have a operand of length <= 6 inside hte '...' brackets!"
|
|
else String.make (6 - String.length hex) '0' ^ hex
|
|
| _ ->
|
|
(* numeric constant *)
|
|
let n = int_of_string operand in
|
|
Printf.sprintf "%06X" n
|
|
|
|
|
|
let print_text_line_instruction (opcode : mnemonic) (mnem : mnemonic_type) (newTextLine : string) : unit =
|
|
Printf.printf "zbirali %s, %s -> %s\n" (string_of_mnemonic opcode) (string_of_mnemonic_type mnem) newTextLine
|