(* Scott Anderson
  COP4020 - Homework 4
  July 25, 2016 *)


let increment_by_one v =
    v := !v + 1
;;

let subtract_by_one v =
    v := !v - 1
;;

(* Defines max styles of instruction stack*)
let max_stack_height = ref 100;;

(* Initializes a Stack Reference of size max_stack_height to value 0*)
let stack = Array.make !max_stack_height 0;;

(* Initializes a Memory Stack Reference of size max_stack_height to value 0*)
let mem = Array.make !max_stack_height 0;;

(* Initializes a Strack Register to the value 0*)
let sr = ref 0;;

(* Initializes a Memory Register to the value 0*)
let mr = ref 0;;

(* Loads argument to current top of stack*)
let load v =
    Array.set stack !sr v
;;

(* Increments Stack Register by one and loads argument to new top of stack*)
let cur l =
    increment_by_one sr;
    Array.set stack !sr l
;;

(* Increments Stack Register by one and loads argument to new top of stack*)
let quote v =
    increment_by_one sr;
    Array.set stack !sr v
;;

(* Simulates a PUSH on the stack and load arguent [sr]  to [sr+1].
  When complete icrements stack by one. *)
let dupl () =
    let ele = stack.(!sr) in
    Array.set stack (!sr + 1) ele;
    increment_by_one sr
;;

(* Simulates a SWAP on the stack and loads [sr] into [sr+1] into temporary variables.
  Loads value of [sr] temporay value into [sr+1]
  Loads value of [sr+1] temporay value into [sr+]  *)
let swap () =
    let temp1 = stack.(!sr - 1) in
    let temp2 = stack.(!sr) in
    Array.set stack !sr temp1;
    Array.set stack (!sr - 1) temp2
;;

(* Simulates a ROTATION of the top three elements of the stack.
  Loads values [sr], [sr-1], and [sr-2] into temporary variables
  Loads value of [sr-1] temporay value into [sr]
  Loads value of [sr-2] temporay value into [sr-1]
  Loads value of [sr] temporay value into [sr-2] *)
let rot () =
    let temp1 = stack.(!sr) in
    let temp2 = stack.(!sr - 1) in
    let temp3 = stack.(!sr - 2) in
    Array.set stack !sr temp2;
    Array.set stack (!sr - 1) temp3;
    Array.set stack (!sr - 2) temp1
;;

(* Simulates a reverse of the ROTATION function
  Loads values [sr], [sr-1], and [sr-2] into temporary variables
  Loads value of [sr-2] temporay value into [sr]
  Loads value of [sr] temporay value into [sr-1]
  Loads value of [sr-1] temporay value into [sr-2] *)
let irot () =
    let temp1 = stack.(!sr) in
    let temp2 = stack.(!sr - 1) in
    let temp3 = stack.(!sr - 2) in
    Array.set stack !sr temp3;
    Array.set stack (!sr - 1) temp1;
    Array.set stack (!sr - 2) temp2
;;

(* Simulates an ADDITION of the top two stack elements.
  Loads value of [sr] and [sr-1] into temporary variables.
  Sums [sr] and [sr-1] values into a temporary variable.
  Stores sum into [sr-1] in the stack.
  Reduces the stack pointer. *)
let plus () =
    let temp1 = stack.(!sr) in
    let temp2 = stack.(!sr - 1) in
    let sum = temp1 + temp2 in
    Array.set stack (!sr - 1) sum;
    subtract_by_one sr
;;
(* Simulates an Multiplication of the top two stack elements.
  Loads value of [sr] and [sr-1] into temporary variables.
  Multiplies [sr] and [sr-1] values into a temporary variable.
  Stores multipliedvalue into [sr-1] in the stack.
  Reduces the stack pointer. *)
let mult () =
    let temp1 = stack.(!sr) in
    let temp2 = stack.(!sr - 1) in
    let product = temp1 * temp2 in
    Array.set stack (!sr - 1) product;
    subtract_by_one sr
;;

(* Load the value stored in the memory stack at address stored in stack[sr]
  Load stored value into stack[sr] *)
let fst () =
    let ele = stack.(!sr) in
    let memEle = mem.(ele) in
    Array.set stack !sr memEle
;;

(* Load the value stored in the memory stack at address stored in stack[sr+1]
  Load stored value into stack[sr] *)
let snd () =
    let ele = stack.(!sr) in
    let memEle = mem.(ele + 1) in
    Array.set stack !sr memEle
;;

(* Load the value stored at stack[sr] into the memory stack at address stored in
  Stack [sr-1] *)
let setfst () =
    let idx = stack.(!sr - 1) in
    Array.set mem idx stack.(!sr);
    subtract_by_one sr
;;

(* Load the value stored in stack[sr] into the memory stack at the address stored
  in stack[sr-1] + 1.
  Decrement the stack register. *)
let setsnd () =
    let idx = (stack.(!sr - 1) + 1) in
    Array.set mem idx stack.(!sr);
    subtract_by_one sr
;;

(* Loads stack[sr] into MEM[mr]
  Loads stack[sr-1] into MEM[mr+1]
  Loads mr into stack[sr-1]
  Increment mr by two
  Decrement sr by one *)
let cons () =
    Array.set mem !mr stack.(!sr);
    let ele = stack.(!sr - 1) in
    Array.set mem (!mr + 1) ele;
    Array.set stack (!sr - 1) !mr;
    increment_by_one mr;
    increment_by_one mr;
    subtract_by_one sr
;;

let split () =
    let ele = mem.(stack.(!sr)) in
    Array.set stack (!sr + 1) ele;
    let ele2 = mem.(stack.(!sr) + 1) in
    Array.set stack !sr ele2;
    subtract_by_one sr
;;

let branch a1 a2 =
    Array.set stack (!sr) (if stack.(!sr) == 1 then a1 else a2)
;;