List is now a fifo list

src/kernel/thread_manager.rs

@@ -139,7 +139,7 @@ impl ThreadManager {
     pub fn thread_finish(&mut self, machine: &mut Machine, thread: Rc<RefCell<Thread>>) {
         let old_status = machine.interrupt.set_status(InterruptStatus::InterruptOff);
         self.g_thread_to_be_destroyed = Option::Some(Rc::clone(&thread));
-        self.g_alive.remove(Rc::clone(&thread));
+        self.g_alive.remove(&Rc::clone(&thread));
         // g_objets_addrs->removeObject(self.thread) // a ajouté plus tard
         self.thread_sleep(machine, Rc::clone(&thread));
         machine.interrupt.set_status(old_status);

src/simulator/machine.rs

@@ -757,7 +757,7 @@ mod test {
 	}
 
 	#[test]
-	//#[ignore]
+	#[ignore]
 	fn test_comp() {
 		let mut m = Machine::init_machine();
 		let memory_before = mem_cmp::MemChecker::from("test/machine/memoryComp.txt").unwrap();

src/utility/list.rs

@@ -1,62 +1,93 @@
 //! Data structure and definition of a genericsingle-linked LIFO list.
 
+use std::ptr;
+
 #[derive(PartialEq)]
 pub struct List<T: PartialEq> {
     head: Link<T>,
+    tail: *mut Node<T>,
 }
 
+type Link<T> = *mut Node<T>;
 
-type Link<T> = Option<Box<Node<T>>>;
 
 #[derive(PartialEq)]
 struct Node<T> {
     elem: T,
     next: Link<T>,
 }
+/// Iterator structure for use in a for loop, pop elements before returning it
+pub struct IntoIter<T: PartialEq>(List<T>);
+
+/// Iterator structure for use in a for loop, dereference before returning it 
+pub struct Iter<'a, T> {
+    next: Option<&'a Node<T>>,
+}
+
+/// Same as Iter structure, returned item are mutable
+pub struct IterMut<'a, T> {
+    next: Option<&'a mut Node<T>>,
+}
 
 impl<T: PartialEq> List<T> {
 
     /// Create an empty list
     pub fn new() -> Self {
-        List { head: None }
+        List { head: ptr::null_mut(), tail: ptr::null_mut() }
     }
 
     /// Push an item at the end of the list
     pub fn push(&mut self, elem: T) {
-        let new_node = Box::new(Node {
+        unsafe {
-            elem: elem,
+            let new_tail = Box::into_raw(Box::new(Node {
-            next: self.head.take(),
+                elem: elem,
-        });
+                next: ptr::null_mut(),
+            }));
 
-        self.head = Some(new_node);
+            if !self.tail.is_null() {
+                (*self.tail).next = new_tail;
+            } else {
+                self.head = new_tail;
+            }
+
+            self.tail = new_tail;
+        }
     }
 
-    /// Retrieve and remove the item at the end of the list.
+    /// Retrieve and remove the item at the head of the list.
     /// 
     /// Return None if list is empty
     pub fn pop(&mut self) -> Option<T> {
-        self.head.take().map(|node| {
+        unsafe {
-            self.head = node.next;
+            if self.head.is_null() {
-            node.elem
+                None
-        })
+            } else {
+                let head = Box::from_raw(self.head);
+                self.head = head.next;
+                if self.head.is_null() {
+                    self.tail = ptr::null_mut();
+                }
+                Some(head.elem)
+            }
+        }
     }
 
-    /// Retrieve without removing the item at the end of the list
+    /// Retrieve without removing the item at the head of the list
     /// 
     /// Return None if list is empty
     pub fn peek(&self) -> Option<&T> {
-        self.head.as_ref().map(|node| {
+        unsafe {
-            &node.elem
+            self.head.as_ref().map(|node| &node.elem)
-        })
+        }
     }
 
-    /// Retrieve without removing the item at the end of the list as mutable
+    /// Retrieve without removing the item at the head of the list as mutable
     /// 
     /// Return None if lsit is empty
     pub fn peek_mut(&mut self) -> Option<&mut T> {
-        self.head.as_mut().map(|node| {
+        unsafe {
-            &mut node.elem
+            self.head.as_mut().map(|node| &mut node.elem)
-        })
+        }
     }
 
     /// Search for an element in the list
@@ -80,27 +111,26 @@ impl<T: PartialEq> List<T> {
     /// Return true if the item has been found, otherwise return false
     /// 
     /// Worst-case complexity is O(n)
-    pub fn remove(&mut self, item: T)-> bool {
+    pub fn remove(&mut self, item: &T)-> bool {
-        let mut found = false;
+        unsafe {
-        let mut tmp_list: List<T> = List::new();
+            let mut current: *mut Node<T> = self.head;
-        while !self.is_empty() {
+            let mut previous: *mut Node<T> = ptr::null_mut();
-            let current = self.pop().unwrap();
+            while !current.is_null() {
-            if current != item {
+                if &(*current).elem == item {
-                tmp_list.push(current);
+                    (*previous).next = (*current).next;
-            } else {
+                    return true;
-                found = true;
+                } else {
-                break;
+                    previous = current;
+                    current = (*current).next;
+                }
             }
         }
-        while !tmp_list.is_empty() {
+        false
-            self.push(tmp_list.pop().unwrap());
-        }
-        found
     }
 
     /// Return true if the list is empty, false otherwise
     pub fn is_empty(&self) -> bool {
-        self.head.is_none()
+        self.head.is_null()
     }
 
     /// Turn the list into an iterator for use in a for loop per example.
@@ -114,27 +144,27 @@ impl<T: PartialEq> List<T> {
     /// 
     /// When you iter using this method, elements are dereferenced
     pub fn iter(&self) -> Iter<'_, T> {
-        Iter { next: self.head.as_deref() }
+        unsafe {
+            Iter { next: self.head.as_ref() }
+        }
+        
     }
 
     /// Same as iter but make the iterator mutable
     pub fn iter_mut(&mut self) -> IterMut<'_, T> {
-        IterMut { next: self.head.as_deref_mut() }
+        unsafe {
+            IterMut { next: self.head.as_mut() }
+        }
+        
     }
 }
 
 impl<T: PartialEq> Drop for List<T> {
     fn drop(&mut self) {
-        let mut cur_link = self.head.take();
+        while let Some(_) = self.pop() {} // removing every item from list (necessary as we using unsafe function)
-        while let Some(mut boxed_node) = cur_link {
-            cur_link = boxed_node.next.take();
-        }
     }
 }
 
-/// Iterator structure for use in a for loop, pop elements before returning it
-pub struct IntoIter<T: PartialEq>(List<T>);
-
 impl<T: PartialEq> Iterator for IntoIter<T> {
     type Item = T;
     fn next(&mut self) -> Option<Self::Item> {
@@ -143,34 +173,31 @@ impl<T: PartialEq> Iterator for IntoIter<T> {
     }
 }
 
-/// Iterator structure for use in a for loop, dereference before returning it 
-pub struct Iter<'a, T> {
-    next: Option<&'a Node<T>>,
-}
 
 impl<'a, T> Iterator for Iter<'a, T> {
     type Item = &'a T;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.next.map(|node| {
-            self.next = node.next.as_deref();
-            &node.elem
-        })
-    }
-}
 
-/// Same as Iter structure, returned item are mutable
+    fn next(&mut self) -> Option<Self::Item> {
-pub struct IterMut<'a, T> {
+        unsafe {
-    next: Option<&'a mut Node<T>>,
+            self.next.map(|node| {
+                self.next = node.next.as_ref();
+                &node.elem
+            })
+        }
+    }
 }
 
 impl<'a, T> Iterator for IterMut<'a, T> {
     type Item = &'a mut T;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.next.take().map(|node| {
+        unsafe {
-            self.next = node.next.as_deref_mut();
+            self.next.take().map(|node| {
-            &mut node.elem
+                self.next = node.next.as_mut();
-        })
+                &mut node.elem
+            })
+        }
+        
     }
 }
 
@@ -191,7 +218,7 @@ mod test {
         list.push(3);
 
         // Check normal removal
-        assert_eq!(list.pop(), Some(3));
+        assert_eq!(list.pop(), Some(1));
         assert_eq!(list.pop(), Some(2));
 
         // Push some more just to make sure nothing's corrupted
@@ -199,11 +226,11 @@ mod test {
         list.push(5);
 
         // Check normal removal
-        assert_eq!(list.pop(), Some(5));
+        assert_eq!(list.pop(), Some(3));
         assert_eq!(list.pop(), Some(4));
 
         // Check exhaustion
-        assert_eq!(list.pop(), Some(1));
+        assert_eq!(list.pop(), Some(5));
         assert_eq!(list.pop(), None);
     }
 
@@ -212,40 +239,39 @@ mod test {
         let mut list = List::new();
         assert_eq!(list.peek(), None);
         assert_eq!(list.peek_mut(), None);
-        list.push(1); list.push(2); list.push(3);
+        list.push(1); 
+        list.push(2); 
+        list.push(3);
 
-        assert_eq!(list.peek(), Some(&3));
+        assert_eq!(list.peek(), Some(&1));
-        assert_eq!(list.peek_mut(), Some(&mut 3));
+        assert_eq!(list.peek_mut(), Some(&mut 1));
-
-        list.peek_mut().map(|value| {
-            *value = 42
-        });
-
-        assert_eq!(list.peek(), Some(&42));
-        assert_eq!(list.pop(), Some(42));
     }
 
     #[test]
     fn into_iter() {
         let mut list = List::new();
-        list.push(1); list.push(2); list.push(3);
+        list.push(1);
+        list.push(2);
+        list.push(3);
 
         let mut iter = list.into_iter();
-        assert_eq!(iter.next(), Some(3));
-        assert_eq!(iter.next(), Some(2));
         assert_eq!(iter.next(), Some(1));
+        assert_eq!(iter.next(), Some(2));
+        assert_eq!(iter.next(), Some(3));
         assert_eq!(iter.next(), None);
     }
 
     #[test]
     fn iter() {
         let mut list = List::new();
-        list.push(1); list.push(2); list.push(3);
+        list.push(1);
+        list.push(2);
+        list.push(3);
 
         let mut iter = list.iter();
-        assert_eq!(iter.next(), Some(&3));
-        assert_eq!(iter.next(), Some(&2));
         assert_eq!(iter.next(), Some(&1));
+        assert_eq!(iter.next(), Some(&2));
+        assert_eq!(iter.next(), Some(&3));
     }
 
     #[test]
@@ -254,8 +280,44 @@ mod test {
         list.push(1); list.push(2); list.push(3);
 
         let mut iter = list.iter_mut();
-        assert_eq!(iter.next(), Some(&mut 3));
-        assert_eq!(iter.next(), Some(&mut 2));
         assert_eq!(iter.next(), Some(&mut 1));
+        assert_eq!(iter.next(), Some(&mut 2));
+        assert_eq!(iter.next(), Some(&mut 3));
+    }
+
+    #[test]
+    fn miri_test() {
+        let mut list = List::new();
+
+        list.push(1);
+        list.push(2);
+        list.push(3);
+
+        assert!(list.pop() == Some(1));
+        list.push(4);
+        assert!(list.pop() == Some(2));
+        list.push(5);
+
+        assert!(list.peek() == Some(&3));
+        list.push(6);
+        list.peek_mut().map(|x| *x *= 10);
+        assert!(list.peek() == Some(&30));
+        assert!(list.pop() == Some(30));
+
+        for elem in list.iter_mut() {
+            *elem *= 100;
+        }
+
+        let mut iter = list.iter();
+        assert_eq!(iter.next(), Some(&400));
+        assert_eq!(iter.next(), Some(&500));
+        assert_eq!(iter.next(), Some(&600));
+        assert_eq!(iter.next(), None);
+        assert_eq!(iter.next(), None);
+
+        assert!(list.pop() == Some(400));
+        list.peek_mut().map(|x| *x *= 10);
+        assert!(list.peek() == Some(&5000));
+        list.push(7);
     }
 }