Reorganized the whole disassembling process and displayed the relative progression.

1 files changed, 65 insertions, 24 deletions

diff --git a/src/analysis/disass/routines.c b/src/analysis/disass/routines.c
index 280757a..3e0aa71 100644
--- a/src/analysis/disass/routines.c
+++ b/src/analysis/disass/routines.c
@@ -25,6 +25,7 @@
 
 
 #include "dragon.h"
+#include "limit.h"
 #include "loop.h"
 #include "macro.h"
 #include "rank.h"
@@ -44,6 +45,8 @@ struct _GRoutinesStudy
 
     GBinRoutine **routines;                 /* Liste de routines à traiter */
     size_t count;                           /* Taille de cette liste       */
+
+    rtn_fallback_cb fallback;               /* Routine de traitement finale*/
     size_t begin;                           /* Point de départ du parcours */
     size_t end;                             /* Point d'arrivée exclu       */
 
@@ -176,6 +179,7 @@ static void g_routines_study_finalize(GRoutinesStudy *computing)
 *                begin    = point de départ du parcours de liste.             *
 *                end      = point d'arrivée exclu du parcours.                *
 *                id       = identifiant du message affiché à l'utilisateur.   *
+*                fallback = routine de traitements particuliers.              *
 *                                                                             *
 *  Description : Crée une tâche d'étude de routines différée.                 *
 *                                                                             *
@@ -185,7 +189,7 @@ static void g_routines_study_finalize(GRoutinesStudy *computing)
 *                                                                             *
 ******************************************************************************/
 
-GRoutinesStudy *g_routines_study_new(const GArchProcessor *proc, mrange_t *exe_ranges, size_t exe_count, GBinRoutine **routines, size_t count, size_t begin, size_t end, activity_id_t id)
+GRoutinesStudy *g_routines_study_new(const GArchProcessor *proc, mrange_t *exe_ranges, size_t exe_count, GBinRoutine **routines, size_t count, size_t begin, size_t end, activity_id_t id, rtn_fallback_cb fallback)
 {
     GRoutinesStudy *result;                /* Tâche à retourner           */
 
@@ -198,6 +202,8 @@ GRoutinesStudy *g_routines_study_new(const GArchProcessor *proc, mrange_t *exe_r
 
     result->routines = routines;
     result->count = count;
+
+    result->fallback = fallback;
     result->begin = begin;
     result->end = end;
 
@@ -224,55 +230,90 @@ GRoutinesStudy *g_routines_study_new(const GArchProcessor *proc, mrange_t *exe_r
 static void g_routines_study_process(GRoutinesStudy *study, GtkStatusStack *status)
 {
     size_t i;                               /* Boucle de parcours          */
-    GBinRoutine *routine;                   /* Routine en traitement       */
-    const mrange_t *range;                  /* Couverture d'une routine    */
-    const vmpa2t *start;                    /* Adresse de départ           */
-    const instr_coverage *coverage;         /* Instructions couvertes      */
-    dragon_knight *knight;                  /* Complexité de code posée    */
-    //dragon_node *nodes;                     /* Liste des noeuds détectés   */
-    //size_t count;                           /* Taille de cette liste       */
 
     for (i = study->begin; i < study->end; i++)
     {
-        //gtk_extended_status_bar_update_activity(statusbar, id, (i + 1) * 1.0 / count);
-
-        routine = study->routines[i];
+        study->fallback(study, i);
 
-        /* Préparatifs communs */
+        gtk_status_stack_update_activity_value(status, study->id, 1);
 
-        range = g_binary_routine_get_range(routine);
-        start = get_mrange_addr(range);
-
-        coverage = g_arch_processor_find_coverage_by_address(study->proc, start);
+    }
 
-        knight = begin_dragon_knight(study->proc, coverage, range, start);
+}
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : study = étude de routines à mener.                           *
+*                index = indice de l'insruction visée.                        *
+*                                                                             *
+*  Description : Détermine si besoin est les bornes des routines.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+void g_routines_study_compute_limits(GRoutinesStudy *study, size_t index)
+{
+    GBinRoutine *routine;                   /* Routine à traiter           */
+    GBinRoutine *next;                      /* Routine suivante éventuelle */
 
-        detect_loops_in_code(knight);
+    routine = study->routines[index];
 
+    if ((index + 1) < study->count)
+        next = study->routines[index + 1];
+    else
+        next = NULL;
 
+    compute_routine_limit(routine, next, study->proc, study->exe_ranges, study->exe_count);
 
-        /* Phase AAAA : regroupement des instructions par blocs */
+}
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : study = étude de routines à mener.                           *
+*                index = indice de l'insruction visée.                        *
+*                                                                             *
+*  Description : Procède au traitement des blocs de routines.                 *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+void g_routines_study_handle_blocks(GRoutinesStudy *study, size_t index)
+{
+    GBinRoutine *routine;                   /* Routine à traiter           */
+    const mrange_t *range;                  /* Couverture d'une routine    */
+    const vmpa2t *start;                    /* Adresse de départ           */
+    const instr_coverage *coverage;         /* Instructions couvertes      */
+    dragon_knight *knight;                  /* Complexité de code posée    */
 
-        group_routine_instructions(routine, knight);
+    routine = study->routines[index];
 
+    /* Préparatifs communs */
 
+    range = g_binary_routine_get_range(routine);
+    start = get_mrange_addr(range);
 
+    coverage = g_arch_processor_find_coverage_by_address(study->proc, start);
 
+    knight = begin_dragon_knight(study->proc, coverage, range, start);
 
-        rank_routine_blocks(routine);
+    /* Traitement par blocs */
 
+    detect_loops_in_code(knight);
 
+    group_routine_instructions(routine, knight);
 
-        /* Nettoyage final */
+    rank_routine_blocks(routine);
 
-        end_dragon_knight(knight);
+    /* Nettoyage final */
 
-    }
+    end_dragon_knight(knight);
 
 }