vector.h

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

/*
  $Id: Vector.h,v 1.2 1997/02/02 01:31:04 matt Exp $

  Vector container.

  (c) 1995 Matt Phillips
  */

#ifndef _VECTOR_H
#define _VECTOR_H

#include "Container.h"
#include "Data.h"

//////////////////// VectorImp

template <class T, class E>
class VectorImp : public Container<T>
{
public:

  typedef class VectorImpIter<T, E> Iterator;

  VectorImp (int _max, int size = 0) :
    Container<T> (size), max (_max), data (new E [max])
  {
    CHECK (size <= max, "init size exceeds bounds");
  }

  ~VectorImp () {clear (); delete data;}
   
  virtual const char *name () const {return "Vector";}

  virtual int isFull () const {return _nItems == max;}

  virtual void add (T &i)
  {
    CHECK (_nItems < max, "overflow");
    data [_nItems++].set (i);
  }

  virtual void clear ();

  T & operator [] (int i) const
  {
    CHECK (i >= 0 && i < _nItems, "index out of bounds");
    return data [i].ref ();
  }

  Iterator *makeIter () const {return new Iterator (*this);}

protected:

  friend class Iterator;

  int max;
  E *data;
};

#pragma option -wrch- -wccc-	// (Borland C++) turn off warnings for if stmt

template <class T, class E>
void VectorImp<T, E>::clear () 
{
  if (E::isOwner ())
  {
    for (int c = 0; c < _nItems; c++)
      data [c].destroy ();
  }

  _nItems = 0;
}

#pragma option -wrch. -wccc.	// reset defaults

template <class T, class E>
class VectorImpIter : public RContainerIter<T>
{
public:

  VectorImpIter (const VectorImp<T, E> &v) : vector (v), i (v.data) {}

  virtual T value () const
  {ITER_CURRENT (int (*this)); return i->ref ();}

  virtual T &ref () const
  {ITER_CURRENT (int (*this)); return i->ref ();}

  virtual void operator ++ (int)
  {ITER_BOUND (i < vector.data + vector._nItems); i++;}

  virtual void operator -- (int)
  {ITER_BOUND (i > vector.data); i--;}

  virtual operator int () const
  {return i >= vector.data && i < vector.data + vector._nItems;}

  virtual void resetStart () {i = vector.data;}
  virtual void resetEnd () {i = vector.data + vector._nItems - 1;}

protected:

  E *i;
  const VectorImp<T, E> &vector;
};

#define TypeDVector(T)  VectorImp<T, DCell<T> >
#define TypeIVector(T)  VectorImp<T, ICell<T, 0> >
#define TypeIOVector(T) VectorImp<T, ICell<T, 1> >

#endif