This is the mail archive of the
gcc-bugs@gcc.gnu.org
mailing list for the GCC project.
gcc-2.95.2 emits internal compiler error 19970302
- To: bug-gcc at gnu dot org
- Subject: gcc-2.95.2 emits internal compiler error 19970302
- From: Jochen Voss <voss at mathematik dot uni-kl dot de>
- Date: Thu, 06 Jan 2000 11:36:12 -0500
- Cc: Jochen Voss <voss at mathematik dot uni-kl dot de>
Hello,
when I try to compile the appended c++ program the result is an
internal compiler error.
I am using an Intel-based GNU/Linux system and gcc version 2.95.2:
The output of `uname -a' is
Linux hostname 2.2.14pre18 #1 Tue Jan 4 15:59:56 CET 2000 i586 unknown
The command `c++ -v' emits
Reading specs from /usr/lib/gcc-lib/i586-pc-linux-gnu/2.95.2/specs
gcc version 2.95.2 19991024 (release)
When I try to compile the file via the command "c++ test.ii", I get
the following error message:
test.ii: In instantiation of `SharedXcharMap<unsigned char>':
test.ii:1951: instantiated from here
test.ii:1081: Internal compiler error 19970302.
test.ii:1081: Please submit a full bug report.
test.ii:1081: See <URL:http://www.gnu.org/software/gcc/faq.html#bugreport> for instructions.
I hope this report is helpful to you. Regards,
Jochen
=== file "test.ii" follows ========================================
template<class T>
class Owner {
public:
Owner() : p_(0) { }
Owner(T *p) : p_(p) { }
~Owner();
void operator=(T *p) {
if (p_) del();
p_ = p;
}
operator int() { return p_ != 0; }
T *pointer() { return p_; }
T *operator->() { return p_; }
T &operator*() { return *p_; }
void swap(Owner<T> &x) {
T *tem = p_;
p_ = x.p_;
x.p_ = tem;
}
T *extract() {
T *tem = p_;
p_ = 0;
return tem;
}
void clear() {
if (p_) {
del();
p_ = 0;
}
}
private:
Owner( Owner<T> &);
void operator=( Owner<T> &o);
void del();
T *p_;
};
template<class T>
Owner<T>::~Owner()
{
if (p_)
delete p_;
}
template<class T>
void Owner<T>::del()
{
delete p_;
}
template<class T>
class CopyOwner : public Owner<T> {
public:
CopyOwner() { }
CopyOwner(T *p) : Owner<T>(p) { }
CopyOwner( CopyOwner<T> &);
void operator=( CopyOwner<T> &o);
void operator=(T *p) { Owner<T>::operator=(p); }
};
template<class T>
CopyOwner<T>::CopyOwner( CopyOwner<T> &o)
: Owner<T>(o.pointer() ? o.pointer()->copy() : 0)
{
}
template<class T>
void CopyOwner<T>::operator=( CopyOwner<T> &o)
{
Owner<T>::operator=(o.pointer() ? o.pointer()->copy() : 0);
}
typedef int ptrdiff_t;
typedef unsigned int size_t;
typedef unsigned int wint_t;
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 ();
}
}
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();
inline void *operator new(size_t, void *place) throw() { return place; }
inline void *operator new[](size_t, void *place) throw() { return place; }
}
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]; }
iterator begin() { return ptr_; }
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_;
};
extern "C" {
extern void * memcpy (void * __restrict __dest,
__const void * __restrict __src, size_t __n) throw () ;
extern void * memmove (void * __dest, __const void * __src,
size_t __n) throw () ;
extern void * memset (void * __s, int __c, size_t __n) throw () ;
extern int memcmp (__const void * __s1, __const void * __s2,
size_t __n) throw () ;
extern void * memchr (__const void * __s, int __c, size_t __n) throw () ;
extern char *strcpy (char *__restrict __dest,
__const char *__restrict __src) throw () ;
extern char *strncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n) throw () ;
extern char *strcat (char *__restrict __dest,
__const char *__restrict __src) throw () ;
extern char *strncat (char *__restrict __dest,
__const char *__restrict __src, size_t __n) throw () ;
extern int strcmp (__const char *__s1, __const char *__s2) throw () ;
extern int strncmp (__const char *__s1, __const char *__s2, size_t __n) throw () ;
extern int strcoll (__const char *__s1, __const char *__s2) throw () ;
extern size_t strxfrm (char *__restrict __dest,
__const char *__restrict __src, size_t __n) throw () ;
extern char *strchr (__const char *__s, int __c) throw () ;
extern char *strrchr (__const char *__s, int __c) throw () ;
extern size_t strcspn (__const char *__s, __const char *__reject) throw () ;
extern size_t strspn (__const char *__s, __const char *__accept) throw () ;
extern char *strpbrk (__const char *__s, __const char *__accept) throw () ;
extern char *strstr (__const char *__haystack, __const char *__needle) throw () ;
extern char *strtok (char *__restrict __s,
__const char *__restrict __delim) throw () ;
extern char *__strtok_r (char *__restrict __s,
__const char *__restrict __delim,
char **__restrict __save_ptr) throw () ;
extern size_t strlen (__const char *__s) throw () ;
extern char *strerror (int __errnum) throw () ;
extern void __bzero (void * __s, size_t __n) throw () ;
}
template<class T>
Vector<T>::~Vector()
{
if (ptr_) {
erase(ptr_, ptr_ + size_);
::operator delete((void *)ptr_);
}
}
template<class T>
Vector<T>::Vector( Vector<T> &v)
: ptr_(0), size_(0), alloc_(0)
{
insert(ptr_ + size_, v.ptr_, v.ptr_ + v.size_);
}
template<class T>
Vector<T>::Vector(size_t n, T &t)
: ptr_(0), size_(0), alloc_(0)
{
insert(ptr_ + size_, n, t);
}
template<class T>
Vector<T> &Vector<T>::operator=( Vector<T> &v)
{
if (&v != this) {
size_t n = v.size_;
if (n > size_) {
n = size_;
insert(ptr_ + size_, v.ptr_ + size_, v.ptr_ + v.size_);
}
else if (n < size_)
erase(ptr_ + n, ptr_ + size_);
while (n-- > 0)
ptr_[n] = v.ptr_[n];
}
return *this;
}
template<class T>
void Vector<T>::assign(size_t n, T &t)
{
size_t sz = n;
if (n > size_) {
sz = size_;
insert(ptr_ + size_, n - size_, t);
}
else if (n < size_)
erase(ptr_ + n, ptr_ + size_);
while (sz-- > 0)
ptr_[sz] = t;
}
template<class T>
void Vector<T>::insert( T *p, size_t n, T &t)
{
size_t i = p - ptr_;
reserve(size_ + n);
if (i != size_)
memmove(ptr_ + i + n, ptr_ + i, (size_ - i)*sizeof(T));
for (T *pp = ptr_ + i; n-- > 0; pp++) {
(void)new (pp) T(t);
size_++;
}
}
template<class T>
void Vector<T>::insert( T *p, T *q1, T *q2)
{
size_t i = p - ptr_;
size_t n = q2 - q1;
reserve(size_ + n);
if (i != size_)
memmove(ptr_ + i + n, ptr_ + i, (size_ - i)*sizeof(T));
for (T *pp = ptr_ + i; q1 != q2; q1++, pp++) {
(void)new (pp) T(*q1);
size_++;
}
}
template<class T>
void Vector<T>::swap(Vector<T> &v)
{
{
T *tem = ptr_;
ptr_ = v.ptr_;
v.ptr_ = tem;
}
{
size_t tem = size_;
size_ = v.size_;
v.size_ = tem;
}
{
size_t tem = alloc_;
alloc_ = v.alloc_;
v.alloc_ = tem;
}
}
template<class T>
void Vector<T>::append(size_t n)
{
reserve(size_ + n);
while (n-- > 0)
(void)new (ptr_ + size_++) T;
}
template<class T>
T *Vector<T>::erase( T *p1, T *p2)
{
typedef T X;
for ( T *p = p1; p != p2; p++)
((X *)p)->~X();
if (p2 != ptr_ + size_)
memmove((T *)p1, p2, (( T *)(ptr_ + size_) - p2)*sizeof(T));
size_ -= p2 - p1;
return (T *)p1;
}
template<class T>
void Vector<T>::reserve1(size_t size)
{
size_t newAlloc = alloc_*2;
if (size > newAlloc)
newAlloc += size;
void *p = ::operator new(newAlloc * sizeof(T));
alloc_ = newAlloc;
if (ptr_) {
memcpy(p, ptr_, size_*sizeof(T));
::operator delete((void *)ptr_);
}
ptr_ = (T *)p;
}
typedef bool Boolean;
typedef char PackedBoolean;
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_;
};
extern "C" {
typedef struct
{
int quot;
int rem;
} div_t;
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
extern size_t __ctype_get_mb_cur_max (void) throw () ;
extern double atof (__const char *__nptr) throw () ;
extern int atoi (__const char *__nptr) throw () ;
extern long int atol (__const char *__nptr) throw () ;
extern double strtod (__const char *__restrict __nptr,
char **__restrict __endptr) throw () ;
extern long int strtol (__const char *__restrict __nptr,
char **__restrict __endptr, int __base) throw () ;
extern unsigned long int strtoul (__const char *__restrict __nptr,
char **__restrict __endptr,
int __base) throw () ;
extern double __strtod_internal (__const char *__restrict __nptr,
char **__restrict __endptr,
int __group) throw () ;
extern float __strtof_internal (__const char *__restrict __nptr,
char **__restrict __endptr, int __group) throw () ;
extern long double __strtold_internal (__const char *
__restrict __nptr,
char **__restrict __endptr,
int __group) throw () ;
extern long int __strtol_internal (__const char *__restrict __nptr,
char **__restrict __endptr,
int __base, int __group) throw () ;
extern unsigned long int __strtoul_internal (__const char *
__restrict __nptr,
char **__restrict __endptr,
int __base, int __group) throw () ;
__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr,
char **__restrict __endptr,
int __base, int __group) throw () ;
__extension__
extern unsigned long long int __strtoull_internal (__const char *
__restrict __nptr,
char **
__restrict __endptr,
int __base,
int __group) throw () ;
extern __inline double
strtod (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
strtol (__const char *__restrict __nptr, char **__restrict __endptr,
int __base) throw ()
{
return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
strtoul (__const char *__restrict __nptr, char **__restrict __endptr,
int __base) throw ()
{
return __strtoul_internal (__nptr, __endptr, __base, 0);
}
extern __inline double
atof (__const char *__nptr) throw ()
{
return strtod (__nptr, (char **) __null );
}
extern __inline int
atoi (__const char *__nptr) throw ()
{
return (int) strtol (__nptr, (char **) __null , 10);
}
extern __inline long int
atol (__const char *__nptr) throw ()
{
return strtol (__nptr, (char **) __null , 10);
}
extern int rand (void) throw () ;
extern void srand (unsigned int __seed) throw () ;
extern void * malloc (size_t __size) throw () ;
extern void * calloc (size_t __nmemb, size_t __size) throw () ;
extern void * realloc (void * __ptr, size_t __size) throw () ;
extern void free (void * __ptr) throw () ;
extern void abort (void) throw () __attribute__ ((__noreturn__));
extern int atexit (void (*__func) (void)) throw () ;
extern void exit (int __status) throw () __attribute__ ((__noreturn__));
extern char *getenv (__const char *__name) throw () ;
extern char *__secure_getenv (__const char *__name) throw () ;
extern int system (__const char *__command) throw () ;
typedef int (*__compar_fn_t) (__const void * , __const void * ) ;
extern void * bsearch (__const void * __key, __const void * __base,
size_t __nmemb, size_t __size,
__compar_fn_t __compar) ;
extern void qsort (void * __base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) ;
extern int abs (int __x) throw () __attribute__ ((__const__));
extern long int labs (long int __x) throw () __attribute__ ((__const__));
extern div_t div (int __numer, int __denom) throw () __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom) throw ()
__attribute__ ((__const__));
extern int mblen (__const char *__s, size_t __n) throw () ;
extern int mbtowc (wchar_t *__restrict __pwc,
__const char *__restrict __s, size_t __n) throw () ;
extern int wctomb (char *__s, wchar_t __wchar) throw () ;
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
__const char *__restrict __s, size_t __n) throw () ;
extern size_t wcstombs (char *__restrict __s,
__const wchar_t *__restrict __pwcs, size_t __n) throw () ;
}
template<class T>
ISet<T>::ISet()
{
}
template<class T>
ISet<T>::~ISet()
{
}
template<class T>
ISet<T>::ISet( T *v, size_t n)
{
for (size_t i = 0; i < n; i++)
add(v[i]);
}
template<class T>
Boolean ISet<T>::contains(T x)
{
for (size_t i = 0; i < r_.size(); i++)
if (r_[i].max >= x)
return r_[i].min <= x ? 1 : 0;
return 0;
}
template<class T>
void ISet<T>::addRange(T min, T max)
{
size_t i;
if (min == 0)
i = 0;
else {
for (i = r_.size(); i > 0 && min - 1 <= r_[i - 1].max; i--)
;
}
if (i < r_.size() && (r_[i].min == 0 || max >= r_[i].min - 1)) {
if (min < r_[i].min)
r_[i].min = min;
if (max > r_[i].max) {
r_[i].max = max;
size_t j;
for (j = i + 1; j < r_.size() && r_[i].max >= r_[j].min - 1; j++)
r_[i].max = r_[j].max;
if (j > i + 1) {
for (size_t k = j; k < r_.size(); k++)
r_[k - (j - i - 1)] = r_[k];
r_.resize(r_.size() - (j - i - 1));
}
}
}
else {
r_.resize(r_.size() + 1);
for (size_t j = r_.size() - 1; j > i; j--)
r_[j] = r_[j - 1];
r_[i].max = max;
r_[i].min = min;
}
}
template<class T>
void ISet<T>::remove(T c)
{
for (size_t i = 0; i < r_.size(); i++)
if (r_[i].max >= c) {
if (r_[i].min <= c) {
if (r_[i].min == r_[i].max) {
while (++i < r_.size())
r_[i - 1] = r_[i];
r_.resize(r_.size() - 1);
}
else if (c == r_[i].min)
r_[i].min += 1;
else if (c == r_[i].max)
r_[i].max -= 1;
else {
r_.resize(r_.size() + 1);
for (size_t j = r_.size() - 2; j > i; j--)
r_[j + 1] = r_[j];
r_[i + 1].max = r_[i].max;
r_[i + 1].min = c + 1;
r_[i].max = c - 1;
}
}
break;
}
}
template<class T>
void ISet<T>::check()
{
for (size_t i = 0; i < r_.size(); i++) {
if (r_[i].min > r_[i].max)
abort();
if (i > 0 && r_[i].min - 1 <= r_[i - 1].max)
abort();
}
}
template<class T>
void ISet<T>::clear()
{
r_.resize(0);
}
typedef unsigned int Unsigned32;
typedef Unsigned32 Number;
typedef Unsigned32 Offset;
typedef Unsigned32 Index;
typedef unsigned short Char;
typedef int Xchar;
typedef Unsigned32 UnivChar;
typedef Unsigned32 WideChar;
typedef Unsigned32 SyntaxChar;
typedef unsigned short CharClassIndex;
typedef unsigned Token;
typedef unsigned short EquivCode;
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_;
};
template<class From, class To>
RangeMap<From, To>::RangeMap()
{
}
template<class From, class To>
Boolean RangeMap<From, To>::map(From from, To &to, From &alsoMax)
{
for (size_t i = 0; i < ranges_.size(); i++) {
RangeMapRange<From,To> &r = ranges_[i];
if (r.fromMin <= from && from <= r.fromMax) {
to = r.toMin + (from - r.fromMin);
alsoMax = r.fromMax;
return 1;
}
if (r.fromMin > from) {
alsoMax = r.fromMin - 1;
return 0;
}
}
alsoMax = From(-1);
return 0;
}
typedef ISet<WideChar> RangeMap_dummy;
template<class From, class To>
unsigned RangeMap<From, To>::inverseMap(To to, From &from,
ISet<WideChar> &fromSet,
WideChar &count)
{
unsigned ret = 0;
count = WideChar(-1);
for (size_t i = 0; i < ranges_.size(); i++) {
RangeMapRange<From,To> &r = ranges_[i];
if (r.toMin <= to && to <= r.toMin + (r.fromMax - r.fromMin)) {
From n = r.fromMin + (to - r.toMin);
WideChar thisCount = r.fromMax - n + 1;
if (ret > 1) {
fromSet.add(n);
if (thisCount < count)
count = thisCount;
}
else if (ret == 1) {
fromSet.add(from);
fromSet.add(n);
ret = 2;
if (thisCount < count)
count = thisCount;
}
else {
count = thisCount;
from = n;
ret = 1;
}
}
else if (ret == 0 && r.toMin > to && (r.toMin - to < count))
count = r.toMin - to;
}
return ret;
}
template<class From, class To>
RangeMapIter<From, To>::RangeMapIter( RangeMap<From, To> &map)
: count_(map.ranges_.size()), ptr_(map.ranges_.begin())
{
}
template<class From, class To>
void RangeMap<From, To>::addRange(From fromMin, From fromMax, To toMin)
{
size_t i;
for (i = ranges_.size(); i > 0; i--)
if (fromMin > ranges_[i - 1].fromMax)
break;
Boolean coalesced = 0;
if (i > 0
&& ranges_[i - 1].fromMax + 1 == fromMin
&& ranges_[i - 1].toMin + (fromMin - ranges_[i - 1].fromMin) == toMin) {
ranges_[i - 1].fromMax = fromMax;
i--;
coalesced = 1;
}
else if (i < ranges_.size() && fromMax >= ranges_[i].fromMin - 1) {
if (fromMin <= ranges_[i].fromMin) {
if (toMin + (ranges_[i].fromMin - fromMin) == ranges_[i].toMin) {
ranges_[i].fromMin = fromMin;
if (fromMax <= ranges_[i].fromMax)
return;
ranges_[i].fromMax = fromMax;
coalesced = 1;
}
}
else {
if (ranges_[i].toMin + (fromMin - ranges_[i].fromMin) == toMin) {
if (fromMax < ranges_[i].fromMax)
return;
ranges_[i].fromMax = fromMax;
coalesced = 1;
}
}
}
if (!coalesced) {
ranges_.resize(ranges_.size() + 1);
for (size_t j = ranges_.size() - 1; j > i; j--)
ranges_[j] = ranges_[j - 1];
ranges_[i].fromMin = fromMin;
ranges_[i].fromMax = fromMax;
ranges_[i].toMin = toMin;
}
size_t j;
for (j = i + 1; j < ranges_.size(); j++) {
if (fromMax < ranges_[j].fromMax) {
if (fromMax >= ranges_[j].fromMin)
ranges_[j].fromMin = fromMax + 1;
break;
}
}
if (j > i + 1) {
size_t count = ranges_.size() - j;
for (size_t k = 0; k < count; k++)
ranges_[i + 1 + count] = ranges_[j + count];
ranges_.resize(ranges_.size() - (j - (i + 1)));
}
}
template<class T>
class Ptr {
public:
Ptr() : ptr_(0) { }
Ptr(T *ptr);
~Ptr();
Ptr( Ptr<T> &);
Ptr<T> &operator=( Ptr<T> &);
Ptr<T> &operator=(T *);
T *pointer() { return ptr_; }
T *operator->() { return ptr_; }
T &operator*() { return *ptr_; }
void swap(Ptr<T> &p) {
T *tem = p.ptr_;
p.ptr_ = ptr_;
ptr_ = tem;
}
Boolean isNull() { return ptr_ == 0; }
void clear();
Boolean operator==( Ptr<T> &p) {
return ptr_ == p.ptr_;
}
Boolean operator!=( Ptr<T> &p) {
return ptr_ != p.ptr_;
}
Boolean operator==( T *p) {
return ptr_ == p;
}
Boolean operator!=( T *p) {
return ptr_ != p;
}
private:
T *ptr_;
};
template<class T>
class ConstPtr : private Ptr<T> {
public:
ConstPtr() { }
ConstPtr(T *ptr) : Ptr<T>(ptr) { }
ConstPtr( Ptr<T> &p) : Ptr<T>(p) { }
ConstPtr( ConstPtr<T> &p) : Ptr<T>(p) { }
ConstPtr<T> &operator=( Ptr<T> &p) {
Ptr<T>::operator=(p); return *this;
}
ConstPtr<T> &operator=( ConstPtr<T> &p) {
Ptr<T>::operator=(p); return *this;
}
ConstPtr<T> &operator=(T *p) {
Ptr<T>::operator=(p); return *this;
}
T *pointer() { return Ptr<T>::pointer(); }
T *operator->() { return Ptr<T>::pointer(); }
T &operator*() { return *Ptr<T>::pointer(); }
void swap(ConstPtr<T> &p) { Ptr<T>::swap(p); }
Ptr<T>::isNull;
Ptr<T>::clear;
Boolean operator==( Ptr<T> &p) { return Ptr<T>::operator==(p); }
Boolean operator!=( Ptr<T> &p) { return Ptr<T>::operator!=(p); }
Boolean operator==( ConstPtr<T> &p) {
return Ptr<T>::operator==(p);
}
Boolean operator!=( ConstPtr<T> &p) {
return Ptr<T>::operator!=(p);
}
};
template<class T>
Ptr<T>::Ptr(T *ptr) : ptr_(ptr)
{
if (ptr_)
ptr_->ref();
}
template<class T>
Ptr<T>::~Ptr()
{
if (ptr_) {
if (ptr_->unref())
delete ptr_;
ptr_ = 0;
}
}
template<class T>
Ptr<T>::Ptr( Ptr<T> &p)
: ptr_(p.ptr_)
{
if (p.ptr_)
p.ptr_->ref();
}
template<class T>
Ptr<T> &Ptr<T>::operator=( Ptr<T> &p)
{
if (p.ptr_)
p.ptr_->ref();
if (ptr_ && ptr_->unref())
delete ptr_;
ptr_ = p.ptr_;
return *this;
}
template<class T>
Ptr<T> &Ptr<T>::operator=(T *p)
{
if (p)
p->ref();
if (ptr_ && ptr_->unref())
delete ptr_;
ptr_ = p;
return *this;
}
template<class T>
void Ptr<T>::clear()
{
if (ptr_) {
if (ptr_->unref())
delete ptr_;
ptr_ = 0;
}
}
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]; }
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_;
};
template<class T>
String<T>::String( T *ptr, size_t length)
: length_(length), alloc_(length)
{
if (length) {
ptr_ = new T[length];
memcpy(ptr_, ptr, length*sizeof(T));
}
else
ptr_ = 0;
}
template<class T>
String<T>::String()
: ptr_(0), length_(0), alloc_(0)
{
}
template<class T>
String<T>::String( String<T> &s)
: length_(s.length_), alloc_(s.length_)
{
if (length_) {
ptr_ = new T[length_];
memcpy(ptr_, s.ptr_, length_*sizeof(T));
}
else
ptr_ = 0;
}
template<class T>
String<T> &String<T>::operator=( String<T> &s)
{
if (&s != this) {
if (s.length_ > alloc_) {
T *oldPtr = ptr_;
ptr_ = new T[alloc_ = s.length_];
if (oldPtr)
delete [] oldPtr;
}
memcpy(ptr_, s.ptr_, s.length_*sizeof(T));
length_ = s.length_;
}
return *this;
}
template<class T>
String<T> &String<T>::insert(size_t i, String<T> &s)
{
if (length_ + s.length_ > alloc_)
grow(s.length_);
for (size_t n = length_ - i; n > 0; n--)
ptr_[i + n - 1 + s.length_] = ptr_[i + n - 1];
length_ += s.length_;
memcpy(ptr_ + i, s.ptr_, s.length_*sizeof(T));
return *this;
}
template<class T>
String<T> &String<T>::append( T *p, size_t length)
{
if (length_ + length > alloc_)
grow(length);
memcpy(ptr_ + length_, p, length*sizeof(T));
length_ += length;
return *this;
}
template<class T>
void String<T>::grow(size_t n)
{
size_t newAlloc = alloc_;
if (alloc_ < n)
newAlloc += n + 16;
else
newAlloc += alloc_;
T *s = new T[newAlloc];
memcpy(s, ptr_, length_*sizeof(T));
delete [] ptr_;
ptr_ = s;
alloc_ = newAlloc;
}
template<class T>
void String<T>::swap(String<T> &to)
{
{
T *tem = to.ptr_;
to.ptr_ = ptr_;
ptr_ = tem;
}
{
size_t tem = to.length_;
to.length_ = length_;
length_ = tem;
}
{
size_t tem = to.alloc_;
to.alloc_ = alloc_;
alloc_ = tem;
}
}
template<class T>
String<T> &String<T>::assign( T *p, size_t n)
{
if (alloc_ < n) {
T *oldPtr = ptr_;
ptr_ = new T[n];
alloc_ = n;
if (oldPtr)
delete [] oldPtr;
}
length_ = n;
for(T *to = ptr_; n > 0; n--, to++, p++)
*to = *p;
return *this;
}
template<class T>
void String<T>::resize(size_t n)
{
if (alloc_ < n) {
T *oldPtr = ptr_;
ptr_ = new T[n];
alloc_ = n;
if (length_ > 0) {
memcpy(ptr_, oldPtr, length_*sizeof(T));
delete [] oldPtr;
}
}
length_ = n;
}
typedef String<Char> StringC;
template<class T>
class ISetIter {
public:
ISetIter( ISet<T> &s) : p_(&s), i_(0) { }
int next(T &min, T &max)
{
if (i_ < p_->r_.size()) {
min = p_->r_[i_].min;
max = p_->r_[i_].max;
i_++;
return 1;
}
else
return 0;
}
private:
ISet<T> *p_;
size_t i_;
};
class Resource {
public:
Resource();
Resource( Resource &);
int unref();
void ref();
int count() ;
private:
int count_;
};
inline
Resource::Resource()
: count_(0)
{
}
inline
Resource::Resource( Resource &)
: count_(0)
{
}
inline
int Resource::count()
{
return count_;
}
inline
int Resource::unref()
{
return --count_ <= 0;
}
inline
void Resource::ref()
{
++count_;
}
Char charMax = Char(-1);
WideChar wideCharMax = WideChar(-1);
UnivChar univCharMax = UnivChar(-1);
SyntaxChar syntaxCharMax = SyntaxChar(-1);
template<class T>
class SharedXcharMap : public Resource {
public:
SharedXcharMap();
SharedXcharMap(T defaultValue);
T *ptr() { return v + 1; }
private:
T v[2 + charMax];
};
template<class T>
class XcharMap {
public:
XcharMap();
XcharMap(T defaultValue);
T operator[](Xchar c) { return ptr_[c]; }
void setRange(Char min, Char max, T val);
void setChar(Char c, T val) { ptr_[c] = val; }
void setEe(T val) { ptr_[-1] = val; }
void clear() { ptr_ = 0; sharedMap_.clear(); }
private:
T *ptr_;
Ptr<SharedXcharMap<T> > sharedMap_;
};
template<class T>
SharedXcharMap<T>::SharedXcharMap()
{
}
template<class T>
SharedXcharMap<T>::SharedXcharMap(T defaultValue)
{
for (size_t i = 0; i < sizeof(v)/sizeof(v[0]); i++)
v[i] = defaultValue;
}
template<class T>
XcharMap<T>::XcharMap()
: ptr_(0)
{
}
template<class T>
XcharMap<T>::XcharMap(T defaultValue)
: sharedMap_(new SharedXcharMap<T>(defaultValue))
{
ptr_ = sharedMap_->ptr();
}
template<class T>
void XcharMap<T>::setRange(Char min, Char max, T val)
{
if (min <= max) {
do {
ptr_[min] = val;
} while (min++ != max);
}
}
template<class T>
class SubstTable {
public:
SubstTable();
void addSubst(T from, T to);
void subst(T &c) { if (table_.size() > 0) c = table_[c]; }
void subst(String<T> &) ;
T operator[](T c) { return table_.size() > 0 ? table_[c] : c; }
String<T> inverse(T) ;
void inverseTable(SubstTable<T> &) ;
private:
String<T> table_;
String<T> pairs_;
Boolean pairsValid_;
};
template<class T>
SubstTable<T>::SubstTable()
: pairsValid_(1)
{
}
template<class T>
void SubstTable<T>::addSubst(T from, T to)
{
if (table_.size() == 0) {
table_.resize(T(-1) + 1);
for (int i = 0; i < T(-1) + 1; i++)
table_[i] = i;
}
if (table_[from] != to)
pairsValid_ = 0;
table_[from] = to;
}
template<class T>
String<T> SubstTable<T>::inverse(T ch)
{
if (!pairsValid_) {
T *p = table_.data();
size_t length = table_.size();
for (size_t i = 0; i < length; i++)
if (p[i] != i) {
((SubstTable<T> *)this)->pairs_ += T(i);
((SubstTable<T> *)this)->pairs_ += p[i];
}
((SubstTable<T> *)this)->pairsValid_ = 1;
}
T *p = pairs_.data();
if (!p)
return String<T>(&ch, 1);
String<T> result;
if (table_[ch] == ch)
result += ch;
for (size_t n = pairs_.size(); n > 0; n -= 2, p += 2)
if (p[1] == ch)
result += p[0];
return result;
}
template<class T>
void SubstTable<T>::inverseTable(SubstTable<T> &inv)
{
if (table_.size() == 0) {
inv.table_.resize(0);
inv.pairs_.resize(0);
inv.pairsValid_ = 1;
}
else {
if (inv.table_.size() == 0)
inv.table_.resize(T(-1) + 1);
int i;
for (i = 0; i < T(-1) + 1; i++)
inv.table_[i] = i;
inv.pairs_.resize(0);
inv.pairsValid_ = 0;
for (i = 0; i < T(-1) + 1; i++)
if (table_[i] != i)
inv.table_[table_[i]] = i;
}
}
template<class T>
void SubstTable<T>::subst(String<T> &str)
{
for (size_t i = 0; i < str.size(); i++)
subst(str[i]);
}
template<class T>
class StringResource : public String<T>, public Resource {
public:
StringResource( String<T> &s) : String<T>(s) { }
};
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>
inline
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>
inline
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;
}
}
template<class T>
CharMap<T>::CharMap()
{
}
template<class T>
CharMap<T>::CharMap(T dflt)
{
for (size_t i = 0; i < (1 << CharMapBits::level1); i++)
pages_[i].value = dflt;
}
template<class T>
void CharMap<T>::setAll(T val)
{
for (size_t i = 0; i < (1 << CharMapBits::level1); i++) {
pages_[i].value = val;
delete [] pages_[i].values;
pages_[i].values = 0;
}
}
template<class T>
void CharMap<T>::swap(CharMap<T> &map)
{
for (size_t i = 0; i < (1 << CharMapBits::level1); i++)
pages_[i].swap(map.pages_[i]);
}
template<class T>
void CharMap<T>::setChar(Char c, T val)
{
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)
column.values[c & ((1 << CharMapBits::level3) - 1)] = val;
else if (val != column.value) {
column.values = new T[1 << CharMapBits::level3];
for (size_t i = 0; i < (1 << CharMapBits::level3); i++)
column.values[i] = column.value;
column.values[c & ((1 << CharMapBits::level3) - 1)] = val;
}
}
else if (val != pg.value) {
pg.values = new CharMapColumn<T>[1 << CharMapBits::level2];
for (size_t i = 0; i < (1 << CharMapBits::level2); i++)
pg.values[i].value = pg.value;
CharMapColumn<T> &column = pg.values[(c >> CharMapBits::level3) & ((1 << CharMapBits::level2) - 1)];
column.values = new T[1 << CharMapBits::level3];
for (size_t i = 0; i < (1 << CharMapBits::level3); i++)
column.values[i] = column.value;
column.values[c & ((1 << CharMapBits::level3) - 1)] = val;
}
}
template<class T>
void CharMap<T>::setRange(Char from, Char to, T val)
{
do {
if ((from & ((1 << CharMapBits::level3) - 1)) == 0
&& to - from >= (1 << CharMapBits::level3) - 1) {
if ((from & ((1 << (CharMapBits::level2 + CharMapBits::level3)) - 1)) == 0
&& to - from >= (1 << (CharMapBits::level2 + CharMapBits::level3)) - 1) {
CharMapPage<T> &pg = pages_[from >> (CharMapBits::level2 + CharMapBits::level3)];
pg.value = val;
delete pg.values;
pg.values = 0;
from += (1 << (CharMapBits::level2 + CharMapBits::level3)) - 1;
}
else {
CharMapPage<T> &pg = pages_[from >> (CharMapBits::level2 + CharMapBits::level3)];
if (pg.values) {
CharMapColumn<T> &column = pg.values[(from >> CharMapBits::level3) & ((1 << CharMapBits::level2) - 1)];
column.value = val;
delete column.values;
column.values = 0;
}
else if (val != pg.value) {
pg.values = new CharMapColumn<T>[1 << CharMapBits::level2];
for (size_t i = 0; i < (1 << CharMapBits::level2); i++)
pg.values[i].value = pg.value;
CharMapColumn<T> &column = pg.values[(from >> CharMapBits::level3) & ((1 << CharMapBits::level2) - 1)];
column.value = val;
}
from += (1 << CharMapBits::level2) - 1;
}
}
else
setChar(from, val);
} while (from++ != to);
}
template<class T>
CharMapPage<T>::CharMapPage()
: values(0)
{
}
template<class T>
CharMapPage<T>::CharMapPage( CharMapPage<T> &pg)
{
if (pg.values) {
values = new CharMapColumn<T>[1 << CharMapBits::level2];
for (size_t i = 0; i < (1 << CharMapBits::level2); i++)
values[i] = pg.values[i];
}
else {
value = pg.value;
values = 0;
}
}
template<class T>
void CharMapPage<T>::operator=( CharMapPage<T> &pg)
{
if (pg.values) {
if (!values)
values = new CharMapColumn<T>[1 << CharMapBits::level2];
for (size_t i = 0; i < (1 << CharMapBits::level2); i++)
values[i] = pg.values[i];
}
else {
if (values) {
delete [] values;
values = 0;
}
value = pg.value;
}
}
template<class T>
CharMapPage<T>::~CharMapPage()
{
delete [] values;
}
template<class T>
void CharMapPage<T>::swap(CharMapPage<T> &pg)
{
{
CharMapColumn<T> *tem = values;
values = pg.values;
pg.values = tem;
}
{
T tem(value);
value = pg.value;
pg.value = tem;
}
}
template<class T>
CharMapColumn<T>::CharMapColumn()
: values(0)
{
}
template<class T>
CharMapColumn<T>::CharMapColumn( CharMapColumn<T> &col)
{
if (col.values) {
values = new T[1 << CharMapBits::level3];
for (size_t i = 0; i < (1 << CharMapBits::level3); i++)
values[i] = col.values[i];
}
else {
values = 0;
value = col.value;
}
}
template<class T>
void CharMapColumn<T>::operator=( CharMapColumn<T> &col)
{
if (col.values) {
if (!values)
values = new T[1 << CharMapBits::level3];
for (size_t i = 0; i < (1 << CharMapBits::level3); i++)
values[i] = col.values[i];
}
else {
if (values) {
delete [] values;
values = 0;
}
value = col.value;
}
}
template<class T>
CharMapColumn<T>::~CharMapColumn()
{
delete [] values;
}
class TypeId {
public:
TypeId( void * *bases) : bases_(bases) { }
int isA(TypeId ti) ;
int canCast(TypeId to, TypeId from) ;
int operator==(TypeId ti) { return bases_ == ti.bases_; }
int operator!=(TypeId ti) { return bases_ != ti.bases_; }
private:
void * *bases_;
};
class ExternalInfo;
class EntityOrigin;
class InputSourceOrigin;
class Entity;
class EntityDecl;
class Location;
class Markup;
class Text;
class NamedCharRef;
class Origin : public Resource {
public:
virtual ~Origin();
virtual EntityOrigin *asEntityOrigin() ;
virtual InputSourceOrigin *asInputSourceOrigin() ;
virtual Location &parent() = 0;
virtual Index refLength() ;
virtual Boolean origChars( Char *&) ;
virtual Boolean inBracketedTextOpenDelim() ;
virtual Boolean inBracketedTextCloseDelim() ;
virtual Boolean isNumericCharRef( Markup *&markup) ;
virtual Boolean isNamedCharRef(Index ind, NamedCharRef &ref) ;
virtual EntityDecl *entityDecl() ;
virtual Boolean defLocation(Offset off, Origin *&, Index &) ;
virtual Markup *markup() ;
virtual Entity *entity() ;
virtual ExternalInfo *externalInfo() ;
virtual Offset startOffset(Index ind) ;
StringC *entityName() ;
};
class ProxyOrigin : public Origin {
public:
ProxyOrigin( Origin *origin);
EntityOrigin *asEntityOrigin() ;
InputSourceOrigin *asInputSourceOrigin() ;
Location &parent() ;
Index refLength() ;
Boolean origChars( Char *&) ;
Boolean inBracketedTextOpenDelim() ;
Boolean inBracketedTextCloseDelim() ;
Boolean isNumericCharRef( Markup *&markup) ;
Boolean isNamedCharRef(Index ind, NamedCharRef &ref) ;
EntityDecl *entityDecl() ;
Boolean defLocation(Offset off, Origin *&, Index &) ;
Markup *markup() ;
Entity *entity() ;
ExternalInfo *externalInfo() ;
Offset startOffset(Index ind) ;
private:
Origin *origin_;
};
class Location {
public:
Location();
Location(Origin *, Index);
Location(ConstPtr<Origin>, Index);
void operator+=(Index i) { index_ += i; }
void operator-=(Index i) { index_ -= i; }
Index index() { return index_; }
ConstPtr<Origin> &origin() { return origin_; }
void clear() { origin_.clear(); }
void swap(Location &to) {
origin_.swap(to.origin_);
Index tem = to.index_;
to.index_ = index_;
index_ = tem;
}
private:
ConstPtr<Origin> origin_;
Index index_;
};
class ExternalInfo {
public: virtual TypeId dynamicType() ; static inline TypeId staticType() { return TypeId(RTTI_bases_); } protected: static void *RTTI_bases_[]; private:
public:
virtual ~ExternalInfo();
};
class NamedCharRef {
public:
enum RefEndType {
endOmitted,
endRE,
endRefc
};
NamedCharRef();
NamedCharRef(Index, RefEndType, StringC &);
Index refStartIndex() ;
RefEndType refEndType() ;
StringC &origName() ;
void set(Index, RefEndType, Char *, size_t);
private:
Index refStartIndex_;
RefEndType refEndType_;
StringC origName_;
};
struct InputSourceOriginNamedCharRef {
Index replacementIndex;
size_t origNameOffset;
Index refStartIndex;
NamedCharRef::RefEndType refEndType;
};
class InputSourceOrigin : public Origin {
public:
virtual void noteCharRef(Index replacementIndex, NamedCharRef &) = 0;
virtual void setExternalInfo(ExternalInfo *) = 0;
virtual InputSourceOrigin *copy() = 0;
static InputSourceOrigin *make();
static InputSourceOrigin *make( Location &refLocation);
};
class BracketOrigin : public Origin {
public:
enum Position { open, close };
BracketOrigin( Location &, Position);
Location &parent() ;
Boolean inBracketedTextOpenDelim() ;
Boolean inBracketedTextCloseDelim() ;
private:
Position pos_;
Location loc_;
};
class ReplacementOrigin : public Origin {
public:
ReplacementOrigin( Location &, Char origChar);
Location &parent() ;
Boolean origChars( Char *&) ;
private:
Location loc_;
Char origChar_;
};
class MultiReplacementOrigin : public Origin {
public:
MultiReplacementOrigin( Location &, StringC &origChars);
Location &parent() ;
Boolean origChars( Char *&) ;
private:
Location loc_;
StringC origChars_;
};
inline
Index NamedCharRef::refStartIndex()
{
return refStartIndex_;
}
inline
NamedCharRef::RefEndType NamedCharRef::refEndType()
{
return refEndType_;
}
inline
StringC &NamedCharRef::origName()
{
return origName_;
}
class MessageBuilder;
class MessageArg {
public:
MessageArg();
virtual ~MessageArg();
virtual MessageArg *copy() = 0;
virtual void append(MessageBuilder &) = 0;
};
class StringMessageArg : public MessageArg {
public:
StringMessageArg( StringC &);
MessageArg *copy() ;
void append(MessageBuilder &) ;
private:
StringC s_;
};
class NumberMessageArg : public MessageArg {
public:
NumberMessageArg(unsigned long);
MessageArg *copy() ;
void append(MessageBuilder &) ;
private:
unsigned long n_;
};
class OrdinalMessageArg : public MessageArg {
public:
OrdinalMessageArg(unsigned long);
MessageArg *copy() ;
void append(MessageBuilder &) ;
private:
unsigned long n_;
};
class OtherMessageArg : public MessageArg {
public: virtual TypeId dynamicType() ; static inline TypeId staticType() { return TypeId(RTTI_bases_); } protected: static void *RTTI_bases_[]; private:
public:
OtherMessageArg();
void append(MessageBuilder &) ;
};
class MessageFragment {
public:
enum {
libModule = 0,
appModule = 1
};
MessageFragment(unsigned module, unsigned number, char *text = 0);
unsigned module() ;
unsigned number() ;
char *text() ;
private:
unsigned short number_;
unsigned char module_;
protected:
unsigned char spare_;
private:
char *text_;
};
class MessageType : public MessageFragment {
public:
enum Severity {
info,
warning,
quantityError,
idrefError,
error
};
MessageType(Severity, unsigned module, unsigned number,
char *text = 0, char *auxText = 0);
Severity severity() ;
MessageFragment auxFragment() ;
Boolean isError() ;
private:
char *auxText_;
};
class MessageType0 : public MessageType {
public:
MessageType0(Severity, unsigned module, unsigned number, char *text = 0);
};
class MessageType1 : public MessageType {
public:
MessageType1(Severity, unsigned module, unsigned number, char *text = 0);
};
class MessageType2 : public MessageType {
public:
MessageType2(Severity, unsigned module, unsigned number, char *text = 0);
};
class MessageType3 : public MessageType {
public:
MessageType3(Severity, unsigned module, unsigned number, char *text = 0);
};
class MessageType4 : public MessageType {
public:
MessageType4(Severity, unsigned module, unsigned number, char *text = 0);
};
class MessageType5 : public MessageType {
public:
MessageType5(Severity, unsigned module, unsigned number, char *text = 0);
};
class MessageType6 : public MessageType {
public:
MessageType6(Severity, unsigned module, unsigned number, char *text = 0);
};
class MessageType0L : public MessageType {
public:
MessageType0L(Severity, unsigned module, unsigned number, char *text = 0,
char *auxText = 0);
};
class MessageType1L : public MessageType {
public:
MessageType1L(Severity, unsigned module, unsigned number, char *text = 0,
char *auxText = 0);
};
class OpenElementInfo {
public:
OpenElementInfo();
PackedBoolean included;
StringC gi;
StringC matchType;
unsigned matchIndex;
};
class Message {
public:
Message();
Message(int nArgs);
MessageType *type;
Location loc;
Location auxLoc;
Vector<CopyOwner<MessageArg> > args;
Vector<OpenElementInfo> openElementInfo;
void swap(Message &);
Boolean isError() ;
};
class Messenger {
public:
Messenger();
virtual ~Messenger();
void message( MessageType0 &);
void message( MessageType1 &, MessageArg &);
void message( MessageType2 &,
MessageArg &,
MessageArg &);
void message( MessageType3 &,
MessageArg &,
MessageArg &,
MessageArg &);
void message( MessageType4 &,
MessageArg &,
MessageArg &,
MessageArg &,
MessageArg &);
void message( MessageType5 &,
MessageArg &,
MessageArg &,
MessageArg &,
MessageArg &,
MessageArg &);
void message( MessageType6 &,
MessageArg &,
MessageArg &,
MessageArg &,
MessageArg &,
MessageArg &,
MessageArg &);
void message( MessageType0L &, Location &);
void message( MessageType1L &, MessageArg &, Location &);
void setNextLocation( Location &);
virtual void initMessage(Message &);
virtual void dispatchMessage(Message &);
private:
void doInitMessage(Message &);
Boolean haveNextLocation_;
Location nextLocation_;
};
class ForwardingMessenger : public Messenger {
public:
ForwardingMessenger(Messenger &);
void dispatchMessage(Message &);
void initMessage(Message &);
private:
Messenger *to_;
};
class ParentLocationMessenger : public ForwardingMessenger {
public:
ParentLocationMessenger(Messenger &);
void initMessage(Message &);
};
class NullMessenger : public Messenger {
public:
NullMessenger();
void dispatchMessage( Message &);
};
inline
unsigned MessageFragment::module()
{
return module_;
}
inline
unsigned MessageFragment::number()
{
return number_;
}
inline
char *MessageFragment::text()
{
return text_;
}
inline
MessageType::Severity MessageType::severity()
{
return Severity(spare_);
}
inline
MessageFragment MessageType::auxFragment()
{
return MessageFragment(module(),
number() + 1,
auxText_
);
}
inline
Boolean MessageType::isError()
{
return severity() != info && severity() != warning;
}
inline
Boolean Message::isError()
{
return type->isError();
}
class Named {
public:
Named( StringC &name) : name_(name) { }
virtual ~Named() { }
StringC &name() { return name_; }
StringC *namePointer() { return &name_; }
void setName( StringC &name) { name_ = name; }
void swap(Named &to) { name_.swap(to.name_); }
private:
StringC name_;
};
class NamedResource : public Named, public Resource {
public:
NamedResource( StringC &str) : Named(str) { }
};
class Messenger;
class CharsetInfo;
class EntityDecl;
class EntityCatalog : public Resource {
public:
class Syntax {
public:
virtual Boolean namecaseGeneral() = 0;
virtual Boolean namecaseEntity() = 0;
virtual SubstTable<Char> &upperSubstTable() = 0;
virtual StringC &peroDelim() = 0;
};
virtual ~EntityCatalog();
virtual Boolean sgmlDecl( CharsetInfo &,
Messenger &,
StringC &) ;
virtual Boolean lookup( EntityDecl &,
Syntax &,
CharsetInfo &,
Messenger &,
StringC &) ;
virtual Boolean lookupPublic( StringC &,
CharsetInfo &,
Messenger &,
StringC &) ;
virtual Boolean lookupChar( StringC &,
CharsetInfo &,
Messenger &,
UnivChar &) ;
};
class Messenger;
class InputSourceOrigin;
class CharsetInfo;
class InputSource;
class EntityManager : public Resource {
public:
enum { mayRewind = 01, maySetDocCharset = 02 };
virtual ~EntityManager();
virtual Boolean internalCharsetIsDocCharset() = 0;
virtual CharsetInfo &charset() = 0;
virtual InputSource *open( StringC &sysid,
CharsetInfo &docCharset,
InputSourceOrigin *,
unsigned flags,
Messenger &) = 0;
virtual ConstPtr<EntityCatalog>
makeCatalog(StringC &systemId, CharsetInfo &, Messenger &) = 0;
};
template class Ptr<InputSourceOrigin>;
template class ConstPtr<InputSourceOrigin>;
template class Ptr<Origin>;
template class ConstPtr<Origin>;
template class Ptr<SharedXcharMap<unsigned char> >;
template class ConstPtr<SharedXcharMap<unsigned char> >;
template class Ptr<SharedXcharMap<PackedBoolean> >;
template class ConstPtr<SharedXcharMap<PackedBoolean> >;
template class Ptr<SharedXcharMap<EquivCode> >;
template class ConstPtr<SharedXcharMap<EquivCode> >;
template class Ptr<StringResource<Char> >;
template class ConstPtr<StringResource<Char> >;
template class Ptr<NamedResource>;
template class ConstPtr<NamedResource>;
template class Ptr<EntityManager>;
template class ConstPtr<EntityManager>;
template class Ptr<EntityCatalog>;
template class ConstPtr<EntityCatalog>;
template class Owner<MessageArg>;
template class CopyOwner<MessageArg>;
template class String<Char>;
template class Vector<OpenElementInfo>;
template class Vector<CopyOwner<MessageArg> >;
template class SharedXcharMap<unsigned char>;
template class XcharMap<unsigned char>;
template class Vector<RangeMapRange<WideChar,UnivChar> >;
template class RangeMapIter<WideChar,UnivChar>;
template class RangeMap<WideChar,UnivChar>;
template class Vector<InputSourceOriginNamedCharRef>;
template class Vector<StringC>;
template class Vector<String<EquivCode> >;
template class Owner<ExternalInfo>;
template class ISet<Char>;
template class Vector<ISetRange<Char> >;
template class ISet<WideChar>;
template class ISetIter<Char>;
template class ISetIter<WideChar>;
template class Vector<ISetRange<WideChar> >;
template class SubstTable<Char>;
template class SharedXcharMap<PackedBoolean>;
template class SharedXcharMap<unsigned char>;
template class SharedXcharMap<EquivCode>;
template class String<EquivCode>;
template class String<SyntaxChar>;
template class XcharMap<PackedBoolean>;
template class XcharMap<unsigned char>;
template class XcharMap<EquivCode>;
template class Vector<char>;
template class Vector<PackedBoolean>;
template class SubstTable<Char>;
template class CharMap<Unsigned32>;
template class CharMapPage<Unsigned32>;
template class CharMapColumn<Unsigned32>;
template class CharMapResource<Unsigned32>;
template class Ptr<CharMapResource<Unsigned32> >;
template class ConstPtr<CharMapResource<Unsigned32> >;