ucsym.h

Go to the documentation of this file.

/*
Copyright (C) 2000 The Exult Team

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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef INCL_UCSYM
#define INCL_UCSYM

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <string>
#include <map>
#include <vector>
using std::vector;

class Uc_array_expression;
class Uc_expression;
class Uc_function;

/*
 *  For comparing names:
 */
class String_compare
  {
public:
  bool operator()(char * const &x, char * const &y) const;
  };

/*
 *  A formal parameter or local symbol within a function.
 */
class Uc_symbol
  {
protected:
  std::string name;     // This will be the key.
public:
  friend class Uc_scope;
  Uc_symbol(char *nm) : name(nm)
    {  }
  const char *get_name() { return name.c_str(); }
          // Gen. code to put result on stack.
  virtual int gen_value(vector<char>& out);
          // Gen. to assign from stack.
  virtual int gen_assign(vector<char>& out);
          // Generate function/procedure call.
  virtual int gen_call(vector<char>& out, Uc_function *fun, bool orig,
    Uc_expression *item, Uc_array_expression *parms, 
              bool retvalue);
  virtual int get_string_offset() // Get offset in text_data.
    { return -1; }
          // Return var/int expression.
  virtual Uc_expression *create_expression();
  };

/*
 *  A variable (untyped) that can be assigned to.
 */
class Uc_var_symbol : public Uc_symbol
  {
protected:
  int offset;     // Within function.  Locals follow
          //   formal parameters.
public:
  friend class Uc_scope;
  Uc_var_symbol(char *nm, int off) : Uc_symbol(nm), offset(off)
    {  }
  int get_offset()
    { return offset; }
          // Gen. code to put result on stack.
  virtual int gen_value(vector<char>& out);
          // Gen. to assign from stack.
  virtual int gen_assign(vector<char>& out);
          // Return var/int expression.
  virtual Uc_expression *create_expression();
  };

/*
 *  A static (persistent) variable.
 */
class Uc_static_var_symbol : public Uc_var_symbol
  {
public:
  Uc_static_var_symbol(char *nm, int off) : Uc_var_symbol(nm, offset)
    {  }
          // Gen. code to put result on stack.
  virtual int gen_value(vector<char>& out);
          // Gen. to assign from stack.
  virtual int gen_assign(vector<char>& out);
  };

/*
 *  A constant integer variable.
 */
class Uc_const_int_symbol : public Uc_symbol
  {
  int value;
public:
  Uc_const_int_symbol(char *nm, int v) : Uc_symbol(nm), value(v)
    {  }
          // Gen. code to put result on stack.
  virtual int gen_value(vector<char>& out);
          // Return var/int expression.
  virtual Uc_expression *create_expression();
  int get_value() const
    { return value; }
  };

/*
 *  A (constant) string.  The offset is within the usecode function's
 *  text_data field.
 */
class Uc_string_symbol : public Uc_symbol
  {
  int offset;     // In function's text_data.
public:
  Uc_string_symbol(char *nm, int off) : Uc_symbol(nm), offset(off)
    {  }
          // Gen. code to put result on stack.
  virtual int gen_value(vector<char>& out);
  virtual int get_string_offset() // Get offset in text_data.
    { return offset; }
          // Return var/int expression.
  virtual Uc_expression *create_expression();
  };

/*
 *  An intrinsic symbol:
 */
class Uc_intrinsic_symbol : public Uc_symbol
  {
  int intrinsic_num;    // Intrinsic #.
  int num_parms;      // # parms. +++++Not used/set yet.
public:
  Uc_intrinsic_symbol(char *nm, int n) : Uc_symbol(nm), intrinsic_num(n),
    num_parms(0)
    {  }
  int get_intrinsic_num()
    { return intrinsic_num; }
  int get_num_parms()   // ++++Not valid yet.
    { return num_parms; }
          // Generate function/procedure call.
  virtual int gen_call(vector<char>& out, Uc_function *fun, bool orig,
    Uc_expression *item, Uc_array_expression *parms, 
              bool retvalue);
  };

/*
 *  A function-prototype symbol:
 */
class Uc_function_symbol : public Uc_symbol
  {
  static int last_num;    // Last 'usecode_num', so we can
          //   assign automatically.
public:
          // Keep track of #'s used.
  typedef std::map<int, Uc_symbol *> Sym_nums;
private:
  static Sym_nums nums_used;
          // Note:  offset = Usecode fun. #.
  std::vector<char *> parms;  // Parameters.
  int usecode_num;    // Usecode function #.
public:
  Uc_function_symbol(char *nm, int num, std::vector<char *>& p);
  const std::vector<char *>& get_parms()
    { return parms; }
  int get_usecode_num()
    { return usecode_num; }
  int get_num_parms()
    { return parms.size(); }
          // Generate function/procedure call.
  virtual int gen_call(vector<char>& out, Uc_function *fun, bool orig,
    Uc_expression *item, Uc_array_expression *parms, 
              bool retvalue);
  };

/*
 *  A 'scope' in the symbol table:
 */
class Uc_scope
  {
  Uc_scope *parent;   // ->parent.
          // For finding syms. by name.
  typedef std::map<char *, Uc_symbol *, String_compare> Sym_map;
  Sym_map symbols;
  std::vector<Uc_scope *> scopes; // Scopes within.
public:
  Uc_scope(Uc_scope *p) : parent(p)
    {  }
  ~Uc_scope();
  Uc_scope *get_parent()
    { return parent; }
  Uc_symbol *search(const char *nm) // Look in this scope.
    {
    char *nm1 = (char *) nm;
    Sym_map::const_iterator it = symbols.find(nm1);
    if (it == symbols.end())
      return 0;
    else
      return (*it).second;
    }
          // Search upwards through scopes.
  Uc_symbol *search_up(char *nm);
  void add(Uc_symbol *sym)  // Add (does NOT check for dups.)
    {
    const char *nm = sym->name.c_str();
    char *nm1 = (char *)nm; // ???Can't figure this out!
    symbols[nm1] = sym; 
    }
  Uc_scope *add_scope()   // Create new scope.
    {
    Uc_scope *newscope = new Uc_scope(this);
    scopes.push_back(newscope);
    return newscope;
    }
          // Add a function decl.
  int add_function_symbol(Uc_function_symbol *fun);
  };

#endif

---