#ifndef p_tree_h_
#define p_tree_h_

/*
 *  p_tree.h
 */

class LexTokCls;
class SymtabCls;

typedef class LstSeqBldrCls *PLstSeqBldrCls;
class LstSeqBldrCls {
public:
   LstSeqBldrCls();
   virtual PLstSeqBldrCls   append(PLstSeqBldrCls);
   virtual PLstSeqBldrCls   get_next() 
      {return next;}
private:
   PLstSeqBldrCls       next;
};
/* end-LstSeqBldrCls */

typedef class PTreeNodeCls *PPTreeNodeCls;
class PTreeNodeCls {
public:
   PTreeNodeCls();
   virtual int      emit();
   virtual void     print();
   virtual LexTokCls    *get_lex_tok()  
      {return lt;}
protected:
   LexTokCls        *lt;
};
/* end-PTreeNodeCls */

typedef class PTreeCls *PPTreeCls;
class PTreeCls {
public:
   PTreeCls(PPTreeNodeCls Root);
   int      emit(); 
   void     print();
private:
   PPTreeNodeCls    root;
   PPTreeNodeCls    current;
};
/* end-PTreeCls */

typedef class DataTypeCls *PDataTypeCls;
class DataTypeCls: public PTreeNodeCls {
public:
   virtual int getSize()=0;
   virtual PDataTypeCls copy()=0;
};

typedef class DataItemCls *PDataItemCls;
class DataItemCls: public PTreeNodeCls, public LstSeqBldrCls {
public:
   DataItemCls(PPTreeNodeCls item, PPTreeNodeCls sub=NULL);
   int emit();

#ifdef MULT_ARR
   virtual PDataTypeCls typeEmit();
#endif

private:
   PPTreeNodeCls item;
   PPTreeNodeCls sub;
};

typedef class StatementCls *PStatementCls;
class StatementCls : public PTreeNodeCls, public LstSeqBldrCls {
public:
     StatementCls():stmt_text(NULL) {}
   
   StatementCls(char *StmtText);
   int      emit();
protected:
   char     *stmt_text;
};
/* end-StatementCls */

typedef class StatementSeqCls *PStatementSeqCls;
class StatementSeqCls : public PTreeNodeCls {
public:
   StatementSeqCls(PPTreeNodeCls Stmt);
   int      emit();
   PPTreeNodeCls    append(PPTreeNodeCls Stmt);
private:
   StatementCls     *seq_head;
   StatementCls     *seq_tail;
};
/* end-StatementSeqCls */

typedef class EmptyStmtCls *PEmptyStmtCls;
class EmptyStmtCls : public StatementCls {
public:
   EmptyStmtCls() {}
   int      emit();
};
/* end-EmptyStmtCls */

typedef class WriteStmtCls *PWriteStmtCls;
class WriteStmtCls : public StatementCls {
public:
   WriteStmtCls(PPTreeNodeCls Expr, char* StmtText);

   /*
     SLICK Emitter.

     Emits the expression and the {\em write} opcode.

     return 0
   */
   int      emit();

private:
   PPTreeNodeCls    expr;
};
/* end-WriteStmtCls */

typedef class AssignmentStmtCls *PAssignmentStmtCls;
class AssignmentStmtCls : public StatementCls {
public:
     AssignmentStmtCls(PPTreeNodeCls assignSeq, PPTreeNodeCls Expr, 
             char* StmtText);
   
   int      emit();
private:
     PPTreeNodeCls   assign_seq;     //lhs
   
   PPTreeNodeCls    expr;       //rhs
};
/* end-AssignmentStmtCls */

typedef class AssignmentSeqCls *PAssignmentSeqCls;
class AssignmentSeqCls: public PTreeNodeCls {
public:
   AssignmentSeqCls(PPTreeNodeCls item);
   int emit();
   PPTreeNodeCls append(PPTreeNodeCls item);
   int getLength();

private:
   DataItemCls *seq_head;
   DataItemCls *seq_tail;
   int length;
};

typedef class LoopStmtCls *PLoopStmtCls;
class LoopStmtCls: public StatementCls {
public:
   LoopStmtCls(PPTreeNodeCls stmts);
   int emit();

private:
   PPTreeNodeCls statements;
};

typedef class ExitStmtCls *PExitStmtCls;
class ExitStmtCls: public StatementCls {
public:
   /*
     SLICK Emitter.

     Emit {\em exit} opcode.

     @return 0
   */
   int emit();
};


typedef class IfStmtCls *PIfStmtCls;
class IfStmtCls: public StatementCls {
public:
   IfStmtCls(PPTreeNodeCls condition, PPTreeNodeCls statements, PPTreeNodeCls elseStmts);
   int emit();

private:
   /*
     Condition.
   */
   PPTreeNodeCls condition;

   /*
     True condition statements.
   */
   PPTreeNodeCls statements;

   /*
     False condition statements.
   */
   PPTreeNodeCls elseStmts;
};

typedef class ElseStmtCls *PElseStmtCls;
class ElseStmtCls: public StatementCls {
public:
   ElseStmtCls(): statements(NULL) {}
   ElseStmtCls(PPTreeNodeCls statements);
   int emit();

private:
   PPTreeNodeCls statements;
};

typedef class RelOpCls *PRelOpCls;
class RelOpCls: public PTreeNodeCls {
public:
   enum RelOp {
      ltOp,
      leOp,
      eqOp,
      neOp,
      geOp,
      gtOp
   };
   RelOpCls(RelOp op);
   int emit();
  
private:
   /*
     The relational operator.
   */
   RelOp op;
};

typedef class ConditionCls *PConditionCls;
class ConditionCls: public PTreeNodeCls {
public:
   ConditionCls(PPTreeNodeCls expr1, PPTreeNodeCls relOp, PPTreeNodeCls expr2);
   int emit();

private:
   PPTreeNodeCls expr1;
   PPTreeNodeCls relOp;
   PPTreeNodeCls expr2;
};

typedef class ExprCls  *PExprCls;
class ExprCls : public PTreeNodeCls {
public:
   ExprCls();
   virtual int      emit();
protected:
   int value;
};
/* end-ExprCls */

typedef class FactorCls *PFactorCls;
class FactorCls : public ExprCls {
public:
   FactorCls();
};
/* end-FactorCls */

typedef class NumFactorCls *PNumFactorCls;
class NumFactorCls : public FactorCls {
public:
   NumFactorCls(PPTreeNodeCls NumLit);
   int      emit();
};
/* end-NumFactorCls */

typedef class VarAccessFactorCls *PVarAccessFactorCls;
class VarAccessFactorCls : public FactorCls {
public:
     VarAccessFactorCls(PPTreeNodeCls Item);
   
   int      emit();
private:
     PPTreeNodeCls item;
   
};
/* end-VarAccessFactorCls */

typedef class ArithmCls *PArithmCls;
class ArithmCls: public PTreeNodeCls {
public:
   enum ArithmOp {
      PlusOp,
      MinusOp,
      MultOp,
      DivOp
   };
   ArithmCls(PPTreeNodeCls left, PPTreeNodeCls right, ArithmOp op);
   int emit();

private:
   PPTreeNodeCls left;
   PPTreeNodeCls right;
   ArithmOp op;
};

typedef class NumLiteralCls  *PNumLiteralCls;
class NumLiteralCls : public PTreeNodeCls {
public:
   NumLiteralCls();
   int          get_value()
      {return value;}

private:
   int          value;
};
/* end-NumLiteralCls */

typedef class IdentCls  *PIdentCls;
class IdentCls : public PTreeNodeCls, public LstSeqBldrCls {
public:
   IdentCls();
   char                *get_name();
};
/* end-IdentCls */

typedef class IdentSeqCls *PIdentSeqCls;
class IdentSeqCls: public PTreeNodeCls {
public:
   IdentSeqCls(PPTreeNodeCls ident);
   int emit();
   PPTreeNodeCls append(PPTreeNodeCls ident);
   PIdentCls get_first();

private:
   IdentCls *seq_head;
   IdentCls *seq_tail;
};

typedef class BasicTypeCls *PBasicTypeCls;
class BasicTypeCls: public DataTypeCls {
};

typedef class CompTypeCls *PCompTypeCls;
class CompTypeCls: public DataTypeCls {
};

typedef class IntTypeCls *PIntTypeCls;
class IntTypeCls: public BasicTypeCls {
public:
   int getSize() {return 1;}
   PIntTypeCls copy();
};

typedef class ArrayTypeCls *PArrayTypeCls;
class ArrayTypeCls: public CompTypeCls {
public:
   ArrayTypeCls(PPTreeNodeCls rangeFrom, PPTreeNodeCls rangeTo,
        PPTreeNodeCls dataType);
   int getSize();
   int getItemSize();
   PNumLiteralCls getRangeFrom();

   PNumLiteralCls getRangeTo();
   PDataTypeCls getItemDataType();
   PArrayTypeCls copy();

private:
   PNumLiteralCls range_from;
   PNumLiteralCls range_to;
   PDataTypeCls data_type;
};

typedef class DeclarationCls *PDeclarationCls;
class DeclarationCls : public PTreeNodeCls, public LstSeqBldrCls {
public:
   DeclarationCls():decl_text(NULL) {}
   DeclarationCls(PPTreeNodeCls identSeq, PPTreeNodeCls dataType, char
          *declText);
   int emit();

protected:
   PIdentSeqCls ident_seq;
   PDataTypeCls data_type;
   char *decl_text;
};

typedef class DeclarationSeqCls *PDeclarationSeqCls;
class DeclarationSeqCls: public PTreeNodeCls {
public:
   DeclarationSeqCls():seq_head(NULL), seq_tail(NULL) {}
   DeclarationSeqCls(PPTreeNodeCls decl);
   int emit();
   PPTreeNodeCls    append(PPTreeNodeCls decl);
  
private:
   DeclarationCls *seq_head;
   DeclarationCls *seq_tail;
};

typedef class AddressCls *PAddressCls;
class AddressCls {
public:
   AddressCls():addr(-1) {}
   virtual void setAddr(int a);
   virtual int getAddr();

protected:
   int addr;
};

typedef class BlockCls *PBlockCls;
class BlockCls : public PTreeNodeCls {
public:
   BlockCls(PPTreeNodeCls StmtSeq);
   int      emit();
private:
   PPTreeNodeCls    stmt_seq;
};
/* end-BlockCls */

typedef class ProgramCls *PProgramCls;
class ProgramCls : public PTreeNodeCls {
public:
   ProgramCls()     {}
   ProgramCls(PPTreeNodeCls Ident, PPTreeNodeCls Block);
   int      emit();
   void     print();
private:
   SymtabCls    *std_table;
   PIdentCls ident;
   PPTreeNodeCls  block;
};
/* end-ProgramCls */

#endif