namespaces.h

Go to the documentation of this file.

/*************************************************************************
 *
 *  This file is part of the ACT library
 *
 *  Copyright (c) 2011, 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 __NAMESPACES_H__
#define __NAMESPACES_H__
 
#include <common/hash.h>
#include <common/list.h>
#include <common/bitset.h>
#include <common/array.h>
 
class Act;
class ActBody;
class UserDef;
class Type;
class InstType;
class ActId;
class AExpr;
class AExprstep;
class ActNamespace;
class ActNamespaceiter;
class ActTypeiter;
class ValueIdx;
class act_connection;
class act_languages;
struct act_chp;
struct act_prs;
struct act_spec;
class Array;
 
 
class Scope {
 public:
 
  Scope(Scope *parent, int is_expanded = 0);
  ~Scope();
 
  Scope *Parent () { return up; }
 
  InstType *Lookup (const char *s);
 
  InstType *Lookup (ActId *id, int err = 1);
  
  void refineBaseType (const char *s, InstType *u);
 
  InstType *FullLookup (const char *s);
 
  int isGlobal (const char *s);
 
  InstType *FullLookup (ActId *id, Array **aref);
 
  InstType *localLookup (ActId *id, Array **aref);
 
  ValueIdx *LookupVal (const char *s);
 
  ValueIdx *FullLookupVal (const char *s);
 
  int Add (const char *s, InstType *it);
 
  void Del (const char *s);
 
  void FlushExpand ();
 
  void Merge (Scope *s);
 
  void Print (FILE *fp);
 
  void setUserDef (UserDef *_u) { u = _u; }
 
  void mkFunction () { is_function = 1; }
 
  int isFunction() { return is_function; }
 
  UserDef *getUserDef () { return u; }
 
  void setNamespace (ActNamespace *_ns) { ns = _ns; }
 
  ActNamespace *getNamespace () { return ns; }
 
  unsigned long AllocPInt(int count = 1);
 
  void DeallocPInt(unsigned long idx, int count = 1);
 
  void setPInt(unsigned long id, unsigned long val);
 
  int issetPInt (unsigned long id);
 
  unsigned long getPInt(unsigned long id);
 
  unsigned long AllocPInts(int count = 1);
  void DeallocPInts(unsigned long idx, int count = 1);
  int issetPInts (unsigned long id);
  long getPInts(unsigned long id);
  void setPInts(unsigned long id, long val);
 
  unsigned long AllocPReal(int count = 1);
 
  void DeallocPReal(unsigned long idx, int count = 1);
 
  int issetPReal (unsigned long id);
 
  double getPReal(unsigned long id);
  
  void setPReal(unsigned long id, double val);
 
  unsigned long AllocPBool(int count = 1);
 
  void DeallocPBool(unsigned long idx, int count = 1);
 
  int issetPBool (unsigned long id);
 
  int getPBool(unsigned long id);
  
  void setPBool(unsigned long id, int val);
 
  unsigned long AllocPType(int count = 1);
 
  void DeallocPType(unsigned long idx, int count = 1);
 
  int issetPType (unsigned long id);
 
  InstType *getPType(unsigned long id);
 
  void setPType(unsigned long id, InstType *val);
 
  int isExpanded () { return expanded; }
 
  void BindParam (const char *s, InstType *tt);
 
  void BindParam (ActId *id, InstType *tt);
 
  void BindParam (const char *s, AExpr *ae);
 
  void BindParam (ActId *id, AExpr *ae);
 
  void BindParam (ActId *id, AExprstep *aes, int idx = -1);
 
  void playBody (ActBody *b); /* create instances in the scope based
                                 on what is in the body */
 
  const char *getName();
 
  static void printConnections (FILE *fp, act_connection *cx, bool force = false);
  
 private:
  struct Hashtable *H;          /* maps names to InstTypes, if
                                   unexpanded; maps to ValueIdx if expanded. */
  Scope *up;
  
  UserDef *u;                   /* if it is a user-defined type */
  unsigned int expanded:1;      /* if it is an expanded scope */
  ActNamespace *ns;             /* if it is a namespace scope */
 
  int is_function;              /* 1 if this is a function scope */
 
  /* values that are per scope, rather than per instance */
  A_DECL (unsigned long, vpint);
  bitset_t *vpint_set;
 
  A_DECL (long, vpints);
  bitset_t *vpints_set;
 
  A_DECL (double, vpreal);
  bitset_t *vpreal_set;
 
  A_DECL (InstType *, vptype);
  bitset_t *vptype_set;
 
  unsigned long vpbool_len;
  bitset_t *vpbool;
  bitset_t *vpbool_set;
 
  friend class ActInstiter;
  friend class ActUniqProcInstiter;
};
 
 
class ActNamespace {
 public:
  ActNamespace (const char *s);
 
  ActNamespace (ActNamespace *ns, const char *s);
 
  ~ActNamespace ();
 
  const char *getName () { return self_bucket->key; }
 
  ActNamespace *findNS (const char *s);
 
 
  UserDef *findType (const char *s);
 
  InstType *findInstance (const char *s);
 
 
  int findName (const char *s);
 
 
  int isExported () { return exported; }
 
  void MkExported () { exported = 1; }
 
  void clrExported () { exported = 0; }
 
  ActNamespace *Parent () { return parent; }
 
  char *Name (bool add_colon = false);
 
  void Unlink ();
 
  void Link (ActNamespace *up, const char *name);
 
 
  int CreateType (const char *s, UserDef *u);
 
  int EditType (const char *s, UserDef *u);
 
  Scope *CurScope () { return I; }
 
 
  void Expand ();
 
  void enum2Int ();
 
  void Print (FILE *fp);
 
  int isExpanded() { return I->isExpanded(); }
 
 
  static void Init ();
 
  static ActNamespace *Global () { return global; }
 
  static class Act *Act() { return act; }
 
  static void setAct (class Act *a);
 
  void setBody (ActBody *b) { B = b; }
 
  void AppendBody (ActBody *b);
 
  ActBody *getBody () { return B; }
 
  act_prs *getprs ();
 
  act_spec *getspec ();
 
  act_languages *getlang() { return lang; }
 
  list_t *getSubNamespaces ();
 
  list_t *getProcList();
 
  list_t *getDataList();
 
  list_t *getChanList();
 
 private:
  
  act_languages *lang; 
 
  hash_bucket_t *self_bucket;
 
  struct Hashtable *N;
 
  struct Hashtable *T;
 
  Scope *I;
 
  ActBody *B;
 
  ActNamespace *parent;         
 
  unsigned int exported;        
 
  static ActNamespace *global;
 
  static class Act *act;
 
  static int creating_global;
 
  void _init (ActNamespace *parent, const char *s);
 
 
  void _subst_globals (list_t *subst, InstType *it, const char *s);
 
  /* second phase */
  void _subst_globals_addconn (list_t *subst, listitem_t *start,
                               InstType *it, const char *s);
 
  friend class Act;
  friend class ActNamespaceiter;
  friend class ActTypeiter;
};
 
 
 
class ActOpen {
 public:
  ActOpen();
  ~ActOpen();
 
  int Open(ActNamespace *ns, const char *newname = NULL);
 
 
  list_t *findAll (ActNamespace *cur, const char *s);
  ActNamespace *find (ActNamespace *cur, const char *s);
 
  ActNamespace *findType (ActNamespace *cur, const char *s);
  
 
 private:
  list_t *search_path;
};
  
#endif /* __NAMESPACES_H__ */