/*****************************************************************************
 Copyright (C) 1994-2000 the Omega Project Team
 Copyright (C) 2005-2011 Chun Chen
 All Rights Reserved.

 Purpose:
   abstract base class of comiler IR code builder

 Notes:
   All "CG_outputRepr *" parameters are consumed inside the the function
 unless explicitly stated otherwise, i.e., not valid after the call.
   Parameter "indent" normally not used except it is used in unstructured
 string output for correct indentation.
 
 History:
   04/17/96 created - Lei Zhou
   05/02/08 clarify integer floor/mod/ceil definitions, -chen
   05/31/08 use virtual clone to implement CreateCopy, -chun
   08/05/10 clarify NULL parameter allowance, -chun
*****************************************************************************/

#ifndef _CG_OUTPUTBUILDER_H
#define _CG_OUTPUTBUILDER_H

#include <code_gen/CG_outputRepr.h>

#include <string>
#include <vector>

namespace omega {

//! abstract base class of comiler IR code builder
class CG_outputBuilder {
public:
  CG_outputBuilder() {}
  virtual ~CG_outputBuilder() {}

  //! substitute variables in stmt
  virtual CG_outputRepr *CreateSubstitutedStmt(int indent, CG_outputRepr *stmt,
                                               const std::vector<std::string> &vars,
                                               std::vector<CG_outputRepr *> &subs) const = 0;

  //! assignment stmt generation
  virtual CG_outputRepr *CreateAssignment(int indent, CG_outputRepr *lhs,
                                          CG_outputRepr *rhs) const = 0;

  //! function invocation generation
  virtual CG_outputRepr *CreateInvoke(const std::string &funcName,
                                      std::vector<CG_outputRepr *> &argList) const = 0;

  //! comment generation
  virtual CG_outputRepr *CreateComment(int indent,
                                       const std::string &commentText) const = 0;

  //! Attribute generation
  virtual CG_outputRepr* CreateAttribute(CG_outputRepr  *control,
                                           const std::string &commentText) const = 0;
  //! Pragma Attribute
  virtual CG_outputRepr* CreatePragmaAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &pragmaText) const = 0;
  
  //! Prefetch Attribute
  virtual CG_outputRepr* CreatePrefetchAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &arrName, int hint) const = 0;

  //! generate if stmt, true/false stmt can be NULL but not the condition
  virtual CG_outputRepr *CreateIf(int indent, CG_outputRepr *guardCondition,
                                  CG_outputRepr *true_stmtList,
                                  CG_outputRepr *false_stmtList) const = 0;

  //! generate loop inductive variable (loop control structure)
  virtual CG_outputRepr *CreateInductive(CG_outputRepr *index,
                                         CG_outputRepr *lower,
                                         CG_outputRepr *upper,
                                         CG_outputRepr *step) const = 0;

  //! generate loop stmt from loop control and loop body, NULL parameter allowed
  virtual CG_outputRepr *CreateLoop(int indent, CG_outputRepr *control,
                                    CG_outputRepr *stmtList) const = 0;

  //! copy operation, NULL parameter allowed.
  /*!
   * this function makes pointer handling uniform regardless NULL status
   */
  virtual CG_outputRepr *CreateCopy(CG_outputRepr *original) const {
    if (original == NULL)
      return NULL;
    else
      return original->clone();
  }

  //! basic integer number creation
  virtual CG_outputRepr *CreateInt(int num) const = 0;
  virtual bool isInteger(CG_outputRepr *op) const = 0;


  //! basic identity/variable creation
  virtual CG_outputRepr *CreateIdent(const std::string &varName) const = 0;

  //! Addition operations, NULL parameter means 0,
  virtual CG_outputRepr *CreatePlus(CG_outputRepr *lop, CG_outputRepr *rop) const = 0;
  //! Subtraction operations, NULL parameter means 0,
  virtual CG_outputRepr *CreateMinus(CG_outputRepr *lop, CG_outputRepr *rop) const = 0;
  //! Multiplication operations, NULL parameter means 0,
  virtual CG_outputRepr *CreateTimes(CG_outputRepr *lop, CG_outputRepr *rop) const = 0;
  //! Division operations, NULL parameter means 0,
  /*!
   * integer division truncation method undefined, only use when lop is known
   * to be multiple of rop, otherwise use integer floor instead
   */
  virtual CG_outputRepr *CreateDivide(CG_outputRepr *lop, CG_outputRepr *rop) const {
    return CreateIntegerFloor(lop, rop);
  }
  
  //! integer floor functions, NULL parameter means 0
  /*! 
   * second parameter must be postive (i.e. b > 0 below), otherwise function undefined
   * 
   * floor(a, b)
   * * = a/b if a >= 0
   * * = (a-b+1)/b if a < 0
   */
  virtual CG_outputRepr *CreateIntegerFloor(CG_outputRepr *lop, CG_outputRepr *rop) const = 0;
  //! integer mod functions, NULL parameter means 0
  /*! 
   * second parameter must be postive (i.e. b > 0 below), otherwise function undefined
   *
   * mod(a, b) = a-b*floor(a, b) where result must lie in range [0,b)
   */
  virtual CG_outputRepr *CreateIntegerMod(CG_outputRepr *lop, CG_outputRepr *rop) const {
    CG_outputRepr *lop2 = CreateCopy(lop);
    CG_outputRepr *rop2 = CreateCopy(rop);
    return CreateMinus(lop2, CreateTimes(rop2, CreateIntegerFloor(lop, rop)));
  }
  //! integer ceil functions, NULL parameter means 0
  /*! 
   * second parameter must be postive (i.e. b > 0 below), otherwise function undefined
   *
   * ceil(a, b) = -floor(-a, b) or floor(a+b-1, b) or floor(a-1, b)+1
   */
  virtual CG_outputRepr *CreateIntegerCeil(CG_outputRepr *lop, CG_outputRepr *rop) const {
    return CreateMinus(NULL, CreateIntegerFloor(CreateMinus(NULL, lop), rop));
  }

  //! binary logical operation, NULL parameter means TRUE
  virtual CG_outputRepr *CreateAnd(CG_outputRepr *lop, CG_outputRepr *rop) const = 0;

  //! binary conditional Greater than or equal to
  virtual CG_outputRepr *CreateGE(CG_outputRepr *lop, CG_outputRepr *rop) const {
    return CreateLE(rop, lop);
  } 
  //! binary conditional Less than or equal to
  virtual CG_outputRepr *CreateLE(CG_outputRepr *lop, CG_outputRepr *rop) const = 0;
  //! binary conditional equal to
  virtual CG_outputRepr *CreateEQ(CG_outputRepr *lop, CG_outputRepr *rop) const = 0;
 
  //! join stmts together, NULL parameter allowed
  virtual CG_outputRepr *StmtListAppend(CG_outputRepr *list1, CG_outputRepr *list2) const = 0;
};

}

#endif