source: to-imperative/trunk/runtime/rf_expr.hh @ 1140

//-----------------------------------------------------------------------------
/// @file rf_expr.hh
///
/// Refal+ expression interface
//
//  $Source$
//  $Revision: 1140 $
//  $Date: 2003-08-10 21:42:33 +0000 (Sun, 10 Aug 2003) $
//-----------------------------------------------------------------------------

#ifndef __rf_expr_hh__
#define __rf_expr_hh__

#include "rf_common.hh"
#include "rf_term.hh"
#include "rf_memory_chunk.hh"
#include "rf_object.hh"

#include <new>
#include <string.h>

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

using namespace rftype ;

///
/// Parameter enumeration for SplitIterator template class
enum Direction {
  d_lt,         ///< Split from left
  d_rt          ///< Split from right
};

///
/// Refal expression class. This is the main type of Refal runtime objects,
/// and the only one the user should deal with. Other object types are not
/// visible from generated code and shouldn't be used directly.
class Expr
{

///
/// We may use expression methods in SplitIterator class. We cannot avoid this
/// because SplitIterator simultaneously changes two expressions in a way that
/// adding necessary methods to Expr class will break invariants.
template <Direction D = d_lt>
friend class SplitIterator ;
///
/// Stack and Arg classes are our friends because they use special copy
/// constructor which shouldn't be public available.
friend class Arg ;
friend class Stack ;
friend class Term ;

private:
  ///
  /// Pointer to the first term
  Term* first;
  ///
  /// Pointer beyond the last term
  Term* last;
  ///
  /// Pointer to a memory block containing an expression
  MemoryChunk* mem_chunk;
  ///
  /// Various expression flags. Currently only REF_BIT is supported, meaning
  /// that expression is not "flat", i.e. it may contain reference terms.
  uintptr_t flags;

public:

#if 0
  ///
  /// Constructor from character string
  inline Expr (char const* _string = null) ;
#endif
  ///
  /// Create an empty expression
  inline Expr () ;
  ///
  /// Constructor from expression holder. This constructor does dereference
  /// operation.
  /// @param _cp        Pointer to a term containg a reference to expression
  ///                   to be dereferenced
  inline Expr (Term const* _cp) ;
  ///
  /// Dereference constructor from explicit term in expression. Should be
  /// called only with valid index argument.
  /// @param _expr      Source expression
  /// @param _index     Term index inside expression
  inline Expr (Expr const& _expr, uintptr_t _index) ;
  ///
  /// Subexpression constructor
  /// @param _expr      Source expression
  /// @param _index     Index where subexpression started
  /// @param _length    Subexpression length
  inline Expr (Expr const& _expr, uintptr_t _index, uintptr_t _length) ;
  ///
  /// Copy constructor
  /// @param _expr      Source expression
  inline Expr (Expr const& _expr) ;
  ///
  /// Constructor from object
  /// @param _obj       Source object
  inline Expr (Object* _obj) ;
  ///
  /// Destructor
  inline ~Expr () ;
  ///
  /// Assignment operator
  /// @param _expr      Right side expression
  inline Expr& operator = (Expr const& _expr) ;
  ///
  /// Expression concatenation
  INLINE Expr operator + (Expr const& _expr) const ;
  ///
  /// Operator enclosing an expression into parentheses
  inline Expr operator () () const ;
  ///
  /// Operator that dereferences expression containing a single reference term
  inline Expr operator * () const ;
  ///
  /// Check whether a term at specified index is a symbol
  inline bool symbol_at (uintptr_t _index) const ;
  ///
  /// Check whether an expression is flat
  inline bool is_flat () const ;
  ///
  /// Check whether an expression is empty
  inline bool is_empty () const ;
  ///
  /// Get a pointer to the first term
  inline Term* get_first () const ;
  ///
  /// Get a pointer beyond the last term
  inline Term* get_last () const ;
  ///
  /// Get expression length (in terms)
  inline uintptr_t get_len () const ;
private:
  ///
  /// Get expression flags
  inline uintptr_t get_flags () const ;
public:
  ///
  /// Dump expression contents (not recursive)
  inline void dump () const ;
  ///
  /// Write an expression to buffered file stream. This function is incomplete
  /// and suboptimal.
  INLINE bool write (FILE* _fp) const ;
  ///
  /// The same as write(), but adds new line at the end of output.
  inline bool writeln (FILE* _fp) const ;
  INLINE bool print (FILE* _fp) const ;
  inline bool println (FILE* _fp) const ;
  INLINE operator WString () const ;
  ///
  /// Compute expression hash
  inline uint32_t hash () const ;
  ///
  /// Compare with subexpression of other expression.  Attention: doesn't check
  /// that our expression is not longer then the rest of the other.
  inline bool eq (Expr const& _expr, uintptr_t _index) ;
  ///
  /// Same method for const expression.
  inline bool eq (Expr const& _expr, uintptr_t _index) const ;
  ///
  /// Compare our first term with some one of another expression.
  /// Should be called only with valid index argument.
  inline bool term_eq (Expr const& _expr, uintptr_t _index) const ;
  ///
  /// Equality check operator
  inline bool operator == (Expr& _expr) ;
  ///
  /// Inequality check operator
  inline bool operator != (Expr& _expr) ;
  ///
  /// Same methods for const expressions.
  inline bool operator == (Expr const& _expr) const ;
  inline bool operator != (Expr const& _expr) const ;
  ///
  /// Compare two expressions.  Return 1 if first expression is larger then
  /// second one, 0 if they are equal, and -1 if first one is smaller then
  /// second one.
  static inline int compare (Expr const& _expr1, Expr const& _expr2) ;
  ///
  /// Get pointer to a memory block containing an expression
  inline MemoryChunk* get_mem_chunk () const ;
  ///
  /// Set a pointer to a memory block containing an expression. This method is
  /// used only to set a null pointer for uninitialized results on a stack,
  /// so if a refal function returns "$fail" we can distinguish whether a
  /// result expression was already constructed and delete it.
  /// FIXME: we should avoid this method at all, or at least make it private.
  inline void set_mem_chunk (MemoryChunk* _ptr) ;

private:

  ///
  /// Create an unitialized expression with given length. This constructor is
  /// private because expression body contains garbage. It is used during
  /// concatenation to allocate memory where resulting expression will be
  /// constructed.
  /// @param _len       A length of expression
  /// @param _align     Indicates how an expression will be aligned in a memory
  ///                   block: < 0 for left alignment, > 0 for right alignment,
  ///                   0 for centered alignment
  inline Expr (size_t _len, int _align = 0) ;
  ///
  /// Generic constructor. Should not be called directly because its arguments
  /// may not be arbitrary.
  /// @param _first     Pointer to the first term
  /// @param _last      Pointer to the right margin
  /// @param _mem_chunk Pointer to the memory block containing an expression
  /// @param _flags     Expression flags
  inline Expr (
    Term* const _first, Term* const _last,
    MemoryChunk* const _mem_chunk, uintptr_t const _flags
  ) ;
  ///
  /// Constructor from a reference term. This constructor originally was
  /// public because operator () returned Term instead of Expr, so this
  /// constructor was actually called from user code. Now the situation is
  /// changed and operator () now returns Expr. This allows to avoid friend
  /// operators + () with Term arguments. For a while we left that code,
  /// because further we may want to use it for optimization. Though we believe
  /// that compiler should optimize a creation of temporary objects.
  /// @param _cp        A term to become an expression.
  inline Expr (Term const& _cp) ;
  ///
  /// A special copy constructor from expression pointer. This constructor is
  /// used only to pop arguments and results from a stack. The trick is that
  /// we don't increment memory block reference counter when popping arguments
  /// from a stack. This allows to simply shift a stack pointer rather then
  /// doing full stack unwind.
  /// @param _expr      Source expression
  inline Expr (Expr const* _expr) ;
  ///
  /// Initialize new expression with specified length and alignment
  /// @param _len       A length of expression
  /// @param _align     Indicates how an expression will be aligned in a memory
  ///                   block: < 0 for left alignment, > 0 for right alignment,
  ///                   0 for centered alignment
  INLINE void init (size_t _len, int _align) ;
  ///
  /// Drop an expression contents. Used in destructor and assignment operator.
  /// After a call to this method expression may be used only to create a new
  /// expression at old place.
  inline void drop () ;
  ///
  /// Increment reference counters for all expressions referenced from us
  inline void ref_childs () const ;
  ///
  /// Decrement reference counters for all expressions referenced from us.
  /// This function is called when we lost the last reference to our memory
  /// block, so it should not only walk through our expression but also look
  /// beside expression margins.
  INLINE void deref_childs () const ;
  static INLINE void deref_childs (
    Term* _first, Term* _last, MemoryChunk* _mem
  ) ;
private:
  ///
  /// Check whether we can copy another expression to the right from our
  /// in the same memory block.
  inline bool rt_alloc (uintptr_t _len) const ;
  ///
  /// Check whether we can copy another expression to the left from our
  /// in the same memory block.
  inline bool lt_alloc( uintptr_t _len ) const ;


public:

  class TooLargeArgument :
    public Exception
  {
  public:
    void print()
      { fprintf(stderr, "Argument too large for conversion\n"); }
  };

};

///
/// A class representing a splitting of expression into two parts. This class
/// is needed to work with "open" expressions. It is closely related to
/// expression itself, so it is contained in the same file.
template <Direction D>
class SplitIterator
{
  ///
  /// Left side of splitted expression
  Expr lt ;
  ///
  /// Right side of splitted expression
  Expr rt ;
  ///
  /// Iterator state
  bool state ;
  ///
  /// Copy constructor and assignment operator do not have any sense for this
  /// class.
  NO_COPY_CTOR(SplitIterator)
  NO_ASSIGN(SplitIterator)

public:
  ///
  /// Constructor
  inline SplitIterator (Expr const& _expr, uintptr_t _min_len = 0) ;
  ///
  /// Destructor
  ~SplitIterator () ;
  ///
  /// Increment iterator
  inline SplitIterator& operator ++ () ;
  ///
  /// Postfix form of increment iterator
  inline SplitIterator& operator ++ (int) ;
  ///
  /// Decrement iterator
  inline SplitIterator& operator -- () ;
  ///
  /// Postfix form of decrement iterator
  inline SplitIterator& operator -- (int) ;
  ///
  /// Get iterator state
  inline operator bool () ;
  ///
  /// Get left part of expression
  inline Expr const& get_left () const ;
  ///
  /// Get right part of expression
  inline Expr const& get_right () const ;

};

///
/// A macro naming iterator for expression variable
#define iter(e) e##_iter
///
/// A macro splitting an expression variable
#define lsplit(e, minlen, le, re) \
  SplitIterator<d_lt> iter(e)(e, minlen); \
  Expr const& le = iter(e).get_left(); \
  Expr const& re = iter(e).get_right()
  
#define rsplit(e, minlen, le, re) \
  SplitIterator<d_rt> iter(e)(e, minlen); \
  Expr const& le = iter(e).get_left(); \
  Expr const& re = iter(e).get_right()

}

#endif // __rf_expr_hh__