Ghidra-Decompiler-Analysis-Engine-Document/printlanguage_8hh_source.html

/* ###

 * 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 __PRINT_LANGUAGE__

#define __PRINT_LANGUAGE__


#include "capability.hh"

#include "cast.hh"

#include "prettyprint.hh"


class PrintLanguage;


class PrintLanguageCapability : public CapabilityPoint {

  static vector<PrintLanguageCapability *> thelist;

protected:

  string name;

  bool isdefault;

public:

  const string &getName(void) const { return name; }

  virtual void initialize(void);


  virtual PrintLanguage *buildLanguage(Architecture *glb)=0;


  static PrintLanguageCapability *getDefault(void);

  static PrintLanguageCapability *findCapability(const string &name);

};


class BlockGraph;

class BlockBasic;

class BlockList;

class BlockCopy;

class BlockGoto;

class BlockIf;

class BlockCondition;

class BlockWhileDo;

class BlockDoWhile;

class BlockInfLoop;

class BlockSwitch;

class Scope;

class Symbol;

class EquateSymbol;

class Comment;


class OpToken {

public:

  enum tokentype {

    binary,

    unary_prefix,

    postsurround,

    presurround,

    space,

    hiddenfunction

  };

  const char *print;

  int4 stage;

  int4 precedence;

  bool associative;

  tokentype type;

  int4 spacing;

  int4 bump;

  OpToken *negate;

};


class PrintLanguage {

public:

  enum modifiers {

    force_hex = 1,

    force_dec = 2,

    bestfit = 4,

    force_scinote = 8,

    force_pointer = 0x10,

    print_load_value = 0x20,

    print_store_value = 0x40,

    no_branch = 0x80,

    only_branch = 0x100,

    comma_separate = 0x200,

    flat = 0x400,

    falsebranch = 0x800,

    nofallthru = 0x1000,

    negatetoken = 0x2000,

    hide_thisparam = 0x4000

  };

  enum tagtype {

    syntax,

    vartoken,

    functoken,

    optoken,

    typetoken,

    fieldtoken,

    blanktoken

  };


  enum namespace_strategy {

    MINIMAL_NAMESPACES = 0,

    NO_NAMESPACES = 1,

    ALL_NAMESPACES = 2

  };


  struct ReversePolish {

    const OpToken *tok;

    int4 visited;

    bool paren;

    const PcodeOp *op;

    int4 id;

    mutable int4 id2;

  };


  struct NodePending {

    const Varnode *vn;

    const PcodeOp *op;

    uint4 vnmod;


    NodePending(const Varnode *v,const PcodeOp *o,uint4 m) {

      vn = v; op = o; vnmod = m; }

  };


  struct Atom {

    const string &name;

    tagtype type;

    EmitXml::syntax_highlight highlight;

    const PcodeOp *op;

    union {

      const Varnode *vn;

      const Funcdata *fd;

      const Datatype *ct;

    } ptr_second;

    int4 offset;


    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl)

      : name(nm) { type = t; highlight = hl; }


    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const Datatype *c)

      : name(nm) { type = t; highlight = hl; ptr_second.ct = c; }


    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const Datatype *c,int4 off)

      : name(nm) { type = t; highlight = hl; ptr_second.ct = c; offset = off; }


    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const PcodeOp *o)

      : name(nm) { type = t; highlight = hl; op = o; }


    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const PcodeOp *o,const Varnode *v)

      : name(nm) { type=t; highlight = hl; ptr_second.vn = v; op = o; }


    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const PcodeOp *o,const Funcdata *f)

      : name(nm) { type=t; highlight = hl; op = o; ptr_second.fd = f; }

  };

private:

  string name;

  vector<uint4> modstack;

  vector<const Scope *> scopestack;

  vector<ReversePolish> revpol;

  vector<NodePending> nodepend;

  int4 pending;

  int4 line_commentindent;

  string commentstart;

  string commentend;

protected:

  Architecture *glb;

  const Scope *curscope;

  CastStrategy *castStrategy;

  EmitXml *emit;

  uint4 mods;

  uint4 instr_comment_type;

  uint4 head_comment_type;

  namespace_strategy namespc_strategy;

#ifdef CPUI_DEBUG

  bool isStackEmpty(void) const { return (nodepend.empty()&&revpol.empty()); }

  bool isModStackEmpty(void) const { return modstack.empty(); }

#endif

  // Routines that are probably consistent across languages

  bool isSet(uint4 m) const { return ((mods & m)!=0); }

  void pushScope(const Scope *sc) { scopestack.push_back(sc); curscope = sc; }

  void popScope(void);

  void pushMod(void) { modstack.push_back(mods); }

  void popMod(void) { mods = modstack.back(); modstack.pop_back(); }

  void setMod(uint4 m) { mods |= m; }

  void unsetMod(uint4 m) { mods &= ~m; }

  void pushOp(const OpToken *tok,const PcodeOp *op);

  void pushAtom(const Atom &atom);

  void pushVnImplied(const Varnode *vn,const PcodeOp *op,uint4 m);

  void pushVnExplicit(const Varnode *vn,const PcodeOp *op);

  void pushVnLHS(const Varnode *vn,const PcodeOp *op);


  bool parentheses(const OpToken *op2);

  void emitOp(const ReversePolish &entry);

  void emitAtom(const Atom &atom);

  static bool unicodeNeedsEscape(int4 codepoint);

  bool escapeCharacterData(ostream &s,const uint1 *buf,int4 count,int4 charsize,bool bigend) const;

  void recurse(void);

  void opBinary(const OpToken *tok,const PcodeOp *op);

  void opUnary(const OpToken *tok,const PcodeOp *op);

  int4 getPending(void) const { return pending; }

  void resetDefaultsInternal(void);


  virtual void printUnicode(ostream &s,int4 onechar) const=0;


  virtual void pushType(const Datatype *ct)=0;


  virtual void pushConstant(uintb val,const Datatype *ct,

                const Varnode *vn,const PcodeOp *op)=0;


  virtual bool pushEquate(uintb val,int4 sz,const EquateSymbol *sym,const Varnode *vn,const PcodeOp *op)=0;


  virtual void pushAnnotation(const Varnode *vn,const PcodeOp *op)=0;


  virtual void pushSymbol(const Symbol *sym,const Varnode *vn,

              const PcodeOp *op)=0;


  virtual void pushUnnamedLocation(const Address &addr,

                   const Varnode *vn,const PcodeOp *op)=0;


  virtual void pushPartialSymbol(const Symbol *sym,int4 off,int4 sz,

                 const Varnode *vn,const PcodeOp *op,Datatype *outtype)=0;


  virtual void pushMismatchSymbol(const Symbol *sym,int4 off,int4 sz,

                  const Varnode *vn,const PcodeOp *op)=0;


  virtual void emitLineComment(int4 indent,const Comment *comm);


  virtual void emitVarDecl(const Symbol *sym)=0;


  virtual void emitVarDeclStatement(const Symbol *sym)=0;


  virtual bool emitScopeVarDecls(const Scope *scope,int4 cat)=0;


  virtual void emitExpression(const PcodeOp *op)=0;


  virtual void emitFunctionDeclaration(const Funcdata *fd)=0;


  virtual bool checkPrintNegation(const Varnode *vn)=0;

public:

  PrintLanguage(Architecture *g,const string &nm);

  virtual ~PrintLanguage(void);

  const string &getName(void) const { return name; }

  CastStrategy *getCastStrategy(void) const { return castStrategy; }

  ostream *getOutputStream(void) const { return emit->getOutputStream(); }

  void setOutputStream(ostream *t) { emit->setOutputStream(t); }

  void setMaxLineSize(int4 mls) { emit->setMaxLineSize(mls); }

  void setIndentIncrement(int4 inc) { emit->setIndentIncrement(inc); }

  void setLineCommentIndent(int4 val);

  void setCommentDelimeter(const string &start,const string &stop,

               bool usecommentfill);

  uint4 getInstructionComment(void) const { return instr_comment_type; }

  void setInstructionComment(uint4 val) { instr_comment_type = val; }

  void setNamespaceStrategy(namespace_strategy strat) { namespc_strategy = strat; }

  uint4 getHeaderComment(void) const { return head_comment_type; }

  void setHeaderComment(uint4 val) { head_comment_type = val; }

  bool emitsXml(void) const { return emit->emitsXml(); }

  void setXML(bool val);

  void setFlat(bool val);


  virtual void adjustTypeOperators(void)=0;

  virtual void resetDefaults(void);

  virtual void clear(void);

  virtual void setIntegerFormat(const string &nm);


  virtual void setCommentStyle(const string &nm)=0;


  virtual void docTypeDefinitions(const TypeFactory *typegrp)=0;


  virtual void docAllGlobals(void)=0;


  virtual void docSingleGlobal(const Symbol *sym)=0;


  virtual void docFunction(const Funcdata *fd)=0;


  virtual void emitBlockBasic(const BlockBasic *bb)=0;

  virtual void emitBlockGraph(const BlockGraph *bl)=0;

  virtual void emitBlockCopy(const BlockCopy *bl)=0;

  virtual void emitBlockGoto(const BlockGoto *bl)=0;

  virtual void emitBlockLs(const BlockList *bl)=0;

  virtual void emitBlockCondition(const BlockCondition *bl)=0;

  virtual void emitBlockIf(const BlockIf *bl)=0;

  virtual void emitBlockWhileDo(const BlockWhileDo *bl)=0;

  virtual void emitBlockDoWhile(const BlockDoWhile *bl)=0;

  virtual void emitBlockInfLoop(const BlockInfLoop *bl)=0;

  virtual void emitBlockSwitch(const BlockSwitch *bl)=0;


  virtual void opCopy(const PcodeOp *op)=0;

  virtual void opLoad(const PcodeOp *op)=0;

  virtual void opStore(const PcodeOp *op)=0;

  virtual void opBranch(const PcodeOp *op)=0;

  virtual void opCbranch(const PcodeOp *op)=0;

  virtual void opBranchind(const PcodeOp *op)=0;

  virtual void opCall(const PcodeOp *op)=0;

  virtual void opCallind(const PcodeOp *op)=0;

  virtual void opCallother(const PcodeOp *op)=0;

  virtual void opConstructor(const PcodeOp *op,bool withNew)=0;

  virtual void opReturn(const PcodeOp *op)=0;

  virtual void opIntEqual(const PcodeOp *op)=0;

  virtual void opIntNotEqual(const PcodeOp *op)=0;

  virtual void opIntSless(const PcodeOp *op)=0;

  virtual void opIntSlessEqual(const PcodeOp *op)=0;

  virtual void opIntLess(const PcodeOp *op)=0;

  virtual void opIntLessEqual(const PcodeOp *op)=0;

  virtual void opIntZext(const PcodeOp *op,const PcodeOp *readOp)=0;

  virtual void opIntSext(const PcodeOp *op,const PcodeOp *readOp)=0;

  virtual void opIntAdd(const PcodeOp *op)=0;

  virtual void opIntSub(const PcodeOp *op)=0;

  virtual void opIntCarry(const PcodeOp *op)=0;

  virtual void opIntScarry(const PcodeOp *op)=0;

  virtual void opIntSborrow(const PcodeOp *op)=0;

  virtual void opInt2Comp(const PcodeOp *op)=0;

  virtual void opIntNegate(const PcodeOp *op)=0;

  virtual void opIntXor(const PcodeOp *op)=0;

  virtual void opIntAnd(const PcodeOp *op)=0;

  virtual void opIntOr(const PcodeOp *op)=0;

  virtual void opIntLeft(const PcodeOp *op)=0;

  virtual void opIntRight(const PcodeOp *op)=0;

  virtual void opIntSright(const PcodeOp *op)=0;

  virtual void opIntMult(const PcodeOp *op)=0;

  virtual void opIntDiv(const PcodeOp *op)=0;

  virtual void opIntSdiv(const PcodeOp *op)=0;

  virtual void opIntRem(const PcodeOp *op)=0;

  virtual void opIntSrem(const PcodeOp *op)=0;

  virtual void opBoolNegate(const PcodeOp *op)=0;

  virtual void opBoolXor(const PcodeOp *op)=0;

  virtual void opBoolAnd(const PcodeOp *op)=0;

  virtual void opBoolOr(const PcodeOp *op)=0;

  virtual void opFloatEqual(const PcodeOp *op)=0;

  virtual void opFloatNotEqual(const PcodeOp *op)=0;

  virtual void opFloatLess(const PcodeOp *op)=0;

  virtual void opFloatLessEqual(const PcodeOp *op)=0;

  virtual void opFloatNan(const PcodeOp *op)=0;

  virtual void opFloatAdd(const PcodeOp *op)=0;

  virtual void opFloatDiv(const PcodeOp *op)=0;

  virtual void opFloatMult(const PcodeOp *op)=0;

  virtual void opFloatSub(const PcodeOp *op)=0;

  virtual void opFloatNeg(const PcodeOp *op)=0;

  virtual void opFloatAbs(const PcodeOp *op)=0;

  virtual void opFloatSqrt(const PcodeOp *op)=0;

  virtual void opFloatInt2Float(const PcodeOp *op)=0;

  virtual void opFloatFloat2Float(const PcodeOp *op)=0;

  virtual void opFloatTrunc(const PcodeOp *op)=0;

  virtual void opFloatCeil(const PcodeOp *op)=0;

  virtual void opFloatFloor(const PcodeOp *op)=0;

  virtual void opFloatRound(const PcodeOp *op)=0;

  virtual void opMultiequal(const PcodeOp *op)=0;

  virtual void opIndirect(const PcodeOp *op)=0;

  virtual void opPiece(const PcodeOp *op)=0;

  virtual void opSubpiece(const PcodeOp *op)=0;

  virtual void opCast(const PcodeOp *op)=0;

  virtual void opPtradd(const PcodeOp *op)=0;

  virtual void opPtrsub(const PcodeOp *op)=0;

  virtual void opSegmentOp(const PcodeOp *op)=0;

  virtual void opCpoolRefOp(const PcodeOp *op)=0;

  virtual void opNewOp(const PcodeOp *op)=0;

  virtual void opInsertOp(const PcodeOp *op)=0;

  virtual void opExtractOp(const PcodeOp *op)=0;

  virtual void opPopcountOp(const PcodeOp *op)=0;


  static int4 mostNaturalBase(uintb val);

  static void formatBinary(ostream &s,uintb val);

};


#endif