libpcp/pcp_emitter.h

   1 // Copyright (C) 2009 Free Software Foundation, Inc.
   2 // Contributed by Jan Sjodin <jan.sjodin@amd.com>.
   3
   4 // This file is part of the Polyhedral Compilation Package Library (libpcp).
   5
   6 // Libpcp is free software; you can redistribute it and/or modify it
   7 // under the terms of the GNU Lesser General Public License as published by
   8 // the Free Software Foundation; either version 2.1 of the License, or
   9 // (at your option) any later version.
  10
  11 // Libpcp is distributed in the hope that it will be useful, but WITHOUT ANY
  12 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13 // FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
  14 // more details.
  15
  16 // You should have received a copy of the GNU Lesser General Public License
  17 // along with libpcp; see the file COPYING.LIB.  If not, write to the
  18 // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19 // MA 02110-1301, USA.
  20
  21 // As a special exception, if you link this library with other files, some
  22 // of which are compiled with GCC, to produce an executable, this library
  23 // does not by itself cause the resulting executable to be covered by the
  24 // GNU General Public License.  This exception does not however invalidate
  25 // any other reasons why the executable file might be covered by the GNU
  26 // General Public License.
  27
  28 #ifndef _PCP_EMITTER_H_
  29 #define _PCP_EMITTER_H_
  30
  31 #include "pcp.h"
  32 #include "pcp_set.h"
  33
  34 // PCP Emit Buffer
  35
  36 class PcpEmitter
  37 {
  38  protected:
  39   PcpStringBuffer* stringBuffer;
  40   int indent;
  41   int column;
  42   PcpSet<const char*>* tagFilterSet;
  43
  44   virtual void setStringBuffer(PcpStringBuffer* stringBuffer);
  45   virtual PcpStringBuffer* getStringBuffer();
  46
  47   virtual bool tagIsFiltered(const char* tag);
  48   virtual void setTagFilterSet(PcpSet<const char*>* tagFilterSet);
  49   virtual PcpSet<const char*>* getTagFilterSet();
  50   virtual void setIndent(int indent);
  51   virtual int getIndent();
  52   virtual void increment();
  53   virtual void decrement();
  54   virtual void writeIndent();
  55   virtual void writeNewline();
  56   virtual void writeString(const char* string);
  57   virtual void writeInt(int value);
  58   virtual void writeStringIndent(const char* string);
  59
  60   virtual const char* stringBufferToString();
  61
  62  public:
  63   virtual void addFilteredTag(const char* tag);
  64
  65   virtual void emitObjectAnnots(PcpObject* object);
  66   virtual void emitArrayTypeDef(PcpArrayType* type);
  67   virtual void emitArrayTypeUse(PcpArrayType* type);
  68   virtual const char* emitGetBoolOperatorString(PcpBoolArithOperator oper);
  69   virtual void emitObjectNameBinding(PcpObject* object);
  70   virtual void emitBoolArith(PcpBoolArith* boolArith);
  71   virtual void emitCompareOperator(PcpCompareOperator oper);
  72   virtual void emitObjectNameBindingIndent(PcpObject* object);
  73   virtual void emitConstantDecl(PcpConstant* constant);
  74   virtual void emitIvDecl(PcpIv* iv);
  75   virtual void emitVariableDecl(PcpVariable* var);
  76   virtual void emitVariableUse(PcpVariable* var);
  77   virtual void emitParameterDecl(PcpParameter* parameter);
  78   virtual const char* emitGetOperatorString(PcpArithOperator oper);
  79   virtual void emitCopy(PcpCopy* copy);
  80   virtual void emitUserStmt(PcpUserStmt* userStmt);
  81   virtual void emitScopInputs(PcpScop* scop);
  82   virtual void emitScopOutputs(PcpScop* scop);
  83   virtual void emitScopParameters(PcpScop* scop);
  84   virtual void emitScopParametersDecl(PcpScop* scop);
  85   virtual void emitScopVariables(PcpScop* scop);
  86   virtual void emitTypeDefs(PcpScop* scop);
  87   virtual void emitAnnot(PcpAnnot* annot);
  88   virtual void emitAnnotInt(PcpAnnotInt* annotInt);
  89   virtual void emitAnnotString(PcpAnnotString* annotString);
  90   virtual void emitAnnotObject(PcpAnnotObject* annotObject);
  91   virtual void emitAnnotTerm(PcpAnnotTerm* annotTerm);
  92   virtual void emitConstantUse(PcpConstant* constant);
  93   virtual void emitIvUse(PcpIv* iv);
  94   virtual void emitParameterUse(PcpParameter* parameter);
  95   virtual void emitExpr(PcpExpr* expr);
  96   virtual void emitArith(PcpArith* arith);
  97   virtual void emitBoolExpr(PcpBoolExpr* boolExpr);
  98   virtual void emitCompare(PcpCompare* compare);
  99   virtual void emitArrayAccess(PcpArrayAccess* access);
 100   virtual void emitStmt(PcpStmt* stmt);
 101   virtual void emitSequence(PcpSequence* sequence);
 102   virtual void emitGuard(PcpGuard* guard);
 103   virtual void emitLoop(PcpLoop* loop);
 104   virtual void emitScop(PcpScop* scop);
 105
 106   virtual const char* bufferToString();
 107
 108   static const char* pcpAnnotToString(PcpAnnot* annot);
 109   static const char* pcpAnnotIntToString(PcpAnnotInt* annotInt);
 110   static const char* pcpAnnotStringToString(PcpAnnotString* annotString);
 111   static const char* pcpAnnotObjectToString(PcpAnnotObject* annotObject);
 112   static const char* pcpAnnotTermToString(PcpAnnotTerm* annotTerm);
 113   static const char* pcpArrayTypeToString(PcpArrayType* type);
 114   static const char* pcpExprToString(PcpExpr* expr);
 115   static const char* pcpArithToString(PcpArith* arith);
 116   static const char* pcpBoolExprToString(PcpBoolExpr* boolExpr);
 117   static const char* pcpCompareToString(PcpCompare* compare);
 118   static const char* pcpBoolArithToString(PcpBoolArith* boolArith);
 119   static const char* pcpArrayAccessToString(PcpArrayAccess* access);
 120   static const char* pcpIvToUseString(PcpIv* iv);
 121   static const char* pcpIvToDeclString(PcpIv* iv);
 122   static const char* pcpParameterToUseString(PcpParameter* parameter);
 123   static const char* pcpParameterToDeclString(PcpParameter* parameter);
 124   static const char* pcpConstantToUseString(PcpConstant* constant);
 125   static const char* pcpConstantToDeclString(PcpConstant* constant);
 126   static const char* pcpVariableToUseString(PcpVariable* var);
 127   static const char* pcpVariableToDeclString(PcpVariable* var);
 128   static const char* pcpStmtToString(PcpStmt* stmt);
 129   static const char* pcpCopyToString(PcpCopy* copy);
 130   static const char* pcpUserStmtToString(PcpUserStmt* userStmt);
 131   static const char* pcpSequenceToString(PcpSequence* sequence);
 132   static const char* pcpGuardToString(PcpGuard* guard);
 133   static const char* pcpLoopToString(PcpLoop* loop);
 134   static const char* pcpScopToString(PcpScop* scop);
 135
 136   PcpEmitter();
 137 };
 138
 139
 140 #endif // _PCP_EMITTER_H_ <
 141