source: to-imperative/trunk/runtime/rf_term.hh @ 781

//-----------------------------------------------------------------------------
/// @file rf_term.hh
///
/// Refal+ term interface
//
//  $Source$
//  $Revision: 781 $
//  $Date: 2003-05-28 17:46:35 +0000 (Wed, 28 May 2003) $
//-----------------------------------------------------------------------------

#ifndef __rf_term_hh__
#define __rf_term_hh__

#include "rf_memory_chunk.hh"
#include "rf_common.hh"
#include "rf_types.hh"
#include "rf_object.hh"
#include "pxx_string.hh"

///
/// A namespace for Refal runtime
namespace rfrt
{

using namespace rftype ;

//
// In previous runtime version we keeped the order of memory block in each
// reference term. This was needed to compute a pointer of a memory block.
// Now an allocator is able to get this pointer for us, so we don't need all
// stuff related to this. However, we still keep old code, because in a future
// we may return to the old scheme if it can lead to faster program execution.
#if !defined(RF_STORE_CHUNK_ORDER_IN_TERM)

typedef enum {
  term_sym,
  term_ref,
  term_obj,
  term_class_num
} term_class_t ;

///
/// "Flat" bit. This bit, if set for reference term, means that referenced
/// expression is "flat", i.e. it contains only short symbols, so we should
/// accurately handle this when destroying the expression. This bit was
/// introduced because in a case of a "flat" expression we don't need to walk
/// through and dereference childs.
/// This bit is kept as invariant during all expression operations.
#define FLAT_BIT (uintptr_t(0x04))
///
/// Pointer mask. Used to obtain a clear pointer from term data.
#define PTR_MASK ~(uintptr_t((sizeof(uintptr_t) << 1) - 1))
///
/// Type mask. Used to distinguish between reference term and other terms.
/// This is the maximum number of internal "short" types (i.e. types that can
/// be placed in place in term data.
#define TYPE_MASK (uintptr_t(0xFFFF0))
#define CLASS_MASK (uintptr_t(0x03))
#define TYPE_SHIFT 4

#else
#if UINTPTR_MAX == UINT32_MAX
#define ORDER_SHIFT 3
#define REF_BIT (uintptr_t(0x04))
#define PTR_MASK (~(uintptr_t(0x07)))
#define ORDER1_MASK (uintptr_t(0x03))
#define ORDER2_MASK (uintptr_t(0x07))
#elif UINTPTR_MAX == UINT64_MAX
#define ORDER_SHIFT 4
#define REF_BIT (uintptr_t(0x08))
#define PTR_MASK (~(uintptr_t(0x0F)))
#define ORDER1_MASK (uintptr_t(0x03))
#define ORDER2_MASK (uintptr_t(0x0F))
#else
#error "Unsupported pointer size"
#endif
//#define COMPOUND_BIT (uintptr_t(0x8000))
//#define CHAR_SHIFT ((sizeof(uintptr_t) - sizeof (uint16_t)) * 8)
#define ORDER1(x) ((uintptr_t)((x) >> ORDER_SHIFT))
#define ORDER2(x) ((uintptr_t)((x) & ORDER2_MASK))
#define ORDER(x,y) (((x) << ORDER_SHIFT) | (y))

#endif // RF_STORE_CHUNK_ORDER_IN_TERM

//-----------------------------------------------------------------------------
/// Refal term. This is one of two basic runtime classes, which describes
/// Refal expression elements.
///
/// FIXME: To follow all invariants it is necessary to define copy ctor and
/// assignment operator, which should increment memory block reference counter
/// in a case of reference term. Destructor should decrement this reference
/// counter appropriately. This is not done for optimization purposes.
//-----------------------------------------------------------------------------
class Term
{
///
/// We can access all term fields from expression class and some methods
friend class Expr ;
friend inline Expr operator + (Term const&, Expr const&) ;
friend inline Expr operator + (Term const&, Term const&) ;
friend inline bool flat_eq (
  Expr const& _e1, uintptr_t _pos1,
  Expr const& _e2, uintptr_t _pos2, uintptr_t _len );

protected:
  ///
  /// The first term field containing symbol type or (in a case of reference
  /// term) pointer to the first term of referenced expresion
  uintptr_t data1 ;
  ///
  /// The second term field containing actual data (for short type), pointer
  /// to object (for object extensions) or pointer to the right margin of
  /// referenced expression

  union {
    uintptr_t uint_data2 ;
    intptr_t int_data2 ;
    void* ptr_data2 ;
  };

  ///
  /// Constructor for empty term with given class and type
  inline Term (term_class_t _class, unsigned _type) ;
  ///
  /// Create expression with specified length
  static inline Expr create_expr (size_t _len, int _align = 0) ;
  ///
  /// Create flat expression with specified length
  static inline Expr create_flat_expr (size_t _len, int _align = 0) ;
private:
  ///
  /// Constructor for a character term. All constructors are private because
  /// they should be called only from expression implementation.
  /// FIXME: Originally it was planned that all strings in Refal will be
  /// unicode-based (there will be no difference in expression size, because
  /// a term can contain either usual character or wide character). However it
  /// was decided later to have both character types, so probably instead of
  /// this we should have Term (char _c) and Term (wchar_t _c).
  inline Term (uint16_t _c) ;
  ///
  /// Constructor for a reference term. It is is needed for Expr::operator()
  /// implementation.
  /// FIXME: The definition of this method is in rf_expr.hh now. It should be
  /// moved into rf_term.ih, when expression interface and implementation will
  /// be separated.
  inline Term (Expr const& _expr) ;
  inline Term (Object* _obj) ;

  inline Term (Term const& _t) ;
  inline Term& operator = (Term const& _t) ;

  typedef void (Term::*ctor_func_t)(Term const& _t) ;
  typedef void (Term::*dtor_func_t)() ;
  typedef bool (Term::*eq_func_t)(Term const& _t) const ;
  typedef pxx::WString (Term::*to_string_func_t)() const ;
  typedef size_t (Term::*get_char_len_func_t)() const ;
  typedef Term* (Term::*to_chars_func_t)(Term* _p) const ;

  static ctor_func_t ctor_funcs[term_class_num] ;
  static dtor_func_t dtor_funcs[term_class_num] ;
  static eq_func_t eq_funcs[term_class_num] ;
  static to_string_func_t to_string_funcs[term_class_num] ;

  void ctor_sym (Term const& _t) ;
  void ctor_ref (Term const& _t) ;
  void ctor_obj (Term const& _t) ;
  void dtor_sym () ;
  void dtor_ref () ;
  void dtor_obj () ;
  bool eq_sym (Term const& _t) const ;
  bool eq_ref (Term const& _t) const ;
  bool eq_obj (Term const& _t) const ;
  pxx::WString to_string_sym () const ;
  pxx::WString to_string_ref () const ;
  pxx::WString to_string_obj () const ;

public:
  ///
  /// Destructor.
  inline ~Term () ;
  ///
  /// Check whether two terms are equal
  inline bool operator == (Term const& _t) const ;
  ///
  /// Check whether two terms are not equal
  inline bool operator != (Term const& _t) const ;
  ///
  /// Check whether two term sequences are equal
  static inline bool eq (
    Term const* _f1, Term const* _l1, Term const* _f2, Term const* _l2
  ) ;
  ///
  /// Check whether a term is a reference term
  inline bool is_ref () const ;
  ///
  /// Check whether a term is a symbol
  inline bool is_sym () const ;
  ///
  /// Check whether a term is a border symbol
  inline bool is_border () const ;
  ///
  /// Get a pointer to the first term of referenced expression for a reference
  /// term. Note that this method doesn't check whether a term is a reference
  /// term.
  inline Term* get_first () const ;
  ///
  /// Get a pointer to the right margin of referenced expression for
  /// a reference term. Note that this method doesn't checkwhether a term is
  /// a reference term.
  inline Term* get_last () const ;
  ///
  /// Get a type of "short" symbol.
  inline unsigned get_type () const ;
  ///
  /// Set a type of "short" symbol.
  inline void set_type (unsigned _type) ;
  inline term_class_t get_class () const ;
  inline void set_class (term_class_t _class) ;
  inline Object& get_object () ;
  ///
  /// Get a pointer to memory block containing referenced expression. Note
  /// that this method doesn't check whether a term is a reference term.
  inline MemoryChunk* get_mem_chunk() const ;

  inline operator pxx::WString () const ;

#if defined(RF_STORE_CHUNK_ORDER_IN_TERM)
  inline unsigned get_order () const
  {
    return ORDER(data1 & ORDER1_MASK, data2 & ORDER2_MASK);
  }
#endif

};

}

#endif // __rf_term_hh__