SymbolTable

The symbol table stores which symbols have been defined in the program (in ASL, that is just variable and function names) and associates each symbol with a type in TypeMgr.

The symbol table is also able to handle visibility scopes, so we can have separate tables for separate functions, or stacked tables for nested scopes.

Thus, class SymTable stores which symbols have been defined in each scope, and we can query it about which is the type of symbol, whether a symbol is defined in the current function, or (if it is defined twice because there is a nested scope) which is the definition we should use at each moment.

////////////////////////////////////////////////////////////////
// Class SymTable: stores the symbols declared in the program
// along with the information associated with each one:
//   - its class (the symbol can be a function, a parameter or
//     a local variable)
//   - its type (the TypeId returned by the TypesMgr)
// The symbols are grouped in scopes. In the current version
// of Asl there are two level of scopes: the global and the
// local. The former for the symbols of function names, and
// the latter for symbols declared inside a function:
// parameters and local variables.
// The SymTable uses a 'stack' to keep the current available
// scopes that determines which symbols are visible and
// which are not. Entering in a function will push a new
// scope to the stack and exiting will pop the stack.

class SymTable {

public:

  // The ScopeId is an index in a vector
  typedef std::size_t ScopeId;

  // Name of the Global Scope
  static const std::string GLOBAL_SCOPE_NAME;

  // Constructor
  SymTable(TypesMgr & Types);
  // Destructor
  ~SymTable() = default;

  // Manage the stack of scopes
  //   - create a new empty scope and push its ScopeId in the stack
  ScopeId pushNewScope  (const std::string & name);
  //   - pop the stack of scopes
  void    popScope      ();
  //   - push a previously created scope sc and set it as current scope
  void    pushThisScope (ScopeId sc);
  //   - returns the current scope
  ScopeId topScope      ()                          const;

  // Methods to find an ident
  //   - in the current scope (top of the stack)
  bool    findInCurrentScope (const std::string & ident)             const;
  //   - in the whole stack. Returns the number of scopes skipped to
                          // find the symbol, or -1 if it is not found
  int     findInStack        (const std::string & ident)             const;

  // Adds a new symbol in the current scope
  void addLocalVar  (const std::string & ident, TypesMgr::TypeId type);
  void addParameter (const std::string & ident, TypesMgr::TypeId type);
  void addFunction  (const std::string & ident, TypesMgr::TypeId type);

  // Accessors to check the class of the symbol. If not found return false
  bool isLocalVarClass  (const std::string & ident) const;
  bool isParameterClass (const std::string & ident) const;
  bool isFunctionClass  (const std::string & ident) const;

  // Accessor to get the TypeId of a symbol. If not found return type 'error'
  TypesMgr::TypeId getType (const std::string & ident) const;

  // Check the existence of the "main" function
  bool noMainProperlyDeclared() const;

  // Given the name of a function, returns its TypeId
  TypesMgr::TypeId getGlobalFunctionType (const std::string & ident) const;
  // Given the names of a function and a local symbol, returns its TypeId
  TypesMgr::TypeId getLocalSymbolType    (const std::string & funcName,
                                          const std::string & ident) const;

  // Print the symbols of a scope on the standard output
  //   - the symbols of the current scope (top of the stack)
  void printCurrentScope () const;
  //   - the symbols of the whole stack
  void print             () const;

};  // class SymTable