Changeset 86 for Deliverables/D4.1

Timestamp:

Sep 17, 2010, 5:12:19 PM (10 years ago)

Author:

mulligan

Message:

Adding bit vector file.

Location:

Deliverables/D4.1

Files:

• ASMInstruction.ml (modified) (4 diffs)
• Byte.ml (modified) (3 diffs)
• Byte7.ml (modified) (2 diffs)
• Nibble.ml (modified) (2 diffs)
• SFR.ml (modified) (1 diff)
• Word.ml (modified) (2 diffs)
• Word11.ml (modified) (2 diffs)
• tentative.ml (added)

Deliverables/D4.1/ASMInstruction.ml

@@ -242 +242 @@
   let to_string =
     function
-      ACALL (`ADDR11 (a10,a9,a8,b1)) ->
-      "ACALL addr11 (" ^ Word11.to_string (a10,a9,a8,b1) ^ ")"
+      ACALL (`ADDR11 w) ->
+      "ACALL addr11 (" ^ Word11.to_string w ^ ")"
     | ADD (`A,`REG (r1,r2,r3)) ->
      "ADD A Rn (" ^ Bit.to_string r1 ^ Bit.to_string r2 ^ Bit.to_string r3 ^ ")"
@@ -260 +260 @@
     | ADDC (`A,`DATA b1) ->
      "ADDC A #data (" ^ Byte.to_string b1 ^ ")"
-    | AJMP (`ADDR11 (a10,a9,a8,b1)) ->
-     "AJMP addr11 (" ^ Word11.to_string (a10,a9,a8,b1) ^ ")"
+    | AJMP (`ADDR11 w) ->
+     "AJMP addr11 (" ^ Word11.to_string w ^ ")"
     | ANL (`U1 (`A, `REG (r1,r2,r3))) ->
      "ANL A Rn (" ^ Bit.to_string r1 ^ Bit.to_string r2 ^ Bit.to_string r3 ^ ")"
@@ -334 +334 @@
     | JZ (`REL b1) ->
     "JZ rel (" ^ Byte.to_string b1 ^ ")"
-    | LCALL (`ADDR16 (b1,b2)) ->
-    "LCALL addr16 (" ^ Byte.to_string b1 ^ Byte.to_string b2 ^ ")"
-    | LJMP (`ADDR16 (b1,b2)) ->
-    "LJMP addr16 (" ^ Byte.to_string b1 ^ Byte.to_string b2 ^ ")"
+    | LCALL (`ADDR16 w) ->
+    "LCALL addr16 (" ^ Word.to_string w ^ ")"
+    | LJMP (`ADDR16 w) ->
+    "LJMP addr16 (" ^ Word.to_string w ^ ")"
     | MOV (`U1 (`A, `REG(r1,r2,r3))) ->
     "MOV A Rn (" ^ Bit.to_string r1 ^ Bit.to_string r2 ^ Bit.to_string r3 ^ ")"
@@ -372 +372 @@
     | MOV (`U6 (`BIT b1, `C)) ->
     "MOV bit C (" ^ Byte.to_string b1 ^ ")"
-    | MOV (`U4 (`DPTR, `DATA16(b1,b2))) ->
-    "MOV DPTR #data16 (" ^ Byte.to_string b1 ^ Byte.to_string b2 ^ ")"
+    | MOV (`U4 (`DPTR, `DATA16 w)) ->
+    "MOV DPTR #data16 (" ^ Word.to_string w ^ ")"
     | MOVC (`A, `A_DPTR) ->
     "MOVC A @A + DPTR"

Deliverables/D4.1/Byte.ml

@@ -23 +23 @@
 
   val to_bit: byte -> bit option
+  val to_bits: byte -> bit list
   val to_nibble: byte -> nibble option
   val to_int: byte -> int
@@ -128 +129 @@
       else
         None
+  let to_bits (n1, n2) = Nibble.to_bits n1 @ Nibble.to_bits n2
   let to_nibble (n1, n2) =
     let (b1, b2, b3, b4) = Nibble.to_bits n1 in
@@ -135 +137 @@
       else None
   let to_int (n1, n2) =
-    let (b1, b2, b3, b4) = Nibble.to_bits n1 in
-    let (b5, b6, b7, b8) = Nibble.to_bits n2 in
+    let [b1; b2; b3; b4] = Nibble.to_bits n1 in
+    let [b5; b6; b7; b8] = Nibble.to_bits n2 in
       (128 * Bit.to_int b8) + (64 * Bit.to_int b8) +
       (32 * Bit.to_int b8) + (16 * Bit.to_int b8) + 

Deliverables/D4.1/Byte7.ml

@@ -14 +14 @@
   type bit
   type nibble
-  type byte7
+  type byte7 = private (bit * bit * bit * nibble)
+
+  val get_bit_at: int -> byte7 -> bit option
+  val set_bit_at: int -> bit -> byte7 -> byte7 option
+
+  val (-&-): byte7 -> byte7 -> byte7
+  val (-|-): byte7 -> byte7 -> byte7
+  val (-^-): byte7 -> byte7 -> byte7
+  val not: byte7 -> byte7
+
+  val iter_bit: (bit -> string) -> byte7 -> string
+  val map_bit: (bit -> bit) -> byte7 -> byte7
+  val zip_bit: (bit -> bit -> bit) -> byte7 -> byte7 -> byte7
+  val to_string: byte7 -> string
 end;;
 
 module Byte7Functor(Bit: BIT)
                    (Nibble: NIBBLE
-                      with type bit = Bit.bit) : BYTE7
+                      with type bit = Bit.bit): BYTE7
   with type bit    = Bit.bit
   and  type nibble = Nibble.nibble =
@@ -25 +38 @@
   type bit = Bit.bit
   type nibble = Nibble.nibble
-  type byte7 = private (bit * bit * bit * nibble)
+  type byte7 = bit * bit * bit * nibble
+
+  let get_bit_at index (b1,b2,b3,b) =
+    if index < 4 then
+      Nibble.get_bit_at index b
+    else
+      match index with
+        4 -> Some b3
+      | 5 -> Some b2
+      | 6 -> Some b1
+      | _ -> None
+  let set_bit_at index new_val (b1,b2,b3,b) =
+    if index < 4 then
+      let nib = Nibble.set_bit_at index new_val b in
+        match nib with
+          Some nib -> Some (b1, b2, b3, nib)
+        | None -> None
+    else
+      match index with
+        4 -> Some (b3, b2, new_val, b)
+      | 5 -> Some (b3, new_val, b1, b)
+      | 6 -> Some (new_val, b2, b1, b)
+      | _ -> None
+
+  let (-&-) (l1, l2, l3, l) (r1, r2, r3, r) =
+    (Bit.(-&-) l1 r1, Bit.(-&-) l2 r2, Bit.(-&-) l3 r3, Nibble.(-&-) l r)
+  let (-|-) (l1, l2, l3, l) (r1, r2, r3, r) =
+    (Bit.(-|-) l1 r1, Bit.(-|-) l2 r2, Bit.(-|-) l3 r3, Nibble.(-|-) l r)
+  let (-^-) (l1, l2, l3, l) (r1, r2, r3, r) =
+    (Bit.(-^-) l1 r1, Bit.(-^-) l2 r2, Bit.(-^-) l3 r3, Nibble.(-^-) l r)
+  let not (b1, b2, b3, b) = (Bit.not b1, Bit.not b2, Bit.not b3, Nibble.not b)
+
+  let iter_bit f (b1, b2, b3, b) =
+    let n_bits = f b1 ^ f b2 ^ f b3 in
+    let n_byte = Nibble.iter_bit f b in
+      n_bits ^ n_byte
+  let map_bit f (b1, b2, b3, b) =
+    (f b1, f b2, f b3, Nibble.map_bit f b)
+  let zip_bit f (l1, l2, l3, l) (r1, r2, r3, r) =
+    (f l1 r1, f l2 r2, f l3 r3, Nibble.zip_bit f l r)
+
+  let to_string = iter_bit Bit.to_string
 end;;
 

Deliverables/D4.1/Nibble.ml

@@ -19 +19 @@
   (* val from_string: string -> nibble option *)
 
-  val to_bits: nibble -> (bit * bit * bit * bit)
+  val to_bits: nibble -> bit list
   val to_bit: nibble -> bit option
   val to_int: nibble -> int
@@ -79 +79 @@
       (false, false, false, b) -> Some (Bit.from_bool b)
    |  _ -> None
-  let to_bits (b1, b2, b3, b4) = (b1, b2, b3, b4)
+  let to_bits (b1, b2, b3, b4) = [b1; b2; b3; b4]
   let to_int (b1, b2, b3, b4) = (8 * Bit.to_int b1) + (4 * Bit.to_int b2) + 
                                 (2 * Bit.to_int b3) + Bit.to_int b4

Deliverables/D4.1/SFR.ml

@@ -17 +17 @@
   type sfr
 
-  val empty: sfr
+  val power_on: sfr
 
   val get_p0: sfr -> byte

Deliverables/D4.1/Word.ml

@@ -17 +17 @@
   type byte
   type word = private byte * byte
+
+  val to_bits: word -> bit list
+
+  val iter_bit: (bit -> string) -> word -> string
+
+  val to_string: word -> string
 end;;
 
@@ -33 +39 @@
   type byte = Byte.byte
   type word = (byte * byte)
+
+  let to_bits (b1, b2) = Byte.to_bits b1 @ Byte.to_bits b2
+
+  let iter_bit f w = foldr (^) "" (map f (to_bits w))
+
+  let to_string = iter_bit Bit.to_string
 end;;
 

Deliverables/D4.1/Word11.ml

@@ -16 +16 @@
   type word11 = private (bit * bit * bit * byte)
 
+  val get_bit_at: int -> word11 -> bit option
+  val set_bit_at: int -> bit -> word11 -> word11 option
+
+  val (-&-): word11 -> word11 -> word11
+  val (-|-): word11 -> word11 -> word11
+  val (-^-): word11 -> word11 -> word11
+(*
+  val rotate_right: word11 -> word11
+  val rotate_left: word11 -> word11
+  val shift_right: word11 -> word11
+  val shift_left: word11 -> word11
+*)
+  val not: word11 -> word11
+
+  val map_bit: (bit -> bit) -> word11 -> word11
+  val iter_bit: (bit -> string) -> word11 -> string
+  val zip_bit: (bit -> bit -> bit) -> word11 -> word11 -> word11
+
+  val zero: word11
+
+  val half_add: word11 -> word11 -> (word11 * bit)
+  val full_add: (word11 * bit) -> word11 -> (word11 * bit)
+
   val to_string: word11 -> string
 end;;
@@ -29 +52 @@
   type word11 = bit * bit * bit * byte
 
-  let to_string (b1,b2,b3,b) =
-    Bit.to_string b1 ^ Bit.to_string b2 ^ Bit.to_string b3 ^ Byte.to_string b
+  let get_bit_at index (b1,b2,b3,b) =
+    if index < 8 then
+      Byte.get_bit_at index b
+    else
+      match index with
+        8 -> Some b3
+      | 9 -> Some b2
+      | 10 -> Some b1
+      | _ -> None
+  let set_bit_at index new_val (b1,b2,b3,b) =
+    if index < 8 then
+      let nib = Byte.set_bit_at index new_val b in
+        match nib with
+          Some nib -> Some (b1, b2, b3, nib)
+        | None -> None
+    else
+      match index with
+        8 -> Some (b3, b2, new_val, b)
+      | 9 -> Some (b3, new_val, b1, b)
+      | 10 -> Some (new_val, b2, b1, b)
+      | _ -> None
+
+  let (-&-) (l1, l2, l3, l) (r1, r2, r3, r) =
+    (Bit.(-&-) l1 r1, Bit.(-&-) l2 r2, Bit.(-&-) l3 r3, Byte.(-&-) l r)
+  let (-|-) (l1, l2, l3, l) (r1, r2, r3, r) =
+    (Bit.(-|-) l1 r1, Bit.(-|-) l2 r2, Bit.(-|-) l3 r3, Byte.(-|-) l r)
+  let (-^-) (l1, l2, l3, l) (r1, r2, r3, r) =
+    (Bit.(-^-) l1 r1, Bit.(-^-) l2 r2, Bit.(-^-) l3 r3, Byte.(-^-) l r)
+  let not (b1, b2, b3, b) = (Bit.not b1, Bit.not b2, Bit.not b3, Byte.not b)
+
+  let map_bit f (b1, b2, b3, b) =
+    (f b1, f b2, f b3, Byte.map_bit f b)
+  let iter_bit f (b1, b2, b3, b) =
+    let n_bits = f b1 ^ f b2 ^ f b3 in
+    let n_byte = Byte.iter_bit f b in
+      n_bits ^ n_byte
+  let zip_bit f (l1, l2, l3, l) (r1, r2, r3, r) =
+    (f l1 r1, f l2 r2, f l3 r3, Byte.zip_bit f l r)
+
+  let zero = (Bit.zero, Bit.zero, Bit.zero, Byte.zero)
+
+  let to_string = iter_bit Bit.to_string
+
+  let half_add (l1, l2, l3, l) (r1, r2, r3, r) =
+    let (n, c) = Byte.half_add l r in
+    let (n3, c3) = Bit.full_add (l3, c) r3 in
+    let (n2, c2) = Bit.full_add (l2, c3) r2 in
+    let (n1, c1) = Bit.full_add (l1, c2) r1 in
+      ((n1, n2, n3, n), c1)
+  let full_add ((l1, l2, l3, l), c) (r1, r2, r3, r) =
+    let (n, c) = Byte.full_add (l, c) r in
+    let (n3, c3) = Bit.full_add (l3, c) r3 in
+    let (n2, c2) = Bit.full_add (l2, c3) r2 in
+    let (n1, c1) = Bit.full_add (l1, c2) r1 in
+      ((n1, n2, n3, n), c1)  
+  let to_string = iter_bit Bit.to_string
 end;;