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

// $Source$
// $Revision: 288 $
// $Date: 2002-12-19 12:11:29 +0000 (Thu, 19 Dec 2002) $

#ifndef __rf_term_hh__
#define __rf_term_hh__

#include "pxx_memory_chunk.hh"
#include "rf_common.hh"

namespace rfrt
{

#define M_Chunk pxx::Memory_Chunk

#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))

enum SymbolType {
  SYM_EMPTY = 0,
  SYM_BORDER,
  SYM_CHAR
};

class Term
{

friend class Expr ;
friend inline Expr operator + (Term const&, Expr const&) ;
friend inline Expr operator + (Term const&, Term const&) ;
friend inline bool operator == (Term const&, Term const&) ;
friend inline bool flat_eq (
    const Expr &_e1, uintptr_t _pos1,
    const Expr &_e2, uintptr_t _pos2, uintptr_t _len );

private:

  uintptr_t data1 ;
  uintptr_t data2 ;

  inline Term (uint16_t const _c) :
    data1 (SYM_CHAR),
    data2 (_c)
  {}

/*
  inline Term (Term* _first, Term* _last, unsigned _order, uintptr_t _ref_fl) :
    data1 ((uintptr_t)_first | ORDER1(_order)),
    data2 ((uintptr_t)_last | ORDER2(_order))
  {
    data1 |= _ref_fl;
  }
*/

  //
  // is needed for () operation
  inline Term (Expr const& _expr);

public:

  inline ~Term ()
  {}

  inline bool is_ref () const
  {
    return data1 > 0xFFFF;
  }

  inline bool is_sym () const
  {
    return data1 <= 0xFFFF;
  }

/*
  inline bool is_compound () const
  {
    return (data1 & COMPOUND_BIT) != 0;
  }
*/

  inline bool is_char () const
  {
    return (data1 & SYM_CHAR) != 0;
  }

  inline int get_char () const
  {
    return (int)(data2);
  }

  inline bool is_border () const
  {
    return ((data1 & SYM_BORDER) != 0);
  }

  inline unsigned get_order () const
  {
    return ORDER(data1 & ORDER1_MASK, data2 & ORDER2_MASK);
  }

  inline Term* get_first () const
  {
    return (Term*)(data1 & PTR_MASK);
  }

  inline Term* get_last () const
  {
    return (Term*)(data2 & PTR_MASK);
  }

  inline SymbolType get_type () const
  {
    return (SymbolType)(data1 & 0x7FFF);
  }

  //
  // return pointer to our memory chunk
  inline M_Chunk *get_mem_chunk() const
  {
    return static_cast<M_Chunk*>(
        allocator.get_block_start( get_first(), get_order() )
    );
  }
  
};

}

#endif // __rf_term_hh__