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;           
  Address funcaddr;     
  Address addr;         
  int4 uniq;            
  string text;          
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) {}  
  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