types.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_TYPES_H__
#define __ACT_TYPES_H__
 
#include <act/basetype.h>
#include <act/namespaces.h>
#include <act/act_array.h>
#include <act/expr.h>
#include <act/expr_extra.h>
#include <common/mstring.h>
#include <act/inst.h>
#include <string.h>
 
class ActBody;
struct act_chp_lang;
struct act_chp;
struct act_prs;
struct act_spec;
struct act_attr;
 
class PInt : public Type {
  const char *getName() { return "pint"; }
 
  Type *Expand (ActNamespace */*ns*/, Scope */*s*/, int /*nt*/, inst_param */*u*/) {
    return this;
  }
 
  int isEqual (const Type *t) const { return t == this ? 1 : 0; }
};
 
 
class PInts : public Type {
  const char *getName() { return "pints"; }
  Type *Expand (ActNamespace */*ns*/, Scope */*s*/, int /*nt*/, inst_param */*u*/) {
    return this;
  }
  int isEqual (const Type *t) const { return t == this ? 1 : 0; }
};
 
 
class PBool : public Type {
  const char *getName() { return "pbool"; }
 
  Type *Expand (ActNamespace */*ns*/, Scope */*s*/, int /*nt*/, inst_param */*u*/) {
    return this;
  }
 
  int isEqual (const Type *t) const { return t == this ? 1 : 0; }
};
 
 
class PReal : public Type {
  const char *getName() { return "preal"; }
 
  Type *Expand (ActNamespace */*ns*/, Scope */*s*/, int /*nt*/, inst_param */*u*/) {
    return this;
  }
 
  int isEqual (const Type *t) const { return t == this ? 1 : 0; }
};
 
class PType : public Type {
public:
  const char *getName();
 
  PType *Expand (ActNamespace *ns, Scope *s, int nt, inst_param *u);
 
  PType() { i = NULL; name = NULL; };
 
  /* wrong */
  int isEqual (const Type *t) const { return t == this ? 1 : 0; }
 
  InstType *getType () { return i; }
 
private:
  InstType *i;                  
 
  const char *name;             
 
  friend class TypeFactory;
};
 
class Bool : public Type {
  const char *getName() { return "bool"; }
  
  Type *Expand (ActNamespace */*ns*/, Scope */*s*/, int /*nt*/, inst_param */*u*/) {
    return this;
  }
  int isEqual (const Type *t) const { return t == this ? 1 : 0; }
};
 
 
class Int : public Type {
  const char *getName();
 
  Int *Expand (ActNamespace *ns, Scope *s, int nt, inst_param *u);
 
  int isEqual (const Type *t) const;
  
  unsigned int kind:2;          
  int w;                        
  
  const char *name;             
  
  friend class TypeFactory;
};
 
class Chan : public Type {
  const char *getName ();
 
  Chan *Expand (ActNamespace *ns, Scope *s, int nt, inst_param *u);
 
  int isEqual (const Type *t) const;
  
 
  const char *name;           
  InstType *p;                
  InstType *ack;              
 
public:
  InstType *datatype() const { return p; }
 
  InstType *acktype() const { return ack; }
 
  int isBiDirectional() { return ack == NULL ? 0 : 1; }
 
  friend class TypeFactory;
};
 
 
class InstType;
class UserMacro;
 
 
 
class UserDef : public Type {
 public:
  UserDef (ActNamespace *ns);
 
  UserDef (UserDef *x);
 
  virtual ~UserDef (); 
 
  const char *getFile() { return file; }
 
  void setFile(const  char *s) { file = string_cache (s); }
 
  int getLine() { return lineno; }
 
  void setLine(int num) { lineno = num; }
  
  int IsExported () { return exported; }
 
  void MkExported () { exported = 1; }
 
  int isExpanded() const { return expanded; }
  
 
  int AddMetaParam (InstType *t, const char *id);
 
  int AddPort (InstType *t, const char *id);
 
 
  int FindPort (const char *id);
 
  const char *getPortName (int pos) const;
 
  
  InstType *getPortType (int pos) const;
 
  void refinePortType (int pos, InstType *u);
 
  const char *getName ();
  
  char *getFullName(); 
  
 
  void printActName (FILE *fp);
 
  int isEqual (const Type *t) const;
 
  void setName (const char *s) { name = s; }
 
  void MkCopy (UserDef *u);
 
  int isEqual (const UserDef *u) const;
 
  void SetParent (InstType *t);
 
  InstType *getParent () const { return parent; }
 
  int isDefined () { return defined; }
 
  void MkDefined () { defined = 1; }
 
  int isPort(const char *name);
 
  int getNumParams () const { return nt; }
 
  int getRemainingParams() const { return nt - inherited_templ; }
 
  int getNumPorts () const { return nports; }
 
  InstType *Lookup (ActId *id) { return I->Lookup (id, 0); }
  
  InstType *Lookup (const char *nm) { return I->Lookup (nm); }
 
  Scope *CurScope() { return I; }
 
  int isStrictPort (const char *name);
 
  virtual void Print (FILE */*fp*/) { }
 
  void PrintHeader (FILE *fp, const char *type);
 
  void setBody (ActBody *x) { b = x; }
 
  void AppendBody (ActBody *x);
 
  ActBody *getBody () { return b; }
 
  UserDef *Expand (ActNamespace */*ns*/, Scope */*s*/, int /*nt*/, inst_param */*u*/) {
    Assert (0, "Don't call this ever");
  }
 
  UserDef *Expand (ActNamespace *ns, Scope *s, int nt, inst_param *u, int *cache_hit, int is_process = 0);
 
  ActNamespace *getns() { return _ns; }
 
  InstType *root() const;
 
  act_prs *getprs ();
 
  act_spec *getspec ();
 
  act_languages *getlang () { return lang; }
 
  int isLeaf();
 
  void mkRefined() { has_refinement = 1; }
 
  int hasRefinement() { return has_refinement; }
 
  UserMacro *newMacro (const char *name);
 
  UserMacro *getMacro (const char *name);
 
 protected:
  InstType *parent;             
  
  unsigned int defined:1;       
  unsigned int expanded:1;      
 
  unsigned int pending:1;       
 
  unsigned int exported:1;      
 
  act_languages *lang;          
  
  int nt;                       
  InstType **pt;                
  const char **pn;              
 
  int nports;                   
  InstType **port_t;            
  const char **port_n;          
 
  Scope *I;                     
 
  const char *name;             
 
  ActBody *b;                   
  ActNamespace *_ns;            
 
  UserDef *unexpanded;          
 
  int level;                    
 
  const char *file; 
  int lineno;       
  int has_refinement;         
 
  int inherited_templ;       
  inst_param **inherited_param;  
 
  int emitMacros (FILE *fp);
 
  A_DECL (UserMacro *, um);   
};
 
 
class Interface : public UserDef {
 public:
  Interface (UserDef *u);
  ~Interface ();
 
  Interface *Expand (ActNamespace *ns, Scope *s, int nt, inst_param *u);
};
 
 
class Process : public UserDef {
 public:
  Process (UserDef *u);
  virtual ~Process ();
 
  void MkCell () { is_cell = 1; }
 
  int isCell() { return is_cell; }
 
  Process *Expand (ActNamespace *ns, Scope *s, int nt, inst_param *u);
 
  void Print (FILE *fp);
 
  int isBlackBox();
 
  int isLowLevelBlackBox ();    
                                
  void addIface (InstType *iface, list_t *imap);
 
  int hasIface (InstType *x, int weak);
 
  list_t *findMap (InstType *iface);
 
  /*-- edit API --*/
 
  bool updateInst (char *name, Process *t);
 
  const char *addBuffer (char *name, ActId *port, Process *buf);
 
  const char *addBuffer (Process *buf, list_t *inst_ports);
 
  Process *getUnexpanded();
 
  void recordGlobal (ActId *id);
 
  int findGlobal (ActId *id);
 
  int findGlobal (const char *s);
    
 private:
  unsigned int is_cell:1;       
  list_t *ifaces;               
 
  list_t *used_globals;         
 
  int bufcnt;                   
};
 
 
class Function : public UserDef {
 public:
  Function (UserDef *u);
  ~Function ();
 
  void setRetType (InstType *i) { ret_type = i; }
 
  InstType *getRetType () { return ret_type; }
 
  Function *Expand (ActNamespace *ns, Scope *s, int nt, inst_param *u);
 
  void Print (FILE *fp);
 
  Expr *eval (ActNamespace *ns, int nargs, Expr **args);
 
  Expr **toInline (int nargs, Expr **args);
 
  int isExternal ();
  
  int isSimpleInline () { return is_simple_inline; }
 
  void chkInline ();
  
 private:
  InstType *ret_type;           
  int is_simple_inline;         
 
  void _chk_inline (Expr *e);   
  void _chk_inline (struct act_chp_lang *c); 
};
 
 
#define ACT_NUM_STD_METHODS 8    
 
#define ACT_NUM_EXPR_METHODS 2  
 
extern const char *act_builtin_method_name[ACT_NUM_STD_METHODS];
 
extern const char *act_builtin_method_expr[ACT_NUM_EXPR_METHODS];
 
extern const int act_builtin_method_boolret[ACT_NUM_EXPR_METHODS];
 
 
enum datatype_methods {
    ACT_METHOD_SET = 0,         
    
    ACT_METHOD_GET = 1,         
    
    ACT_METHOD_SEND_REST = 2,   
    
    ACT_METHOD_RECV_REST = 3,   
    
    ACT_METHOD_SEND_UP = 4,     
    
    ACT_METHOD_RECV_UP = 5,     
    
    ACT_METHOD_SEND_INIT = 6,   
    
    ACT_METHOD_RECV_INIT = 7,   
    
    ACT_METHOD_SEND_PROBE = 0 + ACT_NUM_STD_METHODS, 
    
    ACT_METHOD_RECV_PROBE = 1 + ACT_NUM_STD_METHODS 
};
 
 
class Data : public UserDef {
 public:
  Data (UserDef *u);
  virtual ~Data();
 
  int isEqual (const Type *t) const; 
 
  void MkEnum (int is_int) { is_enum = 1; is_eint = is_int ? 1 : 0; }
 
  int isEnum () const  { return is_enum; }
 
  int isPureEnum() const { return (is_enum && !is_eint) ? 1 : 0; }
 
  void addEnum (const char *s) {
    if (!enum_vals) {
      enum_vals = list_new ();
    }
    list_append (enum_vals, s);
  }
 
  int numEnums() const {
    if (enum_vals) {
      return list_length (enum_vals);
    }
    return 0;
  }
 
  int enumVal (const char *s) const {
    int i = 0;
    if (!enum_vals) return -1;
    for (listitem_t *li = list_first (enum_vals); li; li = list_next (li)) {
      if (strcmp ((const char *)list_value (li), s) == 0) {
        return i;
      }
      i++;
    }
    return -1;
  }
 
  void setMethod (int t, struct act_chp_lang *h) { methods[t] = h; }
  
  struct act_chp_lang *getMethod (int t) { return methods[t]; }
 
  void copyMethods (Data *d);
 
  Data *Expand (ActNamespace *ns, Scope *s, int nt, inst_param *u);
 
  void Print (FILE *fp);
 
  void getStructCount (int *nbools, int *nints);
 
  int getStructOffset (ActId *field, int *sz);
 
  ActId **getStructFields (int **types);
 
private:
  void _get_struct_count (int *nbools, int *nints);
  void _get_struct_fields (ActId **a, int *types, int *pos, ActId *prefix);
  
  unsigned int is_enum:1;       
  unsigned int is_eint:1;       
 
  struct act_chp_lang *methods[ACT_NUM_STD_METHODS]; 
  
  list_t *enum_vals;            
};
 
 
class Channel : public UserDef {
 public:
  Channel (UserDef *u);
  virtual ~Channel();
 
  void setMethod (int t, act_chp_lang *h) { methods[t] = h; }
 
  void setMethod (int t, Expr *e) { emethods[t-ACT_NUM_STD_METHODS] = e; }
 
  act_chp_lang *getMethod(int t) { return methods[t]; }
 
  Expr *geteMethod(int t) { return emethods[t-ACT_NUM_STD_METHODS]; }
 
  void copyMethods (Channel *c);
 
  Channel *Expand (ActNamespace *ns, Scope *s, int nt, inst_param *u);
  
  void Print (FILE *fp);
 
  int chanDir (ActId *id, int isinput);
 
  int mustbeActiveSend ();
  
  int mustbeActiveRecv ();
  
  int isBiDirectional() {
    Assert (parent, "what?");
    Channel *p = dynamic_cast<Channel *>(parent->BaseType());
    if (p) {
      return p->isBiDirectional();
    }
    else {
      Chan *p = dynamic_cast<Chan *>(parent->BaseType());
      Assert (p, "What?");
      return p->isBiDirectional();
    }
  }
 private:
  struct act_chp_lang *methods[ACT_NUM_STD_METHODS]; 
  Expr *emethods[ACT_NUM_EXPR_METHODS];              
};
 
 
struct act_inline_table;
 
 
class UserMacro {
public:
  UserMacro (UserDef *u, const char *name);
  ~UserMacro ();
 
  void Print (FILE *fp);
 
  UserMacro *Expand (UserDef *ux, ActNamespace *ns, Scope *s, int is_proc);
 
  int addPort (InstType *it, const char *name);
 
  const char *getName () { return _nm; }
 
  int getNumPorts() const { return nports; }
 
  const char *getPortName (int i) const { return port_n[i]; }
 
  InstType *getPortType (int i) const { return port_t[i]; }
 
  void setBody (struct act_chp_lang *);
 
  struct act_chp_lang *substitute (ActId *instnm, act_inline_table *tab); 
 
private:
  const char *_nm;           
  UserDef *parent;           
 
  int nports;                
  InstType **port_t;         
  const char **port_n;       
 
  struct act_chp_lang *c;    
};
 
 
class TypeFactory {
 private:
  static TypeFactory *tf;       
  
  static InstType *pint;
  
  static InstType *pints;
  
  static InstType *preal;
 
  static InstType *pbool;
 
  static InstType *bools[5];
 
  static Expr *expr_true;
 
  static Expr *expr_false;
 
  static struct iHashtable *expr_int;
 
  static struct cHashtable *inthash;
  
  static struct cHashtable *enumhash;
 
  static struct cHashtable *ptypehash;
 
  static int inthashfn (int, void *);
  static int intmatchfn (void *, void *);
  static void *intdupfn (void *);
  static void intfreefn (void *);
 
  static struct cHashtable *chanhash;
 
  static int chanhashfn (int, void *);
  static int chanmatchfn (void *, void *);
  static void *chandupfn (void *);
  static void chanfreefn (void *);
 
 public:
  TypeFactory();
  ~TypeFactory();
 
  void *operator new (size_t);
  void operator delete (void *);
 
  InstType *NewPInt ()  { return pint; }
 
  InstType *NewPInts ()  { return pints; }
 
  InstType *NewPBool () { return pbool; }
 
  InstType *NewPReal () { return preal; }
 
  InstType *NewPType (Scope *s, InstType *t);
 
  PType *NewPType (InstType *t);
 
  InstType *NewBool (Type::direction dir);
 
  InstType *NewInt (Scope *s, Type::direction dir, int sig, Expr *w);
  Int *NewInt (int sig, int w);
 
  InstType *NewEnum (Scope *s, Type::direction dir, Expr *w);
 
  InstType *NewChan (Scope *s, Type::direction dir, InstType *l, InstType *ack);
 
  Chan *NewChan (InstType *l, InstType *ack);
 
  InstType *NewUserDef (Scope *s, InstType *it);
 
 
  static Expr *NewExpr (Expr *e);
 
  static TypeFactory *Factory() { return tf; }
  
  static void Init ();
 
 
  static int isDataType (const Type *t);
 
  static int isDataType (const InstType *t);
 
  static int isIntType (const Type *t);
  
  static int isIntType (const InstType *t);
 
  static int isPIntType (const Type *t);
 
  static int isPIntType (const InstType *t);
 
  static int isPIntsType (const Type *t);
 
  static int isPIntsType (const InstType *t);
 
  static int isBoolType (const Type *t);
 
  static int isBoolType (const InstType *it);
  
  static int isPBoolType (const Type *t);
 
  static int isPBoolType (const InstType *it);
 
  static int isPRealType (const Type *t);
 
  static int isPRealType (const InstType *it);
 
  static int isUserType (const Type *t);
  
  static int isUserType (const InstType *it);
 
  static int isChanType (const Type *t);
 
  static int isChanType (const InstType *it);
 
  static int isExactChanType (const Type *t);
 
  static int isExactChanType (const InstType *it);
 
  static int isValidChannelDataType (const Type *t);
  
  static int isValidChannelDataType (const InstType *t);
 
  static int isProcessType (const Type *t);
  
  static int isProcessType (const InstType *it);
 
  static int isFuncType (const Type *t);
 
  static int isFuncType (const InstType *it);
 
 
  static int isInterfaceType (const Type *t);
 
  static int isInterfaceType (const InstType *it);
  
  static int isPTypeType (const Type *t);
 
  static int isPTypeType (const InstType *it);
 
 
  static int isParamType (const Type *t);
 
  static int isParamType (const InstType *it);
 
  static int bitWidth (const Type *t);
 
  static int bitWidth (const InstType *t);
 
  static int bitWidthTwo (const Type *t);
 
  static int bitWidthTwo (const InstType *t);
 
  static int boolType (const Type *t); 
 
  static int boolType (const InstType *t);
 
  static int isStructure (const Type *t);
 
  static int isStructure (const InstType *it);
 
  static int isUserEnum (const Type *t);
 
  static int isUserEnum (const InstType *it);
  
  static int isUserPureEnum (const Type *t);
 
  static int isUserPureEnum (const InstType *it);
 
  static int enumNum (const Type *t);
  static int enumNum (const InstType *t);
 
  static int isEnum (const Type *t);
 
  static int isEnum (const InstType *t);
  
  static int isBaseBoolType (const Type *t);
 
  static int isBaseBoolType (const InstType *t);
 
  static int isBaseIntType (const Type *t);
 
  static int isBaseIntType (const InstType *t);
 
  static InstType *getChanDataType (const InstType *t);
 
  static InstType *getChanAckType (const InstType *t);
};
 
#include <act/typecheck.h>
 
/*------------------------------------------------------------------------
 *
 *  Helper functions for expression manipulation
 *
 *------------------------------------------------------------------------
 */
 
int expr_equal (const Expr *a, const Expr *b);
 
void print_expr (FILE *fp, const Expr *e);
 
void sprint_expr (char *buf, int sz, const Expr *e);
 
 
void print_uexpr (FILE *fp, const Expr *e);
 
 
void sprint_uexpr (char *buf, int sz, const Expr *e);
 
int expr_is_a_const (Expr *e);
 
Expr *expr_dup_const (Expr *e);
 
const char *expr_op_name (int);
 
/* unified expression expansion code, with flags to control
   different variations */
#define ACT_EXPR_EXFLAG_ISLVAL   0x1 
 
#define ACT_EXPR_EXFLAG_PARTIAL  0x2 
 
#define ACT_EXPR_EXFLAG_CHPEX    0x4 
 
#define ACT_EXPR_EXFLAG_DUPONLY  0x8 
 
extern int _act_chp_is_synth_flag;   
 
Expr *expr_expand (Expr *e, ActNamespace *ns, Scope *s, unsigned int flag = 0x2);
 
#define expr_dup(e) expr_expand ((e), NULL, NULL, ACT_EXPR_EXFLAG_DUPONLY)
 
void expr_ex_free (Expr *);
 
/*
  External functions for core act library must 
  be of the form
 
  long function_name (int nargs, long *args);
*/
 
struct ExtLibs;
 
void *act_find_dl_func (struct ExtLibs *el, ActNamespace *ns, const char *f);
 
struct ExtLibs *act_read_extern_table (const char *prefix);
 
 
 
void act_error_push (const char *s, const char *file, int line);
 
void act_error_update (const char *file, int line); // set file to
                                                    // NULL to keep
                                                    // the file name
 
void act_error_pop ();                              
 
void act_error_ctxt (FILE *);   
 
const char *act_error_top ();   
 
void act_error_setline (int line); 
 
#endif /* __ACT_TYPES_H__ */