data.h

用于词法分析的词法分析器

/*
  $Id: Data.h,v 1.5 1996/07/26 10:13:06 matt Exp $

  General-purpose data element classes for containers.
  */

#ifndef _GENDATA_H
#define _GENDATA_H

template <class T> struct DContainerData
{
  DContainerData (T &d) : data (d) {}
  DContainerData (const DContainerData<T> &d) : data (d.data) {}
   
  static int isOwner () {return 0;}

  void copy (T &d) {data = d;}

  T &ref () {return data;}

  T data;
};

// null << operators for general data types
template <class T>
inline ostream &operator << (ostream &os, const DContainerData<T> &)
{
  return os;
}

#ifdef __BCC__

template <class T>
inline ostream &operator << (ostream_withassign &os,
			     const DContainerData<T> &)
{
  return os;
}

#endif

template <class T, int owner> struct IContainerData
{
  IContainerData (T &d) : data (&d) {}
  IContainerData (const IContainerData<T, owner> &d) :
    data (d.data) {}
  ~IContainerData () {if (owner) delete data;}

  static int isOwner () {return owner;}

  void copy (T &d)
  {
    if (owner)
      data = new T (d);
    else
      data = &d;
  }

  T &ref () const {return *data;}

  T *data;
};

template <class T> struct DLinkedItem : public DContainerData<T>
{
  DLinkedItem (T &_data, DLinkedItem<T> *_next = 0) :
    DContainerData<T> (_data), next (_next) {}
  DLinkedItem (const DLinkedItem<T> &d) :
    DContainerData<T> (d), next (0) {}

  DLinkedItem<T> *next;
};

template <class T, int owner>
struct ILinkedItem : public IContainerData<T, owner>
{
  ILinkedItem (T &_data, ILinkedItem<T, owner> *_next = 0) :
    IContainerData<T, owner> (_data), next (_next) {}
  ILinkedItem (const ILinkedItem<T, owner> &d) :
    IContainerData<T, owner> (d), next (0) {}
   
  ILinkedItem<T, owner> *next;
};

template <class T> struct DDoubleLinkItem : public DContainerData<T>
{
  DDoubleLinkItem (T &d) : DContainerData<T> (d) {}

  DDoubleLinkItem<T> *next, *prev;
};

template <class T, int owner>
struct IDoubleLinkItem : public IContainerData<T, owner>
{
  IDoubleLinkItem (T &_data) : IContainerData<T, owner> (_data) {}
   
  IDoubleLinkItem<T, owner> *next, *prev;
};

template <class T> struct DCell
{
  T &ref () {return data;}

  static isOwner () {return 0;}

  void set (T &i) {data = i;}
  void destroy () {}

  T data;
};

template <class T, int owner> struct ICell
{
  T &ref () {return *data;}

  static isOwner () {return owner;}

  void set (T &i) {data = &i;}
  void destroy () {if (owner) delete data; data = 0;}

  T *data;
};

template <class T> struct DBinaryTreeItem : public DContainerData<T>
{
  DBinaryTreeItem (T &d, DBinaryTreeItem<T> *l = 0,
		   DBinaryTreeItem<T> *r = 0) :
    DContainerData<T> (d), left (l), right (r) {}
   
  DBinaryTreeItem<T> *left, *right;
};

template <class T>
inline ostream &operator << (ostream &os, const DBinaryTreeItem<T> &)
{
  return os;
}

template <class T, int owner>
struct IBinaryTreeItem : IContainerData<T, owner>
{
  IBinaryTreeItem (T &d, IBinaryTreeItem<T, owner> *l = 0,
		   IBinaryTreeItem<T, owner> *r = 0) :
    IContainerData<T, owner> (d), left (l), right (r) {}

  IBinaryTreeItem<T, owner> *left, *right;
};

#endif