From 9978818444ffe36d431f1a17bdc4990c0e8dc21d Mon Sep 17 00:00:00 2001
From: Moysan Gabriel <gabriel.moysan.1@etudiant.univ-rennes1.fr>
Date: Tue, 7 Feb 2023 22:40:53 +0100
Subject: [PATCH 1/2] test creation section + conversion hexa

---
 src/simulator/mem_cmp.rs | 109 +++++++++++++++++++++++++++++++++++++--
 src/simulator/mod.rs     |   1 +
 2 files changed, 107 insertions(+), 3 deletions(-)

diff --git a/src/simulator/mem_cmp.rs b/src/simulator/mem_cmp.rs
index 7da05f7..41bcf3a 100644
--- a/src/simulator/mem_cmp.rs
+++ b/src/simulator/mem_cmp.rs
@@ -37,8 +37,33 @@ struct Section{
     content: Vec<u8>, // la donnée en question
 }
 
+/*
+* c doit etre un caractère hexadécimale
+ */
+fn one_hex_to_dec(c: char) -> u8 {
 
+    match c {
+        'A' | 'a' => 10,
+        'B' | 'b' => 11,
+        'C' | 'c' => 12,
+        'D' | 'd' => 13,
+        'E' | 'e' => 14,
+        'F' | 'f' => 15,
+        _ => {
+             let ret : u8 = c.to_digit(10).unwrap() as u8;
+            return ret; 
+            },
+        }
+    }
 
+   
+
+fn two_hex_to_u8(c1: char, c2: char) -> u8 {
+    let a = one_hex_to_dec(c1);
+    let b = one_hex_to_dec(c2);
+
+    16*a + b
+}
 
 /*
 * Voir si instanciation d'une structure deplace les valeurs "locales" à la méthode from, je sais plus ....
@@ -49,12 +74,90 @@ impl Section{
         let addr: usize = section.addr.parse().unwrap();
         let len: usize = section.len.parse().unwrap();
 
-        /*
-        * Remplissage de content
-        */
+        let mut tmp_a: char = ' ';
+        let mut tmp_b: char = ' ';
+
+        for (i, c) in section.content.chars().enumerate(){
+
+            if i%2 == 0 {
+                tmp_a = c;
+            }
+            else {
+                tmp_b = c;
+                content.push(two_hex_to_u8(tmp_a,tmp_b));
+            }
+        }
 
 
         Section{addr:addr, len:len, content:content}
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_section_content(){
+        let section_format = SectionFormat{
+            addr: "0".to_string(),
+            len: "0".to_string(),
+            content: "00FF0AA0A5".to_string(),
+        };
+
+        let section = Section::from(&section_format);
+        let mut expected_vec:  Vec<u8> = Vec::new();
+        expected_vec.push(0u8);
+        expected_vec.push(255u8);
+        expected_vec.push(10u8);
+        expected_vec.push(160u8);
+        expected_vec.push(165u8);
+
+        //println!("Vec from created section {:?}", &section.content);
+        //println!("Expected vec {:?}", &expected_vec);
+
+        assert_eq!(section.content, expected_vec);
+    }
+
+    #[test]
+    fn test_mod(){
+        let cond = (0%2) == 0;
+        assert_eq!(true, cond);
+    }
+
+    #[test]
+    fn test_mod_2(){
+        let cond = (1%2) == 1;
+        assert_eq!(true, cond);
+    }
+
+    #[test]
+    fn test_hex_1(){
+        let b = two_hex_to_u8('0', '0');
+        assert_eq!(0u8, b);
+    }
+
+    #[test]
+    fn test_hex_2(){
+        let b = two_hex_to_u8('F', 'F');
+        assert_eq!(255u8, b);
+    }
+
+    #[test]
+    fn test_hex_3(){
+        let b = two_hex_to_u8('0', 'A');
+        assert_eq!(10u8, b);
+    }
+
+    #[test]
+    fn test_hex_4(){
+        let b = two_hex_to_u8('A', '0');
+        assert_eq!(160u8, b);
+    }
+
+    #[test]
+    fn test_hex_5(){
+        let b = two_hex_to_u8('A', '5');
+        assert_eq!(165u8, b);
+    }
+}
\ No newline at end of file
diff --git a/src/simulator/mod.rs b/src/simulator/mod.rs
index 16e19a5..76c2931 100644
--- a/src/simulator/mod.rs
+++ b/src/simulator/mod.rs
@@ -1,6 +1,7 @@
 pub mod machine;
 pub mod decode;
 pub mod print;
+mod mem_cmp;
 
 
 pub mod global {

From 70210699a467c918d0b8b299f6c499d54ca8b1a1 Mon Sep 17 00:00:00 2001
From: Moysan Gabriel <gabriel.moysan.1@etudiant.univ-rennes1.fr>
Date: Tue, 7 Feb 2023 22:50:55 +0100
Subject: [PATCH 2/2] squelette Mem_Checker

---
 src/simulator/mem_cmp.rs | 78 +++++++++++++++++++++++++---------------
 1 file changed, 50 insertions(+), 28 deletions(-)

diff --git a/src/simulator/mem_cmp.rs b/src/simulator/mem_cmp.rs
index 41bcf3a..859bfad 100644
--- a/src/simulator/mem_cmp.rs
+++ b/src/simulator/mem_cmp.rs
@@ -37,34 +37,6 @@ struct Section{
     content: Vec<u8>, // la donnée en question
 }
 
-/*
-* c doit etre un caractère hexadécimale
- */
-fn one_hex_to_dec(c: char) -> u8 {
-
-    match c {
-        'A' | 'a' => 10,
-        'B' | 'b' => 11,
-        'C' | 'c' => 12,
-        'D' | 'd' => 13,
-        'E' | 'e' => 14,
-        'F' | 'f' => 15,
-        _ => {
-             let ret : u8 = c.to_digit(10).unwrap() as u8;
-            return ret; 
-            },
-        }
-    }
-
-   
-
-fn two_hex_to_u8(c1: char, c2: char) -> u8 {
-    let a = one_hex_to_dec(c1);
-    let b = one_hex_to_dec(c2);
-
-    16*a + b
-}
-
 /*
 * Voir si instanciation d'une structure deplace les valeurs "locales" à la méthode from, je sais plus ....
  */
@@ -93,6 +65,51 @@ impl Section{
     }
 }
 
+/*
+* Representation de l'etat de la mémoire (apres execution.... a  confirmer), sous forme de sections
+*/
+struct Mem_Checker{
+    pc: usize,
+    sp: usize,
+    sections: Vec<Section>,
+}
+
+
+impl Mem_Checker{
+    /*fn from(path: &String) -> Mem_Checker{
+
+    }*/
+}
+
+
+/*
+* c doit etre un caractère hexadécimale
+ */
+fn one_hex_to_dec(c: char) -> u8 {
+
+    match c {
+        'A' | 'a' => 10,
+        'B' | 'b' => 11,
+        'C' | 'c' => 12,
+        'D' | 'd' => 13,
+        'E' | 'e' => 14,
+        'F' | 'f' => 15,
+        _ => {
+             let ret : u8 = c.to_digit(10).unwrap() as u8;
+            return ret; 
+            },
+        }
+    }
+
+   
+
+fn two_hex_to_u8(c1: char, c2: char) -> u8 {
+    let a = one_hex_to_dec(c1);
+    let b = one_hex_to_dec(c2);
+
+    16*a + b
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -119,6 +136,11 @@ mod tests {
         assert_eq!(section.content, expected_vec);
     }
 
+
+
+
+
+    
     #[test]
     fn test_mod(){
         let cond = (0%2) == 0;