symtab.h

// Copyright (c) 2021-2023, David H. Hovemeyer <david.hovemeyer@gmail.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
 
#ifndef SYMTAB_H
#define SYMTAB_H
 
#include <map>
#include <vector>
#include <string>
#include <memory>
#include "type.h"
#ifdef SOLUTION
#include "storage.h"
#endif
 
class SymbolTable;
 
enum class SymbolKind {
  FUNCTION,
  VARIABLE,
  TYPE,
};
 
class Symbol {
private:
  SymbolKind m_kind;
  std::string m_name;
  std::shared_ptr<Type> m_type;
  SymbolTable *m_symtab;
#ifdef SOLUTION
  unsigned m_flags;
  unsigned m_offset;
  int m_vreg;
#endif
  bool m_is_defined;
 
  // value semantics prohibited
  Symbol(const Symbol &);
  Symbol &operator=(const Symbol &);
 
public:
#ifdef SOLUTION
  // flags
  enum Flag {
    MEMORY = 1,
    GLOBAL = 2,
  };
#endif
  Symbol(SymbolKind kind, const std::string &name, const std::shared_ptr<Type> &type, SymbolTable *symtab, bool is_defined);
  ~Symbol();
 
  // a function, variable, or type can be declared
  // and then later defined, so allow m_is_defined to
  // be updated
  void set_is_defined(bool is_defined);
 
  SymbolKind get_kind() const;
  const std::string &get_name() const;
  std::shared_ptr<Type> get_type() const;
  SymbolTable *get_symtab() const;
  bool is_defined() const;
#ifdef SOLUTION
 
  void set_flag(Flag flag)       { m_flags |= unsigned(flag); }
  void clear_flag(Flag flag)     { m_flags &= ~(unsigned(flag)); }
  bool has_flag(Flag flag) const { return (m_flags & unsigned(flag)) != 0U; }
 
  void set_offset(unsigned offset) { m_offset = offset; }
  unsigned get_offset() const      { return m_offset; }
 
  void set_vreg(int vreg) { m_vreg = vreg; }
  int get_vreg() const    { return m_vreg; }
#endif
};
 
class SymbolTable {
private:
  SymbolTable *m_parent;
  std::vector<Symbol *> m_symbols;
  std::map<std::string, unsigned> m_lookup;
#ifdef SOLUTION
  bool m_report;
  bool m_add_fields;
  int m_next_vreg;
#endif
  bool m_has_params; // true if this symbol table contains function parameters
  std::shared_ptr<Type> m_fn_type; // this is set to the type of the enclosing function (if any)
 
  // value semantics prohibited
  SymbolTable(const SymbolTable &);
  SymbolTable &operator=(const SymbolTable &);
 
public:
  SymbolTable(SymbolTable *parent);
  ~SymbolTable();
 
  SymbolTable *get_parent() const;
 
  bool has_params() const;
  void set_has_params(bool has_params);
 
  // Operations limited to the current (local) scope.
  // Note that the caller should verify that a name is not defined
  // in the current scope before calling declare or define.
  bool has_symbol_local(const std::string &name) const;
  Symbol *lookup_local(const std::string &name) const;
  Symbol *declare(SymbolKind sym_kind, const std::string &name, const std::shared_ptr<Type> &type);
  Symbol *define(SymbolKind sym_kind, const std::string &name, const std::shared_ptr<Type> &type);
 
  // Iterate through the symbol table entries in the order in which they were added
  // to the symbol table. This is important for struct types, where the representation
  // of the type needs to record the fields (and their types) in the exact order
  // in which they appeared in the source code.
  typedef std::vector<Symbol *>::const_iterator const_iterator;
  const_iterator cbegin() const { return m_symbols.cbegin(); }
  const_iterator cend() const { return m_symbols.cend(); }
 
  // Operations that search recursively starting from the current (local)
  // scope and expanding to outer scopes as necessary
  Symbol *lookup_recursive(const std::string &name) const;
 
  // This can be called on the symbol table representing the function parameter
  // scope of a function to record the exact type of the function
  void set_fn_type(const std::shared_ptr<Type> &fn_type);
 
  // This returns the function type of the enclosing function, or nullptr
  // if there is no enclosing function. This is helpful for type checking
  // a return statement, to make sure that the value returned is
  // assignment-compatible with the function's return type.
  std::shared_ptr<Type> get_fn_type() const;
#ifdef SOLUTION
 
  void set_report(bool en) { m_report = en; }
  bool add_fields() const { return m_add_fields; }
  void set_add_fields(bool en) { m_add_fields = en; }
 
  bool is_global_scope() const { return m_parent == nullptr; }
 
  bool is_parameter_scope() const { return bool(m_fn_type) && m_fn_type->is_function(); }
#endif
 
  int get_depth() const;
 
private:
  void add_symbol(Symbol *sym);
};
 
#endif // SYMTAB_H