Changeset 83 for Deliverables/D4.1

Timestamp:

Sep 16, 2010, 3:31:33 PM (10 years ago)

Author:

mulligan

Message:

Lots of work done on tidying up code.

Location:

Deliverables/D4.1

Files:

• 8051Series.ml (modified) (2 diffs)
• ASMInterpret.ml (modified) (1 diff)
• Bit.ml (modified) (2 diffs)
• Byte.ml (modified) (5 diffs)
• Nibble.ml (modified) (2 diffs)
• SFR.ml (added)
• Word.ml (modified) (1 diff)

Deliverables/D4.1/8051Series.ml

@@ -13 +13 @@
   type word
 
+  type sfr
+
+  type code_memory
+  type low_internal_ram
+  type high_internal_ram
+  type external_ram
+
   type processor_status
   type program_counter
@@ -21 +28 @@
 
   val power_up: processor_status
-  val next: program_counter -> processor_status -> 
 end;;
+
+module 8051_Series (Bit: BIT)
+                   (Nibble: NIBBLE
+                      with type bit    = Bit.bit)
+                   (Byte: BYTE
+                      with type bit    = Bit.bit
+                      and  type nibble = Nibble.nibble)
+                   (Byte7: BYTE7
+                      with type bit    = Bit.bit
+                      and  type nibble = Nibble.nibble)
+                   (Word: WORD
+                      with type bit    = Bit.bit
+                      and  type nibble = Nibble.nibble 
+                      and  type byte   = Byte.byte)
+                   (SpecialFunctionRegister: SFR
+                      with type bit    = Bit.bit
+                      and  type byte   = Byte.byte): 8051_SERIES =
+struct
+  type bit = Bit.bit
+  type nibble = Nibble.nibble
+  type byte = Byte.byte
+  type byte7 = Byte.byte7
+  type word = Word.word
+
+  type sfr = SpecialFunctionRegister.sfr
+
+  type code_memory = word Map.Make (struct type t = byte7 let compare = Pervasives.compare end)
+  type low_internal_ram = Map.Make (struct type t = byte7 let compare = Pervasives.compare end)
+  type high_internal_ram = Map.Make (struct type t = byte7 let compare = Pervasives.compare end)
+  type external_ram = Map.Make (struct type t = byte7 let compare = Pervasives.compare end)
+
+  type processor_status = {
+    program_counter: word;
+    sfr: sfr;
+    
+  }
+end;;

Deliverables/D4.1/ASMInterpret.ml

@@ -739 +739 @@
   else true
 ;;
+
+let power_on =
+  status
+  {
+    code_memory = WordMap.empty;
+    external_memory = WordMap.empty;
+    low_internal_ram = Byte7Map.empty;
+    high_internal_ram = Byte7Map.empty;
+
+    pc = 
+  }
+;;
+  
 
 let execute1 status =

Deliverables/D4.1/Bit.ml

@@ -22 +22 @@
   val (-^-): bit -> bit -> bit
   val not: bit -> bit
+
+  val zero: bit
+
+  (* Half add: two input bits, returns addition of bit plus carry. *)
+  val half_add: bit -> bit -> (bit * bit)
+  (* Full add: two input bits, plus input carry bit, returns       *)
+  (* addition of input bits plus carry.                            *)
+  val full_add: (bit * bit) -> bit -> (bit * bit)
 end;;
 
@@ -67 +75 @@
       true -> false
     | false -> true
+
+  let zero = false
+
+  let half_add l r = (l -^- r, l -&- r)
+  let full_add (l, c) r =
+    ((l -^- r) -^- c, (l -&- r) -|- (c -&- (l -^- r)))
 end;;

Deliverables/D4.1/Byte.ml

@@ -4 +4 @@
 (*              operations on them.                                          *)
 (* CREATED:     10/09/2010, Dominic Mulligan                                 *)
-(* BUGS:                                                                     *)
+(* BUGS:        `from_int' not yet implemented.                              *)
 (*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*)
 
@@ -20 +20 @@
   val from_nibbles: nibble -> nibble -> byte
   val from_nibble: nibble -> byte
-(*
-  val from_int: int -> byte
-*)
+  (* val from_int: int -> byte *)
+
   val to_bit: byte -> bit option
   val to_nibble: byte -> nibble option
@@ -48 +47 @@
   val zip_bit: (bit -> bit -> bit) -> byte -> byte -> byte
   val to_string: byte -> string
+
+  val zero: byte
+  val half_add: byte -> byte -> (byte * bit)
+  val full_add: (byte * bit) -> byte -> (byte * bit)
 end
 
@@ -74 +77 @@
                               (Bit.from_bool false) (Bit.from_bool false) in
       (n1, n2)
+  (* let from_int = assert false                                 DPM: finish! *)
 
   let get_nibble_at index (n1, n2) =
@@ -197 +201 @@
       (new_n1, new_n2)
   let to_string = iter_nibble Nibble.to_string
+
+  let zero = (Nibble.zero, Nibble.zero)
+  let half_add (l1, l2) (r1, r2) =
+    let (a2, c2) = Nibble.half_add l2 r2 in
+    let (a1, c1) = Nibble.full_add (l1, c2) r2 in
+      ((a1, a2), c1)
+  let full_add ((l1, l2), c) (r1, r2) =
+    let (a2, c2) = Nibble.full_add (l2, c) r2 in
+    let (a1, c1) = Nibble.full_add (l1, c2) r2 in
+      ((a1, a2), c1)
 end;;
 

Deliverables/D4.1/Nibble.ml

@@ -39 +39 @@
   val iter_bit: (bit -> string) -> nibble -> string
   val zip_bit: (bit -> bit -> bit) -> nibble -> nibble -> nibble
+
+  val zero: nibble
+  
+  val half_add: nibble -> nibble -> (nibble * bit)
+  val full_add: (nibble * bit) -> nibble -> (nibble * bit)
 end
 
@@ -116 +121 @@
 
   let to_string = iter_bit Bit.to_string
-end
 
-module Nibble = NibbleFunctor(Bit)
+  let zero = (Bit.zero, Bit.zero, Bit.zero, Bit.zero)
+  let half_add (l1, l2, l3, l4) (r1, r2, r3, r4) =
+    let (a4, c4) = Bit.half_add l4 r4 in
+    let (a3, c3) = Bit.full_add (l3, c4) r3 in
+    let (a2, c2) = Bit.full_add (l2, c3) r2 in
+    let (a1, c1) = Bit.full_add (l1, c2) r1 in
+      ((a1, a2, a3, a4), c1)
+  let full_add ((l1, l2, l3, l4), c) (r1, r2, r3, r4) =
+    let (a4, c4) = Bit.full_add (l4, c) r4 in
+    let (a3, c3) = Bit.full_add (l3, c4) r3 in
+    let (a2, c2) = Bit.full_add (l2, c3) r2 in
+    let (a1, c1) = Bit.full_add (l1, c2) r1 in
+      ((a1, a2, a3, a4), c1)
+end;;
+
+module Nibble = NibbleFunctor(Bit);;

Deliverables/D4.1/Word.ml

@@ -1 +1 @@
 (*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*)
-(* FILENAME:    Byte.ml                                                      *)
-(* DESCRIPTION: An ADT implementing standard 8 bit bytes, and common         *)
+(* FILENAME:    Word.ml                                                      *)
+(* DESCRIPTION: An ADT implementing standard 16 bit words, and common        *)
 (*              operations on them.                                          *)
 (* CREATED:     13/09/2010, Dominic Mulligan                                 *)