Nettoyage des commentaires

src/algo.c

@@ -121,7 +121,7 @@ int get_event_machine(const struct event_key_t * key) {
  * @param[in] key 
  */
 void view_event_key(const void * key) {
-	// A FAIRE
+	
 	const struct event_key_t* ekey = (const struct event_key_t *) key;
 	printf("event type: %d,  event time: %lu, processing time: %lu, task id: %s, machine: %d\n", 
 	ekey->event_type, ekey->event_time, ekey->processing_time, ekey->task_id, ekey->machine);
@@ -147,7 +147,7 @@ void delete_event_key(void * key) {
  * @return int 
  */
 int event_preceed(const void * a, const void * b) {
-	// A FAIRE
+	
 	const struct event_key_t* Akey = (const struct event_key_t *) a;
 	const struct event_key_t* Bkey = (const struct event_key_t *) b;
 	if(Akey->event_time < Bkey->event_time) {
@@ -198,7 +198,7 @@ struct ready_task_key_t {
  * @return struct ready_task_key_t* 
  */
 struct ready_task_key_t * new_ready_task_key(unsigned long remaining_processing_time, char * task_id) {
-	// A FAIRE
+	
 	struct ready_task_key_t *key = malloc(sizeof(struct ready_task_key_t));
     key->remaining_processing_time = remaining_processing_time;
     key->task_id = strdup(task_id);
@@ -212,7 +212,7 @@ struct ready_task_key_t * new_ready_task_key(unsigned long remaining_processing_
  * @return unsigned long 
  */
 unsigned long get_ready_task_remaining_processing_time(const struct ready_task_key_t * key) {
-	// A FAIRE
+	
 	assert(key);
 	return key->remaining_processing_time;
 }
@@ -224,7 +224,7 @@ unsigned long get_ready_task_remaining_processing_time(const struct ready_task_k
  * @return char* 
  */
 char * get_ready_task_id(const struct ready_task_key_t * key) {
-	// A FAIRE
+	
 	assert(key);
 	return key->task_id;
 }
@@ -235,7 +235,7 @@ char * get_ready_task_id(const struct ready_task_key_t * key) {
  * @param[in] key 
  */
 void view_ready_task_key(const void * key) {
-	// A FAIRE
+	
 	const struct ready_task_key_t *ready_key = (const struct ready_task_key_t *) key;
     printf(" remaining processing time: %lu |  task id: %s\n", ready_key->remaining_processing_time, ready_key->task_id);
 }
@@ -246,7 +246,7 @@ void view_ready_task_key(const void * key) {
  * @param[in] key 
  */
 void delete_ready_task_key(void * key) {
-	// A FAIRE
+	
 	struct ready_task_key_t *ready_key = (struct ready_task_key_t *) key;
     free(ready_key->task_id);
     free(ready_key);
@@ -261,7 +261,7 @@ void delete_ready_task_key(void * key) {
  * @return int 
  */
 int ready_task_preceed(const void * a, const void * b) {
-	// A FAIRE
+	
 	struct ready_task_key_t* ta = a;
 	struct ready_task_key_t* tb = b;
 	int res = get_ready_task_remaining_processing_time(b) - get_ready_task_remaining_processing_time(a);

src/instance.c

@@ -37,7 +37,7 @@ unsigned long get_task_release_time(const struct task_t * task) {
 }
 
 void view_task(const void * task) {
-	// A FAIRE
+	
 	assert(task);
 	struct task_t * tk = (struct task_t *) task;
 	printf("Task: %s ProcessingTime: %lu ReleaseTime: %lu \n", tk->id, tk->processing_time, tk->release_time );
@@ -76,13 +76,13 @@ Instance read_instance(const char * filename) {
 }
 
 void view_instance(Instance I) {
-	// A FAIRE
+	
 	assert(I);
 	view_list(I);
 }
 
 void delete_instance(Instance I, int deleteData) {
-	// A FAIRE
+	
 	assert(I);
 	delete_list(I, deleteData);
 }

src/list.c

@@ -100,12 +100,12 @@ void set_list_size(struct list_t * L, int newSize) {
 }
 
 void set_head(struct list_t * L, struct list_node_t * newHead) {
-	// A FAIRE
+	
 	L->head = newHead;
 }
 
 void set_tail(struct list_t * L, struct list_node_t * newTail) {
-	// A FAIRE
+	
 	L->tail = newTail;
 }
 
@@ -160,7 +160,7 @@ void list_insert_last(struct list_t * L, void * data) {
 }
 
 void list_insert_after(struct list_t * L, void * data, struct list_node_t * ptrelm) {
-	// A FAIRE
+	
 	struct list_node_t *new_node = new_list_node(data); //here
 	new_node->successor = ptrelm->successor;
 	new_node->predecessor = ptrelm;
@@ -176,7 +176,7 @@ void list_insert_after(struct list_t * L, void * data, struct list_node_t * ptre
 
 void * list_remove_first(struct list_t * L) {
 	assert(get_list_head(L));
-	// A FAIRE
+	
 	struct list_node_t *head = L->head;
 	if (head->successor) {
 		head->successor->predecessor = NULL;
@@ -193,7 +193,7 @@ void * list_remove_first(struct list_t * L) {
 
 void * list_remove_last(struct list_t * L) {
 	assert(get_list_head(L));
-	// A FAIRE
+	
 	struct list_node_t *tail = L->tail;
 	if (tail->predecessor) {
 		tail->predecessor->successor = NULL;
@@ -210,7 +210,7 @@ void * list_remove_last(struct list_t * L) {
 
 void * list_remove_node(struct list_t * L, struct list_node_t * node) {
 	assert(get_list_head(L) && get_list_tail(L));
-	// A FAIRE
+	
 	if (node->predecessor) {
 		node->predecessor->successor = node->successor;
 	} else {

src/schedule.c

@@ -30,37 +30,37 @@ static struct schedule_node_t * new_schedule_node(struct task_t * task, unsigned
 }
 
 struct task_t * get_schedule_node_task(const struct schedule_node_t * snode) {
-	// A FAIRE
+	
 	assert(snode);
 	return snode->task;
 }
 
 unsigned long get_schedule_node_begin_time(const struct schedule_node_t * snode) {
-	// A FAIRE
+	
 	assert(snode);
 	return snode->begin_time;
 }
 
 unsigned long get_schedule_node_end_time(const struct schedule_node_t * snode) {
-	// A FAIRE
+	
 	assert(snode);
 	return snode->end_time;
 }
 
 void set_schedule_node_begin_time(struct schedule_node_t * snode, unsigned long new_bt) {
-	// A FAIRE
+	
 	assert(snode);
 	snode->begin_time = new_bt;
 }
 
 void set_schedule_node_end_time(struct schedule_node_t * snode, unsigned long new_et) {
-	// A FAIRE
+	
 	assert(snode);
 	snode->end_time = new_et;
 }
 
 void view_schedule_node(const void * snode) {
-	// A FAIRE
+	
 	assert(snode);
 	struct schedule_node_t *node = (struct schedule_node_t*)snode;
 	view_task(node->task);
@@ -89,19 +89,19 @@ struct schedule_t * new_schedule(int num_m) {
 }
 
 struct list_t * get_schedule_of_machine(const struct schedule_t * S, const int machine) {
-	// A FAIRE
+	
 	assert(S);
 	return S->schedule[machine];
 }
 
 int get_num_machines(const struct schedule_t * S) {
-	// A FAIRE
+	
 	assert(S);
 	return S->num_machines;
 }
 
 void view_schedule(const struct schedule_t * S) {
-	// A FAIRE
+	
 	assert(S);
 	for(int i = 0; i < S->num_machines; i++){
 		view_list(S->schedule[i]);
@@ -109,7 +109,7 @@ void view_schedule(const struct schedule_t * S) {
 }
 
 void delete_schedule(struct schedule_t * S) {
-	// A FAIRE
+	
 	assert(S);
 	for(int i = 0; i < S->num_machines; i++){
 		delete_list(S->schedule[i], 1);
@@ -150,7 +150,7 @@ void save_schedule(struct schedule_t * S, char * filename) {
 
 /*
 int find_empty_machine(struct schedule_t * S, unsigned long time) {
-	// A FAIRE
+	
 	assert(S);
 	for(int i = 0; i < get_num_machines(S); i++)
 	{
@@ -180,7 +180,7 @@ int find_empty_machine(struct schedule_t * S, unsigned long time) {
 }
 
 int find_machine_to_interrupt(struct schedule_t * S, unsigned long time, unsigned long processing_time) {
-	// A FAIRE
+	
 	assert(S);
 		for(int i = 0; i < get_num_machines(S); i++)
 	{
@@ -194,7 +194,7 @@ int find_machine_to_interrupt(struct schedule_t * S, unsigned long time, unsigne
 }
 
 void add_task_to_schedule(struct schedule_t * S, struct task_t * task, int machine, unsigned long bt, unsigned long et) {
-	// A FAIRE
+	
 	assert(S);
 	assert(task);
 	assert(machine >= 0 && machine < get_num_machines(S));
@@ -206,7 +206,7 @@ void add_task_to_schedule(struct schedule_t * S, struct task_t * task, int machi
 }
 
 unsigned long preempt_task(struct schedule_t * S, int machine, unsigned long new_et) {
-	// A FAIRE int machine
+	
 	assert(S);
 	assert(machine >= 0 && machine < get_num_machines(S));
 	struct list_t* M = get_schedule_of_machine(S, machine);

src/tree.c

@@ -61,25 +61,25 @@ int get_bfactor(const struct tree_node_t * node) {
 }
 
 void set_tree_node_key(struct tree_node_t * node, void * newKey) {
-	// A FAIRE
+	
 	assert(node);
 	node->key = newKey;
 }
 
 void set_tree_node_data(struct tree_node_t * node, void * newData) {
-	// A FAIRE
+	
 	assert(node);
 	node->data = newData;
 }
 
 void set_left(struct tree_node_t * node, struct tree_node_t * newLeft) {
-	// A FAIRE
+	
 	assert(node);
 	node->left = newLeft;
 }
 
 void set_right(struct tree_node_t * node, struct tree_node_t * newRight) {
-	// A FAIRE
+	
 	assert(node);
 	node->right = newRight;
 }
@@ -119,7 +119,7 @@ struct tree_t * new_tree(int balanced, int (*preceed)(const void *, const void *
 }
 
 int tree_is_empty(struct tree_t * T) {
-	// A FAIRE
+	
 	return (T == NULL) || (T->root == NULL);
 }
 
@@ -166,7 +166,7 @@ void set_root(struct tree_t * T, struct tree_node_t * newRoot) {
  * @param[in] freeData
  */
 static void delete_tree_node(struct tree_node_t * curr, void (*freeKey)(void *), void (*freeData)(void *)) {
-	// A FAIRE
+	
 	if (!curr) return;
 	delete_tree_node(curr->left, freeKey, freeData);
 	delete_tree_node(curr->right, freeKey, freeData);
@@ -185,7 +185,7 @@ static void delete_tree_node(struct tree_node_t * curr, void (*freeKey)(void *),
 void delete_tree(struct tree_t * T, int deleteKey, int deleteData) {
 	//assert(deleteKey == 0 || deleteKey == 1);
 	//assert(deleteData == 0 || deleteData == 1);
-	// A FAIRE
+	
 	assert(T);
 	if (get_root(T))
 		delete_tree_node(T->root, deleteKey? T->freeKey : NULL, deleteData? T->freeData : NULL);
@@ -205,7 +205,7 @@ void delete_tree(struct tree_t * T, int deleteKey, int deleteData) {
 static void view_tree_inorder(struct tree_node_t * curr,
 						void (*viewKey)(const void *),
 						void (*viewData)(const void *)) {
-	// A FAIRE
+	
 	if (tree_node_is_empty(curr)) return;
 	
 	view_tree_inorder(curr->left, viewKey, viewData);
@@ -331,7 +331,7 @@ static struct tree_node_t * insert_into_tree_node(struct tree_node_t * curr, voi
 	// - recherche récursif de la position à insérer
 	// - mise à jour du facteur d'équilibre
 
-	// A FAIRE
+	
 
 	// Exception
 	if (curr == NULL) {
@@ -501,7 +501,7 @@ static struct tree_node_t * remove_tree_node(struct tree_node_t * curr, void * k
 		}
 	}
 
-	// A FAIRE
+	
 	if (balanced && curr) {
 		// PARTIE 2 :
 		// Gérer ici les rotations