/*****
 * access.h
 * Andy Hammerlindl 2003/12/03
 *
 * Describes an "access," a representation of where a variable will be
 * stored at runtime, so that read, write, and call instructions can be
 * made.
 *****/

#ifndef ACCESS_H
#define ACCESS_H

#include <cassert>

#include "errormsg.h"
#include "item.h"
#include "vm.h"

namespace vm {
struct callable;
}

namespace trans {

class frame;
class coder;

enum action {
  READ,
  WRITE,
  CALL
};

// These serves as the base class for the accesses.
class access : public gc {
protected:
  // Generic compiler access error - if the compiler functions properly,
  // none of these should be reachable by the user.
  void error(position pos)
  {
    em.compiler(pos);
    em << "invalid use of access";
  }

public:
  virtual ~access() = 0;

  // Encode a read/write/call of the access when nothing is on the stack.
  virtual void encode(action, position pos, coder &)
  {
    error(pos);
  }
  // Encode a read/write/call of the access when the frame "top" is on top
  // of the stack.
  virtual void encode(action, position pos, coder &, frame *)
  {
    error(pos);
  }
};

// This class represents identity conversions in casting.
class identAccess : public access
{
  virtual void encode(action act, position, coder&);
};

// Represents a function that is implemented by a built-in C++ function.
class bltinAccess : public access {
  vm::bltin f;

public:
  bltinAccess(vm::bltin f)
    : f(f) {}

  void encode(action act, position pos, coder &e);
  void encode(action act, position pos, coder &e, frame *);
};

// Similar to bltinAccess, but works for any callable.
class callableAccess : public access {
  vm::callable *f;

public:
  callableAccess(vm::callable *f)
    : f(f) {}

  void encode(action act, position pos, coder &e);
  void encode(action act, position pos, coder &e, frame *);
};

// An access that puts a frame on the top of the stack.
class frameAccess : public access {
  frame *f;

public:
  frameAccess(frame *f)
    : f(f) {}

  void encode(action act, position pos, coder &e);
  void encode(action act, position pos, coder &e, frame *top);
};

// Represents the access of a local variable.
class localAccess : public access {
  Int offset;
  frame *level;

public:
  localAccess(Int offset, frame *level)
    : offset(offset), level(level) {}

  void encode(action act, position pos, coder &e);
  void encode(action act, position pos, coder &e, frame *top);
};

class qualifiedAccess : public access {
  // The location and frame of the record.
  access *qualifier;
  frame *qualifierLevel;

  // The location of the field relative to the record.
  access *field;

public:
  qualifiedAccess(access *qualifier, frame *qualifierLevel, access *field)
    : qualifier(qualifier), qualifierLevel(qualifierLevel), field(field) {}

  void encode(action act, position pos, coder &e);
  void encode(action act, position pos, coder &e, frame *top);
};

} // namespace trans

#endif // ACCESS_H