range.h

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

/*
  $Id: Range.h,v 1.1 1996/04/08 08:57:29 matt Exp $

  Generic ranges class.

  (c) Feb 1995 Matt Phillips.
  */

#ifndef _RANGE_H
#define _RANGE_H

#include <stdlib.h>
#include <iostream.h>

#include "swap.h"

template <class T>
class Range
{
  friend ostream &operator << (ostream &os, const Range<T> &range);

public:

  Range () {lower = upper = 0;}
  Range (T l, T u) {set (l, u);}
  Range (T i) {lower = upper = i;}
  Range (const Range<T> &rng) : lower (rng.lower), upper (rng.upper) {}

  void operator = (const Range<T> &r)
  {lower = r.lower; upper = r.upper;}

  int operator < (const Range<T> &r) const
  {
    return lower < r.lower || (lower == r.lower && upper < r.upper);
  }

  int operator <= (const Range<T> &r) const
  {
    return lower < r.lower || (lower == r.lower && upper <= r.upper);
  }

  int operator > (const Range<T> &r) const
  {
    return lower > r.lower || (lower == r.lower && upper > r.upper);
  }

  int operator >= (const Range<T> &r) const
  {
    return lower > r.lower || (lower == r.lower && upper >= r.upper);
  }

  int operator == (const Range<T> &r) const
  {
    return lower == r.lower && upper == r.upper;
  }

  void normalize () {if (lower > upper) swap (lower, upper);}

  void set (T l, T u)
  {
    if (l <= u)
    {
      lower = l; upper = u;
    } else
    {
      lower = u; upper = l;
    }
  }

  void set (T i) {lower = upper = i;}

  void shadow (const Range<T> &r)
  {
    lower = max (lower, r.lower);
    upper = min (upper, r.upper);
  }

  void merge (const Range<T> &r)
  {
    lower = min (lower, r.lower);
    upper = max (upper, r.upper);
  }
      
  void nullify () {lower = upper = 0;}

  int isNull () const {return lower >= upper;}

  int overlaps (const Range<T> &r) const
  {
    return upper <= r.upper && upper >= r.lower ||
      r.upper <= upper && r.upper >= lower;
  }

  // true if ranges lie just next to each other
  int adjacent (const Range<T> &r) const
  {
    return (upper == r.lower - 1) || (r.upper == lower - 1);
  }

  int isIn (T i) const {return i >= lower && i <= upper;}

  int length () const {return upper - lower + 1;}

  T lower, upper;
};

template <class T>
inline ostream &operator << (ostream &os, const Range<T> &range)
{
  os << range.lower << " - " << range.upper;
  return os;
}

#endif