src/core/InformationManager.hxx

   1 #ifndef INCLUDE__InformationManager_hxx
   2 #define INCLUDE__InformationManager_hxx
   3
   4 #include <boost/signals2.hpp>
   5 #include <functional>
   6 #include <string>
   7 #include <map>
   8
   9 class Disassembler;
  10 class Function;
  11 class BasicBlock;
  12 class Comment;
  13
  14 class QString;
  15
  16 class RenameFunctionEvent;
  17
  18 class InformationManager {
  19 public:
  20         ~InformationManager();
  21
  22         void reset(const std::string& filename);
  23         void save(const QString& filename);
  24
  25         void signal_new_function(Function* f);
  26         void signal_new_dyn_symbol(const std::string& f)
  27                 { new_dyn_symbol_signal(f);     }
  28
  29         boost::signals2::connection
  30         connect_new_function_signal(std::function<void(Function*)> f)
  31                 { return new_function_signal.connect(f); }
  32
  33         boost::signals2::connection
  34         connect_new_dyn_symbol_signal(std::function<void(const std::string& name)> f)
  35                 { return new_dyn_symbol_signal.connect(f); }
  36
  37         boost::signals2::connection
  38         connect_reset_signal(std::function<void ()> f)
  39                 { return reset_signal.connect(f); }
  40
  41         boost::signals2::connection
  42         connect_rename_function_signal(std::function<void (RenameFunctionEvent*)> f)
  43                 { return rename_function_signal.connect(f); }
  44
  45         Disassembler* getDisassembler()
  46                 { return disassembler.get(); }
  47
  48         void dispatch(RenameFunctionEvent* event)
  49                 { rename_function_signal(event); }
  50
  51         Function* getFunction(uint64_t address);
  52         BasicBlock* getBasicBlock(uint64_t address);
  53
  54         /* Protocoll:
  55          *
  56          * Users may allocate new Data containers with the new*()
  57          * functions. Once they have populated the information they hand
  58          * over the object to the information manager using the finish*()
  59          * functions.
  60          *
  61          * if new*() returns NULL there already exists a function at the
  62          * specified address. Users may then get the old object if they
  63          * wish or (more likely) skip creating it. Uniqueness of the
  64          * object is only guaranteed as compared to the finish()ed
  65          * objects.
  66          *
  67          * Users are responsible for destroying functions iff they do not
  68          * finish them using the delete*() functions. Once the objects are
  69          * finished, the information manager is responsible for cleaning
  70          * up the memory. If delete*() is called on a finished object, bad
  71          * thingsmay happen.
  72          */
  73         Function* newFunction(uint64_t address);
  74         BasicBlock* newBasicBlock(uint64_t address);
  75         Comment* newGlobalComment(uint64_t address);
  76         Comment* newLocalComment(uint64_t address, Function* f);
  77         void finishFunction(Function* f);
  78         void finishBasicBlock(BasicBlock* b);
  79         void finnishComment(Comment* c);
  80         void deleteFunction(Function* f);
  81         void deleteBasicBlock(BasicBlock* b);
  82         void deleteComment(Comment* c);
  83 private:
  84         boost::signals2::signal<void ()> reset_signal;
  85         boost::signals2::signal<void (Function*)> new_function_signal;
  86         boost::signals2::signal<void (const std::string& name)> new_dyn_symbol_signal;
  87         boost::signals2::signal<void (RenameFunctionEvent*)> rename_function_signal;
  88         std::unique_ptr<Disassembler> disassembler;
  89         std::map<uint64_t, Function*> functions;
  90         std::map<uint64_t, BasicBlock*> blocks;
  91 };
  92
  93 #endif /* INCLUDE__InformationManager_hxx */