act_array.h

Go to the documentation of this file.

/*************************************************************************
 *
 *  This file is part of the ACT library
 *
 *  Copyright (c) 2018-2019 Rajit Manohar
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
 *
 **************************************************************************
 */
#ifndef __ACT_ARRAY_H__
#define __ACT_ARRAY_H__
 
#include <act/expr.h>
#include <common/list.h>
 
class ActNamespace;
class Scope;
class Arraystep;
class ActId;
class InstType;
class ValueIdx;
 
 
class Array {
 
  struct _act_array_expr_pair {
    Expr *lo, *hi;
  };
 
  struct _act_array_exprex_pair {
    long lo, hi;
  };
 
  struct _act_array_internal {
    unsigned int isrange:2;     
    union {
      struct _act_array_exprex_pair idx; 
      Expr *deref; 
    };
  };
 
 
 public:
  int isSparse() { return next == NULL ? 0 : 1; }
 
  int isDeref() { return deref; }
 
  void mkArray() { deref = 0; }
 
  int nDims() { return dims; }
 
  int effDims();
 
  void Concat (Array *a);
 
  void preConcat (Array *a);
 
  int isEqual (Array *a, int strict);
 
  int isDimCompatible (Array *a);
 
  void Merge (Array *a);
 
  Array (Expr *e, Expr *f = NULL);
 
  Array (int lo, int hi);
 
  Array (int idx);
 
  ~Array ();
 
  void Print (FILE *fp, int style = 0);
 
  void sPrint (char *buf, int sz, int style = 0);
 
  int sPrintOne (char *buf, int sz, int style = 0);
 
  void PrintOne (FILE *fp, int style = 0);
 
  Array *Next() { return next; }
 
  Array *Clone ();              
 
  Array *CloneOne ();           
 
  Array *Reduce();              
 
  int isExpanded() { return expanded; } 
  int size(); 
  int range_size(int d); 
  void update_range (int d, int lo, int hi);
 
  int isrange (int d) { return (r[d].u.ex.isrange == 1); }
 
  Expr *lo (int d) { return r[d].u.ue.lo; }
  
  Expr *hi (int d) { return r[d].u.ue.hi; }
 
  Array *Expand (ActNamespace *ns, Scope *s, int is_ref = 0);
 
  Array *ExpandRef (ActNamespace *ns, Scope *s) { return Expand (ns, s, 1); }
 
  Array *ExpandRefCHP (ActNamespace *ns, Scope *s);
 
  int Validate (Array *a);
 
  int isDynamicDeref ();
 
  Expr *getDeref (int idx);
 
  int Offset (Array *a);
 
  int Offset (int *a);
 
  Array *unOffset (int offset);
 
  Arraystep *stepper(Array *sub = NULL);
 
private:
  Array ();                     
  int in_range (Array *a);      
  int in_range (int *a);        
 
  int dims;                     
  struct range {
    union {
      struct _act_array_expr_pair ue; 
      struct _act_array_internal ex;  
    } u;
  } *r;                         
  void dumprange (struct range *r); 
  void _merge_range (int idx, Array *prev, struct range *m);
 
  int overlapping (struct range *a, struct range *b);
 
 
  unsigned int range_sz;        
  Array *next;                  
  unsigned int deref:1;         
  unsigned int expanded:1;      
  friend class Arraystep;
};
 
class Arraystep {
public:
  Arraystep (Array *a, Array *sub = NULL);
  
  ~Arraystep ();
  
  void step(); 
  
  int index() { return idx; } 
  
  int index(Array *b) { return b->Offset (deref); } 
  
  int isend();          
 
  int typesize() { return base->size(); } 
 
  char *string(int style = 0); 
  
  Array *toArray(); 
 
  void Print (FILE *fp, int style = 0);
  
private:
  int idx;  
  int *deref; 
  Array *base; 
  Array *subrange;              
  Array *insubrange;            
};
 
 
class AExprstep;
 
class AExpr {
 public:
  enum type {
    CONCAT, COMMA, /*SUBRANGE,*/ EXPR
  };
 
  AExpr (ActId *e); 
  
  AExpr (Expr *e); 
  
  AExpr (type t, AExpr *l, AExpr *r); 
  
  ~AExpr();
 
  int isEqual (AExpr *a); 
  AExpr *GetLeft () { return l; } 
  AExpr *GetRight () { return r; } 
  
  void SetRight (AExpr *a) { r = a; } 
  
  void Print (FILE *fp);  
  void sPrint (char *buf, int sz); 
 
  AExpr *Clone (); 
 
  InstType *getInstType (Scope *s, int *islocal, int expanded = 0);
 
  AExpr *Expand (ActNamespace *, Scope *, int is_lval = 0);
  ActId *toid ();
 
  int isBase() { return t == EXPR ? 1 : 0; }
 
  AExprstep *stepper();
 
  InstType *isType (); 
  
  int isArrayExpr();  
 
 private:
  enum type t;                  
 
  AExpr *l, *r;   
 
  friend class AExprstep;
};
 
class AExprstep {
public:
  AExprstep (AExpr *a); 
  ~AExprstep ();
  void step();  
  int isend();  
 
  unsigned long getPInt(); 
  long getPInts(); 
  double getPReal(); 
  int getPBool(); 
  InstType *getPType(); 
 
  void getID (ActId **id, int *idx, int *typesize);
 
  void getsimpleID (ActId **id, int *idx, int *typesize);
 
  int isSimpleID ();
 
 
private:
  list_t *stack;                
  AExpr *cur;                   
 
  union {
    Expr *const_expr;           
    struct {
      /* this is used for non-parameter identifiers */
      ActId *act_id;            
      Arraystep *a;             
      int issimple:1;           
    } id;
    struct {
      /* this is used for arrays of parameters */
      ValueIdx *vx;             
      Scope *s;                 
      Arraystep *a;             
    } vx;
  } u;
  unsigned int type:2;          
};
 
#endif /* __ACT_ARRAY_H__ */