comment.hh

Go to the documentation of this file.

/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __CPUI_COMMENT__
#define __CPUI_COMMENT__
 
#include "address.hh"
 
class FlowBlock;
class PcodeOp;
class Funcdata;
 
class Comment {
  friend class CommentDatabaseInternal;
  uint4 type;           
  int4 uniq;            
  Address funcaddr;     
  Address addr;         
  string text;          
  mutable bool emitted;     
public:
  enum comment_type {
    user1 = 1,          
    user2 = 2,          
    user3 = 4,          
    header = 8,         
    warning = 16,       
    warningheader = 32      
  };
  Comment(uint4 tp,const Address &fad,const Address &ad,int4 uq,const string &txt); 
  Comment(void) {}  
  void setEmitted(bool val) const { emitted = val; }        
  bool isEmitted(void) const { return emitted; }        
  uint4 getType(void) const { return type; }            
  const Address &getFuncAddr(void) const { return funcaddr; }   
  const Address &getAddr(void) const { return addr; }       
  int4 getUniq(void) const { return uniq; }         
  const string &getText(void) const { return text; }        
  void saveXml(ostream &s) const;               
  void restoreXml(const Element *el,const AddrSpaceManager *manage);    
  static uint4 encodeCommentType(const string &name);       
  static string decodeCommentType(uint4 val);           
};
 
struct CommentOrder {
  bool operator()(const Comment *a,const Comment *b) const; 
};
 
typedef set<Comment *,CommentOrder> CommentSet;     
 
class CommentDatabase {
public:
  CommentDatabase(void) {}      
  virtual ~CommentDatabase(void) {} 
  virtual void clear(void)=0;       
 
  virtual void clearType(const Address &fad,uint4 tp)=0;
 
  virtual void addComment(uint4 tp,const Address &fad,
              const Address &ad,const string &txt)=0;
 
  virtual bool addCommentNoDuplicate(uint4 tp,const Address &fad,const Address &ad,const string &txt)=0;
 
  virtual void deleteComment(Comment *com)=0;
 
  virtual CommentSet::const_iterator beginComment(const Address &fad) const=0;
 
  virtual CommentSet::const_iterator endComment(const Address &fad) const=0;
 
  virtual void saveXml(ostream &s) const=0;
 
  virtual void restoreXml(const Element *el,const AddrSpaceManager *manage)=0;
};
 
 
class CommentDatabaseInternal : public CommentDatabase {
  CommentSet commentset;            
public:
  CommentDatabaseInternal(void);        
  virtual ~CommentDatabaseInternal(void);
  virtual void clear(void);
  virtual void clearType(const Address &fad,uint4 tp);
  virtual void addComment(uint4 tp,const Address &fad,
              const Address &ad,const string &txt);
  virtual bool addCommentNoDuplicate(uint4 tp,const Address &fad,const Address &ad,const string &txt);
  virtual void deleteComment(Comment *com);
  virtual CommentSet::const_iterator beginComment(const Address &fad) const;
  virtual CommentSet::const_iterator endComment(const Address &fad) const;
  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el,const AddrSpaceManager *manage);
};
 
class CommentSorter {
public:
  enum {
    header_basic = 0,       
    header_unplaced = 1     
  };
private:
  struct Subsort {
    int4 index;         
    uint4 order;        
    uint4 pos;          
 
    bool operator<(const Subsort &op2) const {
      if (index == op2.index) {
    if (order == op2.order)
      return (pos < op2.pos);
    return (order < op2.order);
      }
      return (index < op2.index);
    }
 
    void setHeader(uint4 headerType) {
      index = -1;       // -1 indicates a header comment
      order = headerType;
    }
 
    void setBlock(int4 i,uint4 ord) {
      index = i;
      order = ord;
    }
  };
  map<Subsort,Comment *> commmap;           
  mutable map<Subsort,Comment *>::const_iterator start; 
  map<Subsort,Comment *>::const_iterator stop;      
  map<Subsort,Comment *>::const_iterator opstop;    
  bool displayUnplacedComments;             
  bool findPosition(Subsort &subsort,Comment *comm,const Funcdata *fd); 
public:
  CommentSorter(void) { displayUnplacedComments = false; }  
  void setupFunctionList(uint4 tp,const Funcdata *fd,const CommentDatabase &db,bool displayUnplaced);
  void setupBlockList(const FlowBlock *bl);     
  void setupOpList(const PcodeOp *op);          
  void setupHeader(uint4 headerType);           
  bool hasNext(void) const { return (start!=opstop); }  
  Comment *getNext(void) const { Comment *res=(*start).second; ++start; return res; }   
};
 
#endif