prettyprint.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 __PRETTYPRINT__
#define __PRETTYPRINT__
 
#include "type.hh"
 
class Varnode;
class PcodeOp;
class FlowBlock;
class Funcdata;
class Symbol;
 
class EmitXml {
  static const char *highlight[];   
protected:
  ostream *s;               
  int4 indentlevel;         
  int4 parenlevel;          
  int4 indentincrement;         
  void resetDefaultsInternal(void) { indentincrement = 2; } 
public:
  EmitXml(void) { s = (ostream *)0; indentlevel=0; parenlevel=0; resetDefaultsInternal(); } 
 
  enum syntax_highlight {
    keyword_color = 0,      
    comment_color = 1,      
    type_color = 2,     
    funcname_color = 3,     
    var_color = 4,      
    const_color = 5,        
    param_color = 6,        
    global_color = 7,       
    no_color = 8        
  };
  virtual ~EmitXml(void) {}             
  virtual int4 beginDocument(void);         
  virtual void endDocument(int4 id);            
  virtual int4 beginFunction(const Funcdata *fd);   
  virtual void endFunction(int4 id);            
  virtual int4 beginBlock(const FlowBlock *bl);     
  virtual void endBlock(int4 id);           
  virtual void tagLine(void);               
  virtual void tagLine(int4 indent);            
  virtual int4 beginReturnType(const Varnode *vn);  
  virtual void endReturnType(int4 id);          
  virtual int4 beginVarDecl(const Symbol *sym);     
  virtual void endVarDecl(int4 id);         
  virtual int4 beginStatement(const PcodeOp *op);   
  virtual void endStatement(int4 id);           
  virtual int4 beginFuncProto(void);            
  virtual void endFuncProto(int4 id);           
  virtual void tagVariable(const char *ptr,syntax_highlight hl,
                const Varnode *vn,const PcodeOp *op);
  virtual void tagOp(const char *ptr,syntax_highlight hl,const PcodeOp *op);
  virtual void tagFuncName(const char *ptr,syntax_highlight hl,const Funcdata *fd,const PcodeOp *op);
  virtual void tagType(const char *ptr,syntax_highlight hl,const Datatype *ct);
  virtual void tagField(const char *ptr,syntax_highlight hl,const Datatype *ct,int4 off);
  virtual void tagComment(const char *ptr,syntax_highlight hl,const AddrSpace *spc,uintb off);
  virtual void tagLabel(const char *ptr,syntax_highlight hl,const AddrSpace *spc,uintb off);
  virtual void print(const char *str,syntax_highlight hl=no_color);
  virtual int4 openParen(char o,int4 id=0);     
  virtual void closeParen(char c,int4 id);      
 
  virtual int4 openGroup(void) { return 0; }
 
  virtual void closeGroup(int4 id) {}
  virtual void clear(void) { parenlevel = 0; indentlevel=0; }   
  virtual void setOutputStream(ostream *t) { s = t; }       
  virtual ostream *getOutputStream(void) const { return s; }    
  virtual void spaces(int4 num,int4 bump=0);
 
  virtual int4 startIndent(void) { indentlevel+=indentincrement; return 0; }
 
  virtual void stopIndent(int4 id) { indentlevel-=indentincrement; }
 
  virtual int4 startComment(void) { return 0; }
 
  virtual void stopComment(int4 id) {}
 
  virtual void flush(void) {}
 
  virtual void setMaxLineSize(int4 mls) {}
 
  virtual int4 getMaxLineSize(void) const { return -1; }
 
  virtual void setCommentFill(const string &fill) {}
 
  virtual bool emitsXml(void) const { return true; }
 
  virtual void resetDefaults(void);
 
  int4 getParenLevel(void) const { return parenlevel; }
 
  int4 getIndentIncrement(void) const { return indentincrement; }
 
  void setIndentIncrement(int4 val) { indentincrement = val; }
};
 
class EmitNoXml : public EmitXml {
public:
  EmitNoXml(void) : EmitXml() {}    
  virtual int4 beginDocument(void) { return 0; }
  virtual void endDocument(int4 id) {}
  virtual int4 beginFunction(const Funcdata *fd) { return 0; }
  virtual void endFunction(int4 id) {}
  virtual int4 beginBlock(const FlowBlock *bl) { return 0; }
  virtual void endBlock(int4 id) {}
  virtual void tagLine(int4 indent) {
    *s << endl; for(int4 i=indent;i>0;--i) *s << ' '; }
  virtual int4 beginReturnType(const Varnode *vn) { return 0; }
  virtual void endReturnType(int4 id) {}
  virtual int4 beginVarDecl(const Symbol *sym) { return 0; }
  virtual void endVarDecl(int4 id) {}
  virtual int4 beginStatement(const PcodeOp *op) { return 0; }
  virtual void endStatement(int4 id) {}
  virtual int4 beginFuncProto(void) { return 0; }
  virtual void endFuncProto(int4 id) {}
  virtual void tagVariable(const char *ptr,syntax_highlight hl,
                const Varnode *vn,const PcodeOp *op) {
    *s << ptr; }
  virtual void tagOp(const char *ptr,syntax_highlight hl,const PcodeOp *op) {
    *s << ptr; }
  virtual void tagFuncName(const char *ptr,syntax_highlight hl,const Funcdata *fd,const PcodeOp *op) {
    *s << ptr; }
  virtual void tagType(const char *ptr,syntax_highlight hl,const Datatype *ct) {
    *s << ptr; }
  virtual void tagField(const char *ptr,syntax_highlight hl,const Datatype *ct,int4 off) {
    *s << ptr; }
  virtual void tagComment(const char *ptr,syntax_highlight hl,
               const AddrSpace *spc,uintb off) {
    *s << ptr; }
  virtual void tagLabel(const char *ptr,syntax_highlight hl,
             const AddrSpace *spc,uintb off) {
    *s << ptr; }
  virtual void print(const char *str,syntax_highlight hl=no_color) {
    *s << str; }
  virtual int4 openParen(char o,int4 id=0) {
    *s << o; parenlevel += 1; return id; }
  virtual void closeParen(char c,int4 id) {
    *s << c; parenlevel -= 1; }
  virtual bool emitsXml(void) const { return false; }
};
 
class TokenSplit {
public:
  enum printclass {
    begin,      
    end,        
    tokenstring,    
    tokenbreak,     
    begin_indent,   
    end_indent,     
    begin_comment,  
    end_comment,    
    ignore      
  };
 
  enum tag_type {
    docu_b,     
    docu_e,     
    func_b,     
    func_e,     
    bloc_b,     
    bloc_e,     
    rtyp_b,     
    rtyp_e,     
    vard_b,     
    vard_e,     
    stat_b,     
    stat_e,     
    prot_b,     
    prot_e,     
    vari_t,     
    op_t,       
    fnam_t,     
    type_t,     
    field_t,        
    comm_t,     
    label_t,        
    synt_t,     
    opar_t,     
    cpar_t,     
    oinv_t,     
    cinv_t,     
    spac_t,     
    bump_t,     
    line_t      
  };
private:
  tag_type tagtype;     
  printclass delimtype;     
  string tok;           
  EmitXml::syntax_highlight hl; 
  // Additional markup elements for token
  const PcodeOp *op;        
  union {
    const Varnode *vn;      
    const FlowBlock *bl;    
    const Funcdata *fd;     
    const Datatype *ct;     
    const AddrSpace *spc;   
    const Symbol *symbol;   
  } ptr_second;         
  uintb off;            
  int4 indentbump;      
  int4 numspaces;       
  int4 size;            
  int4 count;           
  static int4 countbase;    
public:
  TokenSplit(void) { }      
 
  int4 beginDocument(void) {
    tagtype=docu_b; delimtype=begin; size=0; count=countbase++; return count; }
 
  void endDocument(int4 id) {
    tagtype=docu_e; delimtype=end; size=0; count=id; }
 
  int4 beginFunction(const Funcdata *f) {
    tagtype=func_b; delimtype=begin; size=0; ptr_second.fd=f; count=countbase++; return count; }
 
  void endFunction(int4 id) {
    tagtype=func_e; delimtype=end; size=0; count=id; }
 
  int4 beginBlock(const FlowBlock *b) {
    tagtype=bloc_b; delimtype=ignore; ptr_second.bl=b; count=countbase++; return count; }
 
  void endBlock(int4 id) {
    tagtype=bloc_e; delimtype=ignore; count=id; }
 
  int4 beginReturnType(const Varnode *v) { 
    tagtype=rtyp_b; delimtype=begin; ptr_second.vn=v; count=countbase++; return count; }
 
  void endReturnType(int4 id) {
    tagtype=rtyp_e; delimtype=end; count=id; }
 
  int4 beginVarDecl(const Symbol *sym) {
    tagtype=vard_b; delimtype=begin; ptr_second.symbol=sym; count = countbase++; return count; }
 
  void endVarDecl(int4 id) {
    tagtype=vard_e; delimtype=end; count=id; }
 
  int4 beginStatement(const PcodeOp *o) {
    tagtype=stat_b; delimtype=begin; op=o; count=countbase++; return count; }
 
  void endStatement(int4 id) {
    tagtype=stat_e; delimtype=end; count=id; }
 
  int4 beginFuncProto(void) {
    tagtype=prot_b; delimtype=begin; count=countbase++; return count; }
 
  void endFuncProto(int4 id) {
    tagtype=prot_e; delimtype=end; count=id; }
 
  void tagVariable(const char *ptr,EmitXml::syntax_highlight h,
            const Varnode *v,const PcodeOp *o) {
    tok = ptr; size = tok.size();
    tagtype=vari_t; delimtype=tokenstring; hl=h; ptr_second.vn=v; op=o; }
 
  void tagOp(const char *ptr,EmitXml::syntax_highlight h,const PcodeOp *o) {
    tok = ptr; size = tok.size();
    tagtype=op_t; delimtype=tokenstring; hl=h; op=o; }
 
  void tagFuncName(const char *ptr,EmitXml::syntax_highlight h,const Funcdata *f,const PcodeOp *o) {
    tok = ptr; size = tok.size();
    tagtype=fnam_t; delimtype=tokenstring; hl=h; ptr_second.fd=f; op=o; }
 
  void tagType(const char *ptr,EmitXml::syntax_highlight h,const Datatype *ct) {
    tok = ptr; size = tok.size();
    tagtype=type_t; delimtype=tokenstring; hl=h; ptr_second.ct=ct; }
 
  void tagField(const char *ptr,EmitXml::syntax_highlight h,const Datatype *ct,int4 o) {
    tok = ptr; size = tok.size();
    tagtype=field_t; delimtype=tokenstring; hl=h; ptr_second.ct=ct; off=(uintb)o; }
 
  void tagComment(const char *ptr,EmitXml::syntax_highlight h,
           const AddrSpace *s,uintb o) {
    tok = ptr; size = tok.size(); ptr_second.spc=s; off=o;
    tagtype=comm_t; delimtype=tokenstring; hl=h; }
 
  void tagLabel(const char *ptr,EmitXml::syntax_highlight h,
         const AddrSpace *s,uintb o) {
    tok = ptr; size = tok.size(); ptr_second.spc=s; off=o;
    tagtype=label_t; delimtype=tokenstring; hl=h; }
 
  void print(const char *str,EmitXml::syntax_highlight h) {
    tok = str; size=tok.size();
    tagtype=synt_t; delimtype=tokenstring; hl=h; }
 
  void openParen(char o,int4 id) {
    tok = o; size = 1;
    tagtype=opar_t; delimtype=tokenstring; count=id; }
 
  void closeParen(char c,int4 id) {
    tok = c; size = 1;
    tagtype=cpar_t; delimtype=tokenstring; count=id; }
 
  int4 openGroup(void) {
    tagtype=oinv_t; delimtype=begin; count=countbase++; return count; }
 
  void closeGroup(int4 id) {
    tagtype=cinv_t; delimtype=end; count=id; }
 
  int4 startIndent(int4 bump) {
    tagtype=bump_t; delimtype=begin_indent; indentbump=bump; size=0;
    count=countbase++; return count; }
 
  void stopIndent(int4 id) {
    tagtype=bump_t; delimtype=end_indent; size=0; count=id; }
 
  int4 startComment(void) {
    tagtype=oinv_t; delimtype=begin_comment; count=countbase++; return count; }
 
  void stopComment(int4 id) {
    tagtype=cinv_t; delimtype=end_comment; count=id; }
 
  void spaces(int4 num,int4 bump) {
    tagtype=spac_t; delimtype=tokenbreak; numspaces=num; indentbump=bump; }
 
  void tagLine(void) {
    tagtype=bump_t; delimtype=tokenbreak; numspaces=999999; indentbump=0; }
 
  void tagLine(int4 indent) {
    tagtype=line_t; delimtype=tokenbreak; numspaces=999999; indentbump=indent; }
 
  void print(EmitXml *emit) const;          
  int4 getIndentBump(void) const { return indentbump; } 
  int4 getNumSpaces(void) const { return numspaces; }   
  int4 getSize(void) const { return size; }     
  void setSize(int4 sz) { size = sz; }          
  printclass getClass(void) const { return delimtype; } 
  tag_type getTag(void) const { return tagtype; }   
#ifdef PRETTY_DEBUG
  int4 getCount(void) const { return count; }       
  void printDebug(ostream &s) const;            
#endif
};
 
template<typename _type>
class circularqueue {
  _type *cache;     
  int4 left;        
  int4 right;       
  int4 max;     
public:
  circularqueue(int4 sz);       
  ~circularqueue(void);         
  void setMax(int4 sz);         
  int4 getMax(void) const { return max; }   
  void expand(int4 amount);     
  void clear(void) { left=1; right=0; } 
  bool empty(void) const { return (left == (right+1)%max); }    
  int4 topref(void) const { return right; } 
  int4 bottomref(void) const { return left; }   
  _type &ref(int4 r) { return cache[r]; }   
  _type &top(void) { return cache[right]; } 
  _type &bottom(void) { return cache[left]; }   
  _type &push(void) { right=(right+1)%max; return cache[right]; }   
  _type &pop(void) { int4 tmp=right; right=(right+max-1)%max; return cache[tmp]; }  
  _type &popbottom(void) { int4 tmp=left; left=(left+1)%max; return cache[tmp]; }   
};
 
template<typename _type>
circularqueue<_type>::circularqueue(int4 sz)
 
{
  max = sz;
  left = 1;         // Set queue to be empty
  right = 0;
  cache = new _type [ sz ];
}
 
template<typename _type>
circularqueue<_type>::~circularqueue(void)
 
{
  delete [] cache;
}
 
template<typename _type>
void circularqueue<_type>::setMax(int4 sz)
 
{
  if (max != sz) {
    delete [] cache;
    max = sz;
    cache = new _type [ sz ];
  }
  left = 1;         // This operation empties queue
  right = 0;
}
 
template<typename _type>
void circularqueue<_type>::expand(int4 amount)
 
{
  _type *newcache = new _type [ max + amount ];
  
  int4 i=left;
  int4 j=0;
 
  // Assume there is at least one element in queue
  while(i != right) {
    newcache[j++] = cache[i];
    i = (i+1)%max;
  }
  newcache[j] = cache[i];   // Copy rightmost
  left=0;
  right = j;
  
  delete [] cache;
  cache = newcache;
  max += amount; 
}
 
class EmitPrettyPrint : public EmitXml {
#ifdef PRETTY_DEBUG
  vector<int4> checkid;
#endif
  EmitXml *lowlevel;        
  vector<int4> indentstack; 
  int4 spaceremain;     
  int4 maxlinesize;     
  int4 leftotal;        
  int4 rightotal;       
  bool needbreak;           
  bool commentmode;     
  string commentfill;       
  circularqueue<int4> scanqueue; 
  circularqueue<TokenSplit> tokqueue;   
  void expand(void);        
  void checkstart(void);    
  void checkend(void);      
  void checkstring(void);   
  void checkbreak(void);    
  void overflow(void);      
  void print(const TokenSplit &tok);    
  void advanceleft(void);   
  void scan(void);      
  void resetDefaultsPrettyPrint(void) { setMaxLineSize(100); } 
public:
  EmitPrettyPrint(void);    
  virtual ~EmitPrettyPrint(void);
  virtual int4 beginDocument(void);
  virtual void endDocument(int4 id);
  virtual int4 beginFunction(const Funcdata *fd);
  virtual void endFunction(int4 id);
  virtual int4 beginBlock(const FlowBlock *bl);
  virtual void endBlock(int4 id);
  virtual void tagLine(void);
  virtual void tagLine(int4 indent);
  virtual int4 beginReturnType(const Varnode *vn);
  virtual void endReturnType(int4 id);
  virtual int4 beginVarDecl(const Symbol *sym);
  virtual void endVarDecl(int4 id);
  virtual int4 beginStatement(const PcodeOp *op);
  virtual void endStatement(int4 id);
  virtual int4 beginFuncProto(void);
  virtual void endFuncProto(int4 id);
  virtual void tagVariable(const char *ptr,syntax_highlight hl,
               const Varnode *vn,const PcodeOp *op);
  virtual void tagOp(const char *ptr,syntax_highlight hl,const PcodeOp *op);
  virtual void tagFuncName(const char *ptr,syntax_highlight hl,const Funcdata *fd,const PcodeOp *op);
  virtual void tagType(const char *ptr,syntax_highlight hl,const Datatype *ct);
  virtual void tagField(const char *ptr,syntax_highlight hl,const Datatype *ct,int4 off);
  virtual void tagComment(const char *ptr,syntax_highlight hl,
              const AddrSpace *spc,uintb off);
  virtual void tagLabel(const char *ptr,syntax_highlight hl,
            const AddrSpace *spc,uintb off);
  virtual void print(const char *str,syntax_highlight hl=no_color);
  virtual int4 openParen(char o,int4 id=0);
  virtual void closeParen(char c,int4 id);
  virtual int4 openGroup(void);
  virtual void closeGroup(int4 id);
  virtual void clear(void);
  virtual void setOutputStream(ostream *t) { lowlevel->setOutputStream(t); }
  virtual ostream *getOutputStream(void) const { return lowlevel->getOutputStream(); }
  virtual void spaces(int4 num,int4 bump=0);
  virtual int4 startIndent(void);
  virtual void stopIndent(int4 id);
  virtual int4 startComment(void);
  virtual void stopComment(int4 id);
  virtual void flush(void);
  virtual void setMaxLineSize(int4 val);
  virtual int4 getMaxLineSize(void) const { return maxlinesize; }
  virtual void setCommentFill(const string &fill) { commentfill = fill; }
  virtual bool emitsXml(void) const { return lowlevel->emitsXml(); }
  virtual void resetDefaults(void);
  void setXML(bool val);    
};
 
#endif