Compilation with egcs when compiling jade (2/3)

Thu Jan 7 07:49:00 GMT 1999

public:
  Resource();
  Resource(  Resource &);
  int unref();			 
  void ref();
  int count()  ;
private:
  int count_;
};

 
Resource::Resource()
: count_(0)
{
}

 
Resource::Resource(  Resource &)
: count_(0)
{
}

 
int Resource::count()  
{
  return count_;
}

 
int Resource::unref()
{
  return --count_ <= 0;
}

 
void Resource::ref()
{
  ++count_;
}


# 8 "../include/CharMap.h" 2


class CharMapBits {
public:
  enum { level1 = 8, level2 = 4, level3 = 4 };
};

template<class T>
class CharMapColumn {
public:
  CharMapColumn();
  CharMapColumn(  CharMapColumn<T> &);
  void operator=(  CharMapColumn<T> &);
  ~CharMapColumn();
  T *values;
  T value;
};

template<class T>
class CharMapPage {
public:
  CharMapPage();
  CharMapPage(  CharMapPage<T> &);
  void operator=(  CharMapPage<T> &);
  ~CharMapPage();
  void swap(CharMapPage<T> &);
  CharMapColumn<T> *values;
  T value;
};


template<class T>
class CharMap {
public:
  CharMap();
  CharMap(T);
  T operator[](Char)  ;
  T getRange(Char from, Char &to)  ;
  void swap(CharMap<T> &);
  void setChar(Char, T);
  void setRange(Char from, Char to, T val);
  void setAll(T);
private:

  CharMapPage<T> pages_[1 << CharMapBits::level1];


};

template<class T>
class CharMapResource : public CharMap<T>, public Resource {
public:
  CharMapResource() { }
  CharMapResource(T t) : CharMap<T>(t) { }
};


template<class T>
 
T CharMap<T>::operator[](Char c)  
{
    CharMapPage<T> &pg = pages_[c >> (CharMapBits::level2 + CharMapBits::level3)];
  if (pg.values) {
      CharMapColumn<T> &column = pg.values[(c >> CharMapBits::level3) & ((1 << CharMapBits::level2) - 1)];
    if (column.values)
      return column.values[c & ((1 << CharMapBits::level3) - 1)];
    else
      return column.value;
  }
  else
    return pg.value;
}

template<class T>
 
T CharMap<T>::getRange(Char c, Char &max)  
{
    CharMapPage<T> &pg = pages_[c >> (CharMapBits::level2 + CharMapBits::level3)];
  if (pg.values) {
      CharMapColumn<T> &column = pg.values[(c >> CharMapBits::level3) & ((1 << CharMapBits::level2) - 1)];
    if (column.values) {
      max = c;
      return column.values[c & ((1 << CharMapBits::level3) - 1)];
    }
    else {
      max = (c & ~((1 << CharMapBits::level3) - 1)) + ((1 << CharMapBits::level3) - 1);
      return column.value;
    }
  }
  else {
    max = (c & ~((1 << (CharMapBits::level2 + CharMapBits::level3)) - 1)) + ((1 << (CharMapBits::level2 + CharMapBits::level2)) - 1);
    return pg.value;
  }
}

# 135 "../include/CharMap.h"


# 12 "../include/UnivCharsetDesc.h" 2

# 1 "../include/RangeMap.h" 1
 
 
# 1 "../include/Vector.h" 1
 
 
# 1 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 1 3
# 342 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 3

# 7 "../include/Vector.h" 2

# 1 "../include/xnew.h" 1


# 17 "../include/xnew.h"


# 1 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/new" 1 3
 
 
#pragma interface "new"
# 1 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 1 3
# 342 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 3

# 8 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/new" 2 3

# 1 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/exception" 1 3
 
 
#pragma interface "exception"

extern "C++" {

namespace std {

class exception {
public:
  exception () { }
  virtual ~exception () { }
  virtual   char* what ()  ;
};

class bad_exception : public exception {
public:
  bad_exception () { }
  virtual ~bad_exception () { }
};

typedef void (*terminate_handler) ();
typedef void (*unexpected_handler) ();

terminate_handler set_terminate (terminate_handler);
void terminate () __attribute__ ((__noreturn__));
unexpected_handler set_unexpected (unexpected_handler);
void unexpected () __attribute__ ((__noreturn__));
bool uncaught_exception ();

}  

}  


# 9 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/new" 2 3


extern "C++" {

namespace std {

  class bad_alloc : public exception {
  public:
    virtual   char* what()   throw() { return "bad_alloc"; }
  };

  struct nothrow_t {};
  extern   nothrow_t nothrow;
  typedef void (*new_handler)();
  new_handler set_new_handler (new_handler);

}  

 
void *operator new (size_t) throw (std::bad_alloc);
void *operator new[] (size_t) throw (std::bad_alloc);
void operator delete (void *) throw();
void operator delete[] (void *) throw();
void *operator new (size_t,   std::nothrow_t&) throw();
void *operator new[] (size_t,   std::nothrow_t&) throw();
void operator delete (void *,   std::nothrow_t&) throw();
void operator delete[] (void *,   std::nothrow_t&) throw();

 
  void *operator new(size_t, void *place) throw() { return place; }
  void *operator new[](size_t, void *place) throw() { return place; }
}  


# 20 "../include/xnew.h" 2


# 35 "../include/xnew.h"


# 8 "../include/Vector.h" 2


template<class T>
class Vector {
public:
  typedef size_t size_type;
  typedef T *iterator;
  typedef   T *const_iterator;
  Vector() : ptr_(0), size_(0), alloc_(0) { }
  Vector(size_t n) : ptr_(0), size_(0), alloc_(0) { append(n); }
  ~Vector();
  void resize(size_t n) {
    if (n < size_)
      erase(ptr_ + n, ptr_ + size_);
    else if (n > size_)
      append(n - size_);
  }

  Vector(size_t,   T &);
  Vector(  Vector<T> &);
  Vector<T> &operator=(  Vector<T> &);
  void assign(size_t,   T &);
  void push_back(  T &t) {
    reserve(size_ + 1);
    (void)new (ptr_ + size_) T(t);
    size_++;
  }
  void insert(const_iterator p, size_t n,   T &t);
  void insert(const_iterator p, const_iterator q1, const_iterator q2);

  void swap(Vector<T> &);
  void clear() { erase(ptr_, ptr_ + size_); }
  size_t size()   { return size_; }
  T &operator[](size_t i) { return ptr_[i]; }
    T &operator[](size_t i)   { return ptr_[i]; }
  iterator begin() { return ptr_; }
  const_iterator begin()   { return ptr_; }
  T &back() { return ptr_[size_ - 1]; }
    T &back()   { return ptr_[size_ - 1]; }
  void reserve(size_t n) {  if (n > alloc_) reserve1(n); }
  iterator erase(const_iterator, const_iterator);
private:


  void append(size_t);
  void reserve1(size_t);
  
  size_t size_;
  T *ptr_;
  size_t alloc_;		 
};


# 7 "../include/RangeMap.h" 2

# 1 "../include/Boolean.h" 1
 
 
typedef bool Boolean;


typedef char PackedBoolean;


# 8 "../include/RangeMap.h" 2

# 1 "../include/ISet.h" 1
 
 
# 1 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 1 3
# 342 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 3

# 8 "../include/ISet.h" 2

# 1 "../include/Vector.h" 1
 
 
# 74 "../include/Vector.h"


# 9 "../include/ISet.h" 2


template<class T> class ISetIter;

template<class T>
struct ISetRange {
  T min;
  T max;
};
  
template<class T>
class ISet {
public:
  ISet();
  ISet(  T *, size_t);
  ~ISet();
  Boolean contains(T)  ;
  void remove(T);
  void add(T x) { addRange(x, x); }
  void addRange(T, T);


  void check();
  void operator+=(T x) { addRange(x, x); }
  void clear();
  Boolean isSingleton()   {
    return r_.size() == 1 && r_[0].min == r_[0].max;
  }
  Boolean isEmpty()   { return r_.size() == 0; }
  void swap(ISet<T> &x) { r_.swap(x.r_); }
friend class ISetIter<T>;
private:
  Vector<ISetRange<T> > r_;
};


# 9 "../include/RangeMap.h" 2


# 1 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 1 3
# 342 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 3

# 11 "../include/RangeMap.h" 2


template<class From, class To>
struct RangeMapRange {
  From fromMin;
  From fromMax;
  To toMin;
};

template<class From, class To> class RangeMapIter;

template<class From, class To>
class RangeMap {
public:
  RangeMap();
  Boolean map(From, To &, From &alsoMax)  ;
   
  unsigned inverseMap(To, From &, ISet<WideChar> &, WideChar &count)  ;
  void addRange(From, From, To);
private:
  Vector<RangeMapRange<From,To> > ranges_;
  friend class RangeMapIter<From,To>;
};

template<class From, class To>
class RangeMapIter {
public:
  RangeMapIter(  RangeMap<From,To> &map);
  Boolean next(From &fromMin, From &fromMax, To &toMin) {
    if (!count_)
      return 0;
    else {
      fromMin = ptr_->fromMin;
      fromMax = ptr_->fromMax;
      toMin = ptr_->toMin;
      ptr_++;
      count_--;
      return 1;
    }
  }
private:
  size_t count_;
    Vector<RangeMapRange<From,To> >::const_iterator ptr_;
};


# 13 "../include/UnivCharsetDesc.h" 2


# 1 "../include/ISet.h" 1
 
 
# 54 "../include/ISet.h"


# 15 "../include/UnivCharsetDesc.h" 2

# 1 "../include/constant.h" 1


  Char charMax = Char(-1);
  WideChar wideCharMax = WideChar(-1);
  UnivChar univCharMax = UnivChar(-1);
  SyntaxChar syntaxCharMax = SyntaxChar(-1);


# 16 "../include/UnivCharsetDesc.h" 2


class   UnivCharsetDesc {
public:
  struct   Range {
    WideChar descMin;
     
     
    unsigned long count;
    UnivChar univMin;
  };
  enum {
    zero = 48,
    A = 65,
    a = 97,
    tab = 9,
    rs = 10,
    re = 13,
    space = 32,
    exclamation = 33,
    lessThan = 60,
    greaterThan = 62
    };
  UnivCharsetDesc();
  UnivCharsetDesc(  Range *, size_t);
  void set(  Range *, size_t);
  Boolean descToUniv(WideChar from, UnivChar &to)  ;
  Boolean descToUniv(WideChar from, UnivChar &to, WideChar &alsoMax)  ;
   
  unsigned univToDesc(UnivChar from, WideChar &to, ISet<WideChar> &toSet)
        ;
  unsigned univToDesc(UnivChar from, WideChar &to, ISet<WideChar> &toSet,
		      WideChar &count)
        ;
  void addRange(WideChar descMin, WideChar descMax, UnivChar univMin);
  void addBaseRange(  UnivCharsetDesc &baseSet,
		    WideChar descMin,
		    WideChar descMax,
		    WideChar baseMin,
		    ISet<WideChar> &baseMissing);
private:
  static Boolean noDesc(Unsigned32 n) {
    return (n & (unsigned(1) << 31));
  }
  static UnivChar extractChar(Unsigned32 n, Char ch) {
    return UnivChar((n + ch) & ((unsigned(1) << 31) - 1));
  }
  static Unsigned32 wrapChar(UnivChar univ, Char ch) {
    return Unsigned32((univ - ch) & ((unsigned(1) << 31) - 1));
  }
   
  CharMap<Unsigned32> charMap_;
   
  RangeMap<WideChar,UnivChar> rangeMap_;
  friend class UnivCharsetDescIter;
};

class   UnivCharsetDescIter {
public:
  UnivCharsetDescIter(  UnivCharsetDesc &);
  Boolean next(WideChar &descMin, WideChar &descMax, UnivChar &univMin);
  void skipTo(WideChar);
private:
    CharMap<Unsigned32> *charMap_;
  Char nextChar_;
  Boolean doneCharMap_;
  RangeMapIter<WideChar,UnivChar> rangeMapIter_;
};

 
Boolean UnivCharsetDesc::descToUniv(WideChar from, UnivChar &to)  
{
  if (from > charMax) {
    WideChar tem;
    return rangeMap_.map(from, to, tem);
  }
  else {
    Unsigned32 tem = charMap_[from];
    if (noDesc(tem))
      return 0;
    else {
      to = extractChar(tem, from);
      return 1;
    } 
  }
}

 
Boolean UnivCharsetDesc::descToUniv(WideChar from, UnivChar &to,
				    WideChar &alsoMax)  
{
  if (from > charMax)
    return rangeMap_.map(from, to, alsoMax);
  else {
    Char max;
    Unsigned32 tem = charMap_.getRange(from, max);
    alsoMax = max;
    if (noDesc(tem))
      return 0;
    else {
      to = extractChar(tem, from);
      return 1;
    }
  }
}

 
unsigned UnivCharsetDesc::univToDesc(UnivChar from, WideChar &to,
				     ISet<WideChar> &toSet)  
{
  WideChar tem;
  return univToDesc(from, to, toSet, tem);
}

 
void UnivCharsetDescIter::skipTo(WideChar ch)
{
  if (ch > charMax)
    doneCharMap_ = 1;
  else
    nextChar_ = ch;
}


# 11 "../include/CharsetInfo.h" 2


# 1 "../include/StringC.h" 1
 
 
# 1 "../include/StringOf.h" 1
 
 
# 1 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 1 3
# 342 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/stddef.h" 3

# 14 "../include/StringOf.h" 2

# 1 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/string.h" 1 3
 

extern "C" {


     extern int memcmp(  void *,   void *, size_t);
     extern char *strncat(char *,   char *, size_t);
     extern int strncmp(  char *,   char *, size_t);
     extern void *memmove(void *,   void *, size_t);
     extern char *strcpy(char *,   char *);
     extern char *strncpy(char *,   char *, size_t);
     extern char *strcat(char *,   char *);
     extern int strcmp(  char *,   char *);
     extern int strcoll(  char *,   char *);
     extern size_t strxfrm(char *,   char *, size_t);
     extern char *strchr(  char *, int);
     extern char *strpbrk(  char *,   char *);
     extern char *strrchr(  char *, int);
     extern char *strstr(  char *,   char *);
     extern char *strtok(char *,   char *);
     extern char *strerror(int);


# 65 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/string.h" 3


       extern void *memcpy(void *,   void *, size_t);
       extern void *memchr(  void *, int, size_t);
       extern void *memset(void *, int, size_t);
       extern size_t strcspn(  char *,   char *);
       extern size_t strspn(  char *,   char *);


          extern size_t strlen(  char *);


# 107 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/string.h" 3


# 141 "/usr/local/lib/gcc-lib/hppa2.0-hp-hpux10.20/egcs-2.92.34/include/string.h" 3


}


# 15 "../include/StringOf.h" 2


template<class T>
class String {
public:
  typedef size_t size_type;
  typedef T *iterator;
  typedef   T *const_iterator;
  String();
  ~String() { if (ptr_) delete [] ptr_; }
  String(  T *, size_t);
  String(  String<T> &);
  String<T> &operator=(  String<T> &);
  size_t size()   { return length_; }
  String<T> &assign(  T *, size_t);
  String<T> &insert(size_t i,   String<T> &s);
  void swap(String<T> &str);
  T operator[](size_t i)   { return ptr_[i]; }
  T &operator[](size_t i) { return ptr_[i]; }
  iterator begin() { return ptr_; }
  const_iterator begin()   { return ptr_; }
    T *data()   { return ptr_; }
  String<T> &operator+=(T c) {
    if (length_ >= alloc_)
      grow(1);
    ptr_[length_++] = c;
    return *this;
  }
  String<T> &operator+=(  String<T> &s) {
    append(s.ptr_, s.length_);
    return *this;
  }
  String<T> &append(  T *, size_t);
  Boolean operator==(  String<T> &s)   {
    return (length_ == s.length_
	    && (length_ == 0
		|| (*ptr_ == *s.ptr_
		    && (memcmp(ptr_ + 1, s.ptr_ + 1, (length_ - 1)*sizeof(T))
			== 0))));
  }
  Boolean operator!=(  String<T> &str)   {
    return !(*this == str);
  }
  void resize(size_t n);
private:
  void grow(size_t);
  T *ptr_;
  size_t length_;
  size_t alloc_;
};


# 8 "../include/StringC.h" 2


typedef String<Char> StringC;


# 14 "../include/CharsetInfo.h" 2

# 1 "../include/ISet.h" 1
 
 
# 54 "../include/ISet.h"


# 15 "../include/CharsetInfo.h" 2

# 1 "../include/CharMap.h" 1
 
 
# 141 "../include/CharMap.h"


# 16 "../include/CharsetInfo.h" 2


class   CharsetInfo {
public:
  CharsetInfo();
  CharsetInfo(  UnivCharsetDesc &);
  void set(  UnivCharsetDesc &);
   
   
  Char execToDesc(char)  ;
  StringC execToDesc(  char *s)  ;
  Boolean descToUniv(WideChar from, UnivChar &to)  ;
  Boolean descToUniv(WideChar from, UnivChar &to, WideChar &alsoMax)  ;
   
   
  unsigned univToDesc(UnivChar from, WideChar &to, ISet<WideChar> &toSet)
        ;
  unsigned univToDesc(UnivChar from, WideChar &to, ISet<WideChar> &toSet,
		      WideChar &count)
        ;
  void getDescSet(ISet<Char> &)  ;
  int digitWeight(Char)  ;
  int hexDigitWeight(Char)  ;
    UnivCharsetDesc &desc()  ;
private:
  void init();
  UnivCharsetDesc desc_;
  CharMap<Unsigned32> inverse_;
  Char execToDesc_[255  + 1];
};

 
unsigned CharsetInfo::univToDesc(UnivChar from, WideChar &to,
				 ISet<WideChar> &toSet)
      
{
  if (from <= Char(-1)) {
    Unsigned32 n = inverse_[from];
    if (n == Unsigned32(-1))