This is the mail archive of the
gcc-bugs@gcc.gnu.org
mailing list for the GCC project.
Internal compiler error in `make_label_edge', at flow.c:1097
- To: gcc-bugs at gcc dot gnu dot org
- Subject: Internal compiler error in `make_label_edge', at flow.c:1097
- From: Dennis Taylor <dennis at funkplanet dot com>
- Date: Sat, 28 Apr 2001 22:32:27 -0700
While compiling doxygen (a popular GPL documentation generator,
written in C++) on my i686 OpenBSD 2.8 machine, horrible things
happened. Here's the log:
[root@bluesky src]# gcc -v
Reading specs from /usr/lib/gcc-lib/i386-unknown-openbsd2.8/2.95.3/specs
gcc version 2.95.3 19991030 (prerelease)
[root@bluesky src]# g++ -save-temps -c -Wall -W -O2 -I../qtools -o ../objects/index.o index.cpp
index.cpp: In function `void writeGroupTreeNode(OutputList &, GroupDef *)':
index.cpp:2397: Internal compiler error in `make_label_edge', at flow.c:1097
Please submit a full bug report.
See <URL:http://www.gnu.org/software/gcc/bugs.html> for instructions.
The file "index.ii" is attached. Note that compiling this file
without optimization works just fine; both -O1 and -O2 cause the
compiler error.
_________________________________________________________________________
Dennis Taylor "Anyone whose days are all the same and free from
dennis@funkplanet.com want inhabits eternity of a sort." - Peter Hoeg
_________________________________________________________________________
PGP Fingerprint: E8D6 9670 4FBD EEC3 6C6B 810B 2B30 E529 51BD 7B90
# 1 "index.cpp"
# 1 "/usr/include/stdlib.h" 1 3 4
# 1 "/usr/include/machine/ansi.h" 1 3 4
# 41 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/types.h" 1 3 4
# 1 "/usr/include/machine/types.h" 1 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 1 "/usr/include/machine/cdefs.h" 1 3 4
# 39 "/usr/include/machine/cdefs.h" 3 4
# 53 "/usr/include/sys/cdefs.h" 2 3 4
# 110 "/usr/include/sys/cdefs.h" 3 4
# 42 "/usr/include/machine/types.h" 2 3 4
typedef struct _physadr {
int r[1];
} *physadr;
typedef struct label_t {
int val[6];
} label_t;
typedef unsigned long vm_offset_t;
typedef unsigned long vm_size_t;
typedef unsigned long vaddr_t;
typedef unsigned long paddr_t;
typedef unsigned long vsize_t;
typedef unsigned long psize_t;
typedef signed char int8_t;
typedef unsigned char u_int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short u_int16_t;
typedef unsigned short uint16_t;
typedef int int32_t;
typedef unsigned int u_int32_t;
typedef unsigned int uint32_t;
typedef long long int64_t;
typedef unsigned long long u_int64_t;
typedef unsigned long long uint64_t;
typedef int32_t register_t;
# 48 "/usr/include/sys/types.h" 2 3 4
# 1 "/usr/include/machine/endian.h" 1 3 4
# 1 "/usr/include/sys/endian.h" 1 3 4
# 83 "/usr/include/sys/endian.h" 3 4
# 125 "/usr/include/sys/endian.h" 3 4
extern "C" {
u_int32_t htobe32 (u_int32_t) ;
u_int16_t htobe16 (u_int16_t) ;
u_int32_t betoh32 (u_int32_t) ;
u_int16_t betoh16 (u_int16_t) ;
u_int32_t htole32 (u_int32_t) ;
u_int16_t htole16 (u_int16_t) ;
u_int32_t letoh32 (u_int32_t) ;
u_int16_t letoh16 (u_int16_t) ;
};
# 180 "/usr/include/sys/endian.h" 3 4
# 68 "/usr/include/machine/endian.h" 2 3 4
# 51 "/usr/include/sys/types.h" 2 3 4
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
typedef unsigned char unchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
typedef u_int64_t u_quad_t;
typedef int64_t quad_t;
typedef quad_t * qaddr_t;
typedef char * caddr_t;
typedef int32_t daddr_t;
typedef int32_t dev_t;
typedef u_int32_t fixpt_t;
typedef u_int32_t gid_t;
typedef u_int32_t ino_t;
typedef long key_t;
typedef u_int16_t mode_t;
typedef u_int16_t nlink_t;
typedef int32_t pid_t;
typedef quad_t rlim_t;
typedef int32_t segsz_t;
typedef int32_t swblk_t;
typedef u_int32_t uid_t;
typedef u_int32_t useconds_t;
typedef int32_t suseconds_t;
typedef u_int32_t in_addr_t;
typedef u_int16_t in_port_t;
typedef u_int8_t sa_family_t;
typedef u_int32_t socklen_t;
typedef unsigned long clock_t;
typedef unsigned int size_t;
typedef int ssize_t;
typedef int time_t;
typedef int clockid_t;
typedef int timer_t;
typedef long long off_t;
extern "C" {
off_t lseek (int, off_t, int) ;
int ftruncate (int, off_t) ;
int truncate (const char *, off_t) ;
};
typedef int32_t fd_mask;
typedef struct fd_set {
fd_mask fds_bits[((( 256 ) + (( (sizeof(fd_mask) * 8 ) ) - 1)) / ( (sizeof(fd_mask) * 8 ) )) ];
} fd_set;
# 205 "/usr/include/sys/types.h" 3 4
# 44 "/usr/include/stdlib.h" 2 3 4
typedef struct {
int quot;
int rem;
} div_t;
typedef struct {
long quot;
long rem;
} ldiv_t;
typedef struct {
quad_t quot;
quad_t rem;
} qdiv_t;
extern "C" {
void abort (void) ;
int abs (int) ;
int atexit (void (*)(void)) ;
double atof (const char *) ;
int atoi (const char *) ;
long atol (const char *) ;
void *bsearch (const void *, const void *, size_t,
size_t, int (*)(const void *, const void *)) ;
void *calloc (size_t, size_t) ;
div_t div (int, int) ;
void exit (int) ;
void free (void *) ;
char *getenv (const char *) ;
long labs (long) ;
ldiv_t ldiv (long, long) ;
void *malloc (size_t) ;
void qsort (void *, size_t, size_t,
int (*)(const void *, const void *)) ;
int rand (void) ;
int rand_r (unsigned int *) ;
void *realloc (void *, size_t) ;
void srand (unsigned) ;
double strtod (const char *, char **) ;
long strtol (const char *, char **, int) ;
unsigned long
strtoul (const char *, char **, int) ;
int system (const char *) ;
int mblen (const char *, size_t) ;
size_t mbstowcs (wchar_t *, const char *, size_t) ;
int wctomb (char *, wchar_t) ;
int mbtowc (wchar_t *, const char *, size_t) ;
size_t wcstombs (char *, const wchar_t *, size_t) ;
void *alloca (size_t) ;
char *getbsize (int *, long *) ;
char *cgetcap (char *, const char *, int) ;
int cgetclose (void) ;
int cgetent (char **, char **, const char *) ;
int cgetfirst (char **, char **) ;
int cgetmatch (char *, const char *) ;
int cgetnext (char **, char **) ;
int cgetnum (char *, const char *, long *) ;
int cgetset (const char *) ;
int cgetstr (char *, const char *, char **) ;
int cgetustr (char *, const char *, char **) ;
int daemon (int, int) ;
char *devname (int, int) ;
int getloadavg (double [], int) ;
long a64l (const char *) ;
char *l64a (long) ;
void cfree (void *) ;
int getopt (int, char * const *, const char *) ;
extern char *optarg;
extern int opterr;
extern int optind;
extern int optopt;
extern int optreset;
int getsubopt (char **, char * const *, char **) ;
extern char *suboptarg;
int heapsort (void *, size_t, size_t,
int (*)(const void *, const void *)) ;
int mergesort (void *, size_t, size_t,
int (*)(const void *, const void *)) ;
int radixsort (const unsigned char **, int, const unsigned char *,
unsigned) ;
int sradixsort (const unsigned char **, int, const unsigned char *,
unsigned) ;
char *initstate (unsigned int, char *, size_t) ;
long random (void) ;
char *realpath (const char *, char *) ;
char *setstate (const char *) ;
void srandom (unsigned int) ;
void srandomdev (void) ;
int putenv (const char *) ;
int setenv (const char *, const char *, int) ;
void unsetenv (const char *) ;
void setproctitle (const char *, ...) ;
quad_t qabs (quad_t) ;
qdiv_t qdiv (quad_t, quad_t) ;
quad_t strtoq (const char *, char **, int) ;
u_quad_t strtouq (const char *, char **, int) ;
double drand48 (void) ;
double erand48 (unsigned short[3]) ;
long jrand48 (unsigned short[3]) ;
void lcong48 (unsigned short[7]) ;
long lrand48 (void) ;
long mrand48 (void) ;
long nrand48 (unsigned short[3]) ;
unsigned short *seed48 (unsigned short[3]) ;
void srand48 (long) ;
u_int32_t arc4random (void) ;
void arc4random_stir (void) ;
void arc4random_addrandom (unsigned char *, int) ;
};
# 18 "index.cpp" 2
# 1 "../qtools/qtextstream.h" 1
# 1 "../qtools/qiodevice.h" 1
# 1 "../qtools/qglobal.h" 1
# 105 "../qtools/qglobal.h"
# 133 "../qtools/qglobal.h"
# 190 "../qtools/qglobal.h"
# 259 "../qtools/qglobal.h"
# 278 "../qtools/qglobal.h"
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned uint;
typedef unsigned long ulong;
typedef char *pchar;
typedef uchar *puchar;
typedef const char *pcchar;
const bool FALSE = 0;
const bool TRUE = !0;
inline int qRound( double d )
{
return d > 0.0 ? int(d+0.5) : int(d-0.5);
}
typedef signed char INT8;
typedef unsigned char UINT8;
typedef short INT16;
typedef unsigned short UINT16;
typedef int INT32;
typedef unsigned int UINT32;
typedef signed char Q_INT8;
typedef unsigned char Q_UINT8;
typedef short Q_INT16;
typedef unsigned short Q_UINT16;
typedef int Q_INT32;
typedef unsigned int Q_UINT32;
typedef long Q_INT64;
typedef unsigned long Q_UINT64;
class QDataStream;
# 1 "../qtools/qfeatures.h" 1
# 63 "../qtools/qfeatures.h"
# 1 "../qtools/qconfig.h" 1
# 64 "../qtools/qfeatures.h" 2
# 183 "../qtools/qfeatures.h"
# 307 "../qtools/qfeatures.h"
# 592 "../qtools/qfeatures.h"
# 620 "../qtools/qfeatures.h"
# 678 "../qtools/qfeatures.h"
# 712 "../qtools/qfeatures.h"
# 730 "../qtools/qfeatures.h"
# 815 "../qtools/qfeatures.h"
# 903 "../qtools/qfeatures.h"
# 409 "../qtools/qglobal.h" 2
# 434 "../qtools/qglobal.h"
const char *qVersion();
bool qSysInfo( int *wordSize, bool *bigEndian );
# 493 "../qtools/qglobal.h"
void qDebug( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void qWarning( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void qFatal( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void debug( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void warning( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void fatal( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
bool qt_check_pointer( bool c, const char *, int );
enum QtMsgType { QtDebugMsg, QtWarningMsg, QtFatalMsg };
typedef void (*msg_handler)(QtMsgType, const char *);
msg_handler qInstallMsgHandler( msg_handler );
void qSuppressObsoleteWarnings( bool = TRUE );
void qObsolete( const char *obj, const char *oldfunc,
const char *newfunc );
void qObsolete( const char *obj, const char *oldfunc );
void qObsolete( const char *message );
# 42 "../qtools/qiodevice.h" 2
# 1 "../qtools/qcstring.h" 1
# 1 "../qtools/qarray.h" 1
# 1 "../qtools/qgarray.h" 1
# 1 "../qtools/qshared.h" 1
struct QShared
{
QShared() { count = 1; }
void ref() { count++; }
bool deref() { return !--count; }
uint count;
};
# 42 "../qtools/qgarray.h" 2
class QGArray
{
friend class QBuffer;
public:
struct array_data : public QShared {
array_data() { data=0; len=0; }
char *data;
uint len;
};
QGArray();
protected:
QGArray( int, int );
QGArray( int size );
QGArray( const QGArray &a );
virtual ~QGArray();
QGArray &operator=( const QGArray &a ) { return assign( a ); }
virtual void detach() { duplicate(*this); }
char *data() const { return shd->data; }
uint nrefs() const { return shd->count; }
uint size() const { return shd->len; }
bool isEqual( const QGArray &a ) const;
bool resize( uint newsize );
bool fill( const char *d, int len, uint sz );
QGArray &assign( const QGArray &a );
QGArray &assign( const char *d, uint len );
QGArray &duplicate( const QGArray &a );
QGArray &duplicate( const char *d, uint len );
void store( const char *d, uint len );
array_data *sharedBlock() const { return shd; }
void setSharedBlock( array_data *p ) { shd=(array_data*)p; }
QGArray &setRawData( const char *d, uint len );
void resetRawData( const char *d, uint len );
int find( const char *d, uint index, uint sz ) const;
int contains( const char *d, uint sz ) const;
void sort( uint sz );
int bsearch( const char *d, uint sz ) const;
char *at( uint index ) const;
bool setExpand( uint index, const char *d, uint sz );
protected:
virtual array_data *newData();
virtual void deleteData( array_data *p );
private:
static void msg_index( uint );
array_data *shd;
};
inline char *QGArray::at( uint index ) const
{
if ( index >= size() ) {
msg_index( index );
index = 0;
}
return &shd->data[index];
}
# 42 "../qtools/qarray.h" 2
template<class type> class QArray : public QGArray
{
public:
typedef type* Iterator;
typedef const type* ConstIterator;
typedef type ValueType;
protected:
QArray( int, int ) : QGArray( 0, 0 ) {}
public:
QArray() {}
QArray( int size ) : QGArray(size*sizeof(type)) {}
QArray( const QArray<type> &a ) : QGArray(a) {}
~QArray() {}
QArray<type> &operator=(const QArray<type> &a)
{ return (QArray<type>&)QGArray::assign(a); }
type *data() const { return (type *)QGArray::data(); }
uint nrefs() const { return QGArray::nrefs(); }
uint size() const { return QGArray::size()/sizeof(type); }
uint count() const { return size(); }
bool isEmpty() const { return QGArray::size() == 0; }
bool isNull() const { return QGArray::data() == 0; }
bool resize( uint size ) { return QGArray::resize(size*sizeof(type)); }
bool truncate( uint pos ) { return QGArray::resize(pos*sizeof(type)); }
bool fill( const type &d, int size = -1 )
{ return QGArray::fill((char*)&d,size,sizeof(type) ); }
void detach() { QGArray::detach(); }
QArray<type> copy() const
{ QArray<type> tmp; return tmp.duplicate(*this); }
QArray<type>& assign( const QArray<type>& a )
{ return (QArray<type>&)QGArray::assign(a); }
QArray<type>& assign( const type *a, uint n )
{ return (QArray<type>&)QGArray::assign((char*)a,n*sizeof(type)); }
QArray<type>& duplicate( const QArray<type>& a )
{ return (QArray<type>&)QGArray::duplicate(a); }
QArray<type>& duplicate( const type *a, uint n )
{ return (QArray<type>&)QGArray::duplicate((char*)a,n*sizeof(type)); }
QArray<type>& setRawData( const type *a, uint n )
{ return (QArray<type>&)QGArray::setRawData((char*)a,
n*sizeof(type)); }
void resetRawData( const type *a, uint n )
{ QGArray::resetRawData((char*)a,n*sizeof(type)); }
int find( const type &d, uint i=0 ) const
{ return QGArray::find((char*)&d,i,sizeof(type)); }
int contains( const type &d ) const
{ return QGArray::contains((char*)&d,sizeof(type)); }
void sort() { QGArray::sort(sizeof(type)); }
int bsearch( const type &d ) const
{ return QGArray::bsearch((const char*)&d,sizeof(type)); }
type& operator[]( int i ) const
{ return (type &)(*(type *)QGArray::at(i*sizeof(type))); }
type& at( uint i ) const
{ return (type &)(*(type *)QGArray::at(i*sizeof(type))); }
operator const type*() const { return (const type *)QGArray::data(); }
bool operator==( const QArray<type> &a ) const { return isEqual(a); }
bool operator!=( const QArray<type> &a ) const { return !isEqual(a); }
Iterator begin() { return data(); }
Iterator end() { return data() + size(); }
ConstIterator begin() const { return data(); }
ConstIterator end() const { return data() + size(); }
};
# 43 "../qtools/qcstring.h" 2
# 1 "/usr/include/string.h" 1 3 4
extern "C" {
void *memchr (const void *, int, size_t) ;
int memcmp (const void *, const void *, size_t) ;
void *memcpy (void *, const void *, size_t) ;
void *memmove (void *, const void *, size_t) ;
void *memset (void *, int, size_t) ;
char *strcat (char *, const char *) ;
char *strchr (const char *, int) ;
int strcmp (const char *, const char *) ;
int strcoll (const char *, const char *) ;
char *strcpy (char *, const char *) ;
size_t strcspn (const char *, const char *) ;
char *strerror (int) ;
size_t strlen (const char *) ;
char *strncat (char *, const char *, size_t) ;
int strncmp (const char *, const char *, size_t) ;
char *strncpy (char *, const char *, size_t) ;
char *strpbrk (const char *, const char *) ;
char *strrchr (const char *, int) ;
size_t strspn (const char *, const char *) ;
char *strstr (const char *, const char *) ;
char *strtok (char *, const char *) ;
char *strtok_r (char *, const char *, char **) ;
size_t strxfrm (char *, const char *, size_t) ;
int bcmp (const void *, const void *, size_t) ;
void bcopy (const void *, void *, size_t) ;
void bzero (void *, size_t) ;
int ffs (int) ;
char *index (const char *, int) ;
void *memccpy (void *, const void *, int, size_t) ;
char *rindex (const char *, int) ;
int strcasecmp (const char *, const char *) ;
char *strdup (const char *) ;
size_t strlcat (char *, const char *, size_t) ;
size_t strlcpy (char *, const char *, size_t) ;
void strmode (int, char *) ;
int strncasecmp (const char *, const char *, size_t) ;
char *strsep (char **, const char *) ;
char *strsignal (int) ;
};
# 46 "../qtools/qcstring.h" 2
# 71 "../qtools/qcstring.h"
void *qmemmove( void *dst, const void *src, uint len );
char *qstrdup( const char * );
inline uint cstrlen( const char *str )
{ return strlen(str); }
inline uint qstrlen( const char *str )
{ return str ? strlen(str) : 0; }
inline char *cstrcpy( char *dst, const char *src )
{ return strcpy(dst,src); }
inline char *qstrcpy( char *dst, const char *src )
{ return src ? strcpy(dst, src) : 0; }
char *qstrncpy( char *dst, const char *src, uint len );
inline int cstrcmp( const char *str1, const char *str2 )
{ return strcmp(str1,str2); }
inline int qstrcmp( const char *str1, const char *str2 )
{ return (str1 && str2) ? strcmp(str1,str2) : (int)((long)str2 - (long)str1); }
inline int cstrncmp( const char *str1, const char *str2, uint len )
{ return strncmp(str1,str2,len); }
inline int qstrncmp( const char *str1, const char *str2, uint len )
{ return (str1 && str2) ? strncmp(str1,str2,len) :
(int)((long)str2 - (long)str1); }
int qstricmp( const char *, const char * );
int qstrnicmp( const char *, const char *, uint len );
Q_UINT16 qChecksum( const char *s, uint len );
typedef QArray<char> QByteArray;
QDataStream &operator<<( QDataStream &, const QByteArray & );
QDataStream &operator>>( QDataStream &, QByteArray & );
class QRegExp;
class QCString : public QByteArray
{
public:
QCString() {}
QCString( int size );
QCString( const QCString &s ) : QByteArray( s ) {}
QCString( const char *str );
QCString( const char *str, uint maxlen );
QCString &operator=( const QCString &s );
QCString &operator=( const char *str );
bool isNull() const;
bool isEmpty() const;
uint length() const;
bool resize( uint newlen );
bool truncate( uint pos );
bool fill( char c, int len = -1 );
QCString copy() const;
QCString &sprintf( const char *format, ... );
int find( char c, int index=0, bool cs=TRUE ) const;
int find( const char *str, int index=0, bool cs=TRUE ) const;
int find( const QRegExp &, int index=0 ) const;
int findRev( char c, int index=-1, bool cs=TRUE) const;
int findRev( const char *str, int index=-1, bool cs=TRUE) const;
int findRev( const QRegExp &, int index=-1 ) const;
int contains( char c, bool cs=TRUE ) const;
int contains( const char *str, bool cs=TRUE ) const;
int contains( const QRegExp & ) const;
QCString left( uint len ) const;
QCString right( uint len ) const;
QCString mid( uint index, uint len=0xffffffff) const;
QCString leftJustify( uint width, char fill=' ', bool trunc=FALSE)const;
QCString rightJustify( uint width, char fill=' ',bool trunc=FALSE)const;
QCString lower() const;
QCString upper() const;
QCString stripWhiteSpace() const;
QCString simplifyWhiteSpace() const;
QCString &insert( uint index, const char * );
QCString &insert( uint index, char );
QCString &append( const char * );
QCString &prepend( const char * );
QCString &remove( uint index, uint len );
QCString &replace( uint index, uint len, const char * );
QCString &replace( const QRegExp &, const char * );
short toShort( bool *ok=0 ) const;
ushort toUShort( bool *ok=0 ) const;
int toInt( bool *ok=0 ) const;
uint toUInt( bool *ok=0 ) const;
long toLong( bool *ok=0 ) const;
ulong toULong( bool *ok=0 ) const;
float toFloat( bool *ok=0 ) const;
double toDouble( bool *ok=0 ) const;
QCString &setStr( const char *s );
QCString &setNum( short );
QCString &setNum( ushort );
QCString &setNum( int );
QCString &setNum( uint );
QCString &setNum( long );
QCString &setNum( ulong );
QCString &setNum( float, char f='g', int prec=6 );
QCString &setNum( double, char f='g', int prec=6 );
bool setExpand( uint index, char c );
operator const char *() const;
QCString &operator+=( const char *str );
QCString &operator+=( char c );
};
QDataStream &operator<<( QDataStream &, const QCString & );
QDataStream &operator>>( QDataStream &, QCString & );
inline QCString &QCString::operator=( const QCString &s )
{ return (QCString&)assign( s ); }
inline QCString &QCString::operator=( const char *str )
{ return (QCString&)duplicate( str, qstrlen(str)+1 ); }
inline bool QCString::isNull() const
{ return data() == 0; }
inline bool QCString::isEmpty() const
{ return data() == 0 || *data() == '\0'; }
inline uint QCString::length() const
{ return qstrlen( data() ); }
inline bool QCString::truncate( uint pos )
{ return resize(pos+1); }
inline QCString QCString::copy() const
{ return QCString( data() ); }
inline QCString &QCString::prepend( const char *s )
{ return insert(0,s); }
inline QCString &QCString::append( const char *s )
{ return operator+=(s); }
inline QCString &QCString::setNum( short n )
{ return setNum((long)n); }
inline QCString &QCString::setNum( ushort n )
{ return setNum((ulong)n); }
inline QCString &QCString::setNum( int n )
{ return setNum((long)n); }
inline QCString &QCString::setNum( uint n )
{ return setNum((ulong)n); }
inline QCString &QCString::setNum( float n, char f, int prec )
{ return setNum((double)n,f,prec); }
inline QCString::operator const char *() const
{ return (const char *)data(); }
inline bool operator==( const QCString &s1, const QCString &s2 )
{ return qstrcmp(s1.data(),s2.data()) == 0; }
inline bool operator==( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) == 0; }
inline bool operator==( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) == 0; }
inline bool operator!=( const QCString &s1, const QCString &s2 )
{ return qstrcmp(s1.data(),s2.data()) != 0; }
inline bool operator!=( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) != 0; }
inline bool operator!=( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) != 0; }
inline bool operator<( const QCString &s1, const QCString& s2 )
{ return qstrcmp(s1.data(),s2.data()) < 0; }
inline bool operator<( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) < 0; }
inline bool operator<( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) < 0; }
inline bool operator<=( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) <= 0; }
inline bool operator<=( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) <= 0; }
inline bool operator>( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) > 0; }
inline bool operator>( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) > 0; }
inline bool operator>=( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) >= 0; }
inline bool operator>=( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) >= 0; }
inline QCString operator+( const QCString &s1, const QCString &s2 )
{
QCString tmp( s1.data() );
tmp += s2;
return tmp;
}
inline QCString operator+( const QCString &s1, const char *s2 )
{
QCString tmp( s1.data() );
tmp += s2;
return tmp;
}
inline QCString operator+( const char *s1, const QCString &s2 )
{
QCString tmp( s1 );
tmp += s2;
return tmp;
}
inline QCString operator+( const QCString &s1, char c2 )
{
QCString tmp( s1.data() );
tmp += c2;
return tmp;
}
inline QCString operator+( char c1, const QCString &s2 )
{
QCString tmp;
tmp += c1;
tmp += s2;
return tmp;
}
# 43 "../qtools/qiodevice.h" 2
class QIODevice
{
public:
QIODevice();
virtual ~QIODevice();
int flags() const { return ioMode; }
int mode() const { return ioMode & 0x00ff ; }
int state() const { return ioMode & 0xf000 ; }
bool isDirectAccess() const { return ((ioMode & 0x0100 ) == 0x0100 ); }
bool isSequentialAccess() const { return ((ioMode & 0x0200 ) == 0x0200 ); }
bool isCombinedAccess() const { return ((ioMode & 0x0300 ) == 0x0300 ); }
bool isBuffered() const { return ((ioMode & 0x0040 ) != 0x0040 ); }
bool isRaw() const { return ((ioMode & 0x0040 ) == 0x0040 ); }
bool isSynchronous() const { return ((ioMode & 0x0080 ) != 0x0080 ); }
bool isAsynchronous() const { return ((ioMode & 0x0080 ) == 0x0080 ); }
bool isTranslated() const { return ((ioMode & 0x0010 ) == 0x0010 ); }
bool isReadable() const { return ((ioMode & 0x0001 ) == 0x0001 ); }
bool isWritable() const { return ((ioMode & 0x0002 ) == 0x0002 ); }
bool isReadWrite() const { return ((ioMode & 0x0003 ) == 0x0003 ); }
bool isInactive() const { return state() == 0; }
bool isOpen() const { return state() == 0x1000 ; }
int status() const { return ioSt; }
void resetStatus() { ioSt = 0 ; }
virtual bool open( int mode ) = 0;
virtual void close() = 0;
virtual void flush() = 0;
virtual uint size() const = 0;
virtual int at() const;
virtual bool at( int );
virtual bool atEnd() const;
bool reset() { return at(0); }
virtual int readBlock( char *data, uint maxlen ) = 0;
virtual int writeBlock( const char *data, uint len ) = 0;
virtual int readLine( char *data, uint maxlen );
int writeBlock( const QByteArray& data );
QByteArray readAll();
virtual int getch() = 0;
virtual int putch( int ) = 0;
virtual int ungetch( int ) = 0;
protected:
void setFlags( int f ) { ioMode = f; }
void setType( int );
void setMode( int );
void setState( int );
void setStatus( int );
int ioIndex;
private:
int ioMode;
int ioSt;
private:
QIODevice( const QIODevice & );
QIODevice &operator=( const QIODevice & );
};
# 42 "../qtools/qtextstream.h" 2
# 1 "../qtools/qstring.h" 1
class QRegExp;
class QString;
class QCharRef;
class QChar {
public:
QChar();
QChar( char c );
QChar( uchar c );
QChar( uchar c, uchar r );
QChar( const QChar& c );
QChar( ushort rc );
QChar( short rc );
QChar( uint rc );
QChar( int rc );
static const QChar null;
static const QChar replacement;
static const QChar byteOrderMark;
static const QChar byteOrderSwapped;
static const QChar nbsp;
enum Category
{
NoCategory,
Mark_NonSpacing,
Mark_SpacingCombining,
Mark_Enclosing,
Number_DecimalDigit,
Number_Letter,
Number_Other,
Separator_Space,
Separator_Line,
Separator_Paragraph,
Other_Control,
Other_Format,
Other_Surrogate,
Other_PrivateUse,
Other_NotAssigned,
Letter_Uppercase,
Letter_Lowercase,
Letter_Titlecase,
Letter_Modifier,
Letter_Other,
Punctuation_Connector,
Punctuation_Dask,
Punctuation_Open,
Punctuation_Close,
Punctuation_InitialQuote,
Punctuation_FinalQuote,
Punctuation_Other,
Symbol_Math,
Symbol_Currency,
Symbol_Modifier,
Symbol_Other
};
enum Direction
{
DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
};
enum Decomposition
{
Single, Canonical, Font, NoBreak, Initial, Medial,
Final, Isolated, Circle, Super, Sub, Vertical,
Wide, Narrow, Small, Square, Compat, Fraction
};
enum Joining
{
OtherJoining, Dual, Right, Center
};
int digitValue() const;
QChar lower() const;
QChar upper() const;
Category category() const;
Direction direction() const;
Joining joining() const;
bool mirrored() const;
QChar mirroredChar() const;
QString decomposition() const;
Decomposition decompositionTag() const;
char latin1() const { return rw ? 0 : cl; }
ushort unicode() const { return (rw << 8) | cl; }
operator char() const { return latin1(); }
bool isNull() const { return unicode()==0; }
bool isPrint() const;
bool isPunct() const;
bool isSpace() const;
bool isMark() const;
bool isLetter() const;
bool isNumber() const;
bool isLetterOrNumber() const;
bool isDigit() const;
uchar& cell() { return cl; }
uchar& row() { return rw; }
uchar cell() const { return cl; }
uchar row() const { return rw; }
static bool networkOrdered() { return (int)net_ordered == 1; }
friend inline int operator==( char ch, QChar c );
friend inline int operator==( QChar c, char ch );
friend inline int operator==( QChar c1, QChar c2 );
friend inline int operator!=( QChar c1, QChar c2 );
friend inline int operator!=( char ch, QChar c );
friend inline int operator!=( QChar c, char ch );
friend inline int operator<=( QChar c, char ch );
friend inline int operator<=( char ch, QChar c );
friend inline int operator<=( QChar c1, QChar c2 );
private:
uchar rw;
uchar cl;
enum { net_ordered = 1 };
# 201 "../qtools/qstring.h"
};
inline QChar::QChar()
{
rw = 0; cl = 0;
}
inline QChar::QChar( char c )
{
rw = 0; cl = (uchar)c;
}
inline QChar::QChar( uchar c )
{
rw = 0; cl = c;
}
inline QChar::QChar( uchar c, uchar r )
{
rw = r; cl = c;
}
inline QChar::QChar( const QChar& c )
{
rw = c.rw; cl = c.cl;
}
inline QChar::QChar( ushort rc )
{
rw = (uchar)((rc>>8)&0xff); cl = (uchar)(rc&0xff);
}
inline QChar::QChar( short rc )
{
rw = (uchar)((rc>>8)&0xff); cl = (uchar)(rc&0xff);
}
inline QChar::QChar( uint rc )
{
rw = (uchar)((rc>>8)&0xff); cl = (uchar)(rc&0xff);
}
inline QChar::QChar( int rc )
{
rw = (uchar)((rc>>8)&0xff); cl = (uchar)(rc&0xff);
}
inline int operator==( char ch, QChar c )
{
return ch == c.cl && !c.rw;
}
inline int operator==( QChar c, char ch )
{
return ch == c.cl && !c.rw;
}
inline int operator==( QChar c1, QChar c2 )
{
return c1.cl == c2.cl
&& c1.rw == c2.rw;
}
inline int operator!=( QChar c1, QChar c2 )
{
return c1.cl != c2.cl
|| c1.rw != c2.rw;
}
inline int operator!=( char ch, QChar c )
{
return ch != c.cl || c.rw;
}
inline int operator!=( QChar c, char ch )
{
return ch != c.cl || c.rw;
}
inline int operator<=( QChar c, char ch )
{
return !(ch < c.cl || c.rw);
}
inline int operator<=( char ch, QChar c )
{
return ch <= c.cl || c.rw;
}
inline int operator<=( QChar c1, QChar c2 )
{
return c1.rw > c2.rw
? FALSE
: c1.rw < c2.rw
? TRUE
: c1.cl <= c2.cl;
}
inline int operator>=( QChar c, char ch ) { return ch <= c; }
inline int operator>=( char ch, QChar c ) { return c <= ch; }
inline int operator>=( QChar c1, QChar c2 ) { return c2 <= c1; }
inline int operator<( QChar c, char ch ) { return !(ch<=c); }
inline int operator<( char ch, QChar c ) { return !(c<=ch); }
inline int operator<( QChar c1, QChar c2 ) { return !(c2<=c1); }
inline int operator>( QChar c, char ch ) { return !(ch>=c); }
inline int operator>( char ch, QChar c ) { return !(c>=ch); }
inline int operator>( QChar c1, QChar c2 ) { return !(c2>=c1); }
struct QStringData : public QShared {
QStringData() :
unicode(0), ascii(0), len(0), maxl(0), dirtyascii(0) { ref(); }
QStringData(QChar *u, uint l, uint m) :
unicode(u), ascii(0), len(l), maxl(m), dirtyascii(0) { }
~QStringData() { if ( unicode ) delete[] ((char*)unicode);
if ( ascii ) delete[] ascii; }
void deleteSelf();
QChar *unicode;
char *ascii;
uint len;
uint maxl:30;
uint dirtyascii:1;
};
class QString
{
public:
QString();
QString( QChar );
QString( const QString & );
QString( const QByteArray& );
QString( const QChar* unicode, uint length );
QString( const char *str );
~QString();
QString &operator=( const QString & );
QString &operator=( const char * );
QString &operator=( const QCString& );
QString &operator=( QChar c );
QString &operator=( char c );
static const QString null;
bool isNull() const;
bool isEmpty() const;
uint length() const;
void truncate( uint pos );
void fill( QChar c, int len = -1 );
QString copy() const;
QString arg(long a, int fieldwidth=0, int base=10) const;
QString arg(ulong a, int fieldwidth=0, int base=10) const;
QString arg(int a, int fieldwidth=0, int base=10) const;
QString arg(uint a, int fieldwidth=0, int base=10) const;
QString arg(short a, int fieldwidth=0, int base=10) const;
QString arg(ushort a, int fieldwidth=0, int base=10) const;
QString arg(char a, int fieldwidth=0) const;
QString arg(QChar a, int fieldwidth=0) const;
QString arg(const QString& a, int fieldwidth=0) const;
QString arg(double a, int fieldwidth=0, char fmt='g', int prec=-1) const;
QString &sprintf( const char* format, ... )
__attribute__ ((format (printf, 2, 3)))
;
int find( QChar c, int index=0, bool cs=TRUE ) const;
int find( char c, int index=0, bool cs=TRUE ) const;
int find( const QString &str, int index=0, bool cs=TRUE ) const;
int find( const QRegExp &, int index=0 ) const;
int find( const char* str, int index=0 ) const;
int findRev( QChar c, int index=-1, bool cs=TRUE) const;
int findRev( char c, int index=-1, bool cs=TRUE) const;
int findRev( const QString &str, int index=-1, bool cs=TRUE) const;
int findRev( const QRegExp &, int index=-1 ) const;
int findRev( const char* str, int index=-1 ) const;
int contains( QChar c, bool cs=TRUE ) const;
int contains( char c, bool cs=TRUE ) const
{ return contains(QChar(c), cs); }
int contains( const char* str, bool cs=TRUE ) const;
int contains( const QString &str, bool cs=TRUE ) const;
int contains( const QRegExp & ) const;
QString left( uint len ) const;
QString right( uint len ) const;
QString mid( uint index, uint len=0xffffffff) const;
QString leftJustify( uint width, QChar fill=' ', bool trunc=FALSE)const;
QString rightJustify( uint width, QChar fill=' ',bool trunc=FALSE)const;
QString lower() const;
QString upper() const;
QString stripWhiteSpace() const;
QString simplifyWhiteSpace() const;
QString &insert( uint index, const QString & );
QString &insert( uint index, const QChar*, uint len );
QString &insert( uint index, QChar );
QString &insert( uint index, char c ) { return insert(index,QChar(c)); }
QString &append( char );
QString &append( QChar );
QString &append( const QString & );
QString &prepend( char );
QString &prepend( QChar );
QString &prepend( const QString & );
QString &remove( uint index, uint len );
QString &replace( uint index, uint len, const QString & );
QString &replace( uint index, uint len, const QChar*, uint clen );
QString &replace( const QRegExp &, const QString & );
short toShort( bool *ok=0, int base=10 ) const;
ushort toUShort( bool *ok=0, int base=10 ) const;
int toInt( bool *ok=0, int base=10 ) const;
uint toUInt( bool *ok=0, int base=10 ) const;
long toLong( bool *ok=0, int base=10 ) const;
ulong toULong( bool *ok=0, int base=10 ) const;
float toFloat( bool *ok=0 ) const;
double toDouble( bool *ok=0 ) const;
QString &setNum( short, int base=10 );
QString &setNum( ushort, int base=10 );
QString &setNum( int, int base=10 );
QString &setNum( uint, int base=10 );
QString &setNum( long, int base=10 );
QString &setNum( ulong, int base=10 );
QString &setNum( float, char f='g', int prec=6 );
QString &setNum( double, char f='g', int prec=6 );
static QString number( long, int base=10 );
static QString number( ulong, int base=10);
static QString number( int, int base=10 );
static QString number( uint, int base=10);
static QString number( double, char f='g', int prec=6 );
void setExpand( uint index, QChar c );
QString &operator+=( const QString &str );
QString &operator+=( QChar c );
QString &operator+=( char c );
QChar at( uint i ) const
{ return i<d->len ? d->unicode[i] : QChar::null; }
QChar operator[]( int i ) const { return at((uint)i); }
QCharRef at( uint i );
QCharRef operator[]( int i );
QChar constref(uint i) const
{ return at(i); }
QChar& ref(uint i)
{
if (d->count!=1 || i>=d->len)
subat(i);
d->dirtyascii=1;
return d->unicode[i];
}
const QChar* unicode() const { return d->unicode; }
const char* ascii() const;
const char* latin1() const;
static QString fromLatin1(const char*, int len=-1);
QCString utf8() const;
static QString fromUtf8(const char*, int len=-1);
QCString local8Bit() const;
static QString fromLocal8Bit(const char*, int len=-1);
bool operator!() const;
operator const char *() const { return latin1(); }
QString &setUnicode( const QChar* unicode, uint len );
QString &setUnicodeCodes( const ushort* unicode_as_ushorts, uint len );
QString &setLatin1( const char*, int len=-1 );
int compare( const QString& s ) const;
static int compare( const QString& s1, const QString& s2 )
{ return s1.compare(s2); }
friend QDataStream &operator>>( QDataStream &, QString & );
void compose();
QChar::Direction basicDirection();
QString visual(int index = 0, int len = -1);
const char* data() const { return latin1(); }
bool startsWith( const QString& ) const;
private:
QString( int size, bool dummy );
void deref();
void real_detach();
void setLength( uint pos );
void subat( uint );
bool findArg(int& pos, int& len) const;
static QChar* asciiToUnicode( const char*, uint * len, uint maxlen=(uint)-1 );
static QChar* asciiToUnicode( const QByteArray&, uint * len );
static char* unicodeToAscii( const QChar*, uint len );
QStringData *d;
static QStringData* shared_null;
static QStringData* makeSharedNull();
friend class QConstString;
QString(QStringData* dd, bool ) : d(dd) { }
};
class QCharRef {
friend class QString;
QString& s;
uint p;
QCharRef(QString* str, uint pos) : s(*str), p(pos) { }
public:
ushort unicode() const { return s.constref(p).unicode(); }
char latin1() const { return s.constref(p).latin1(); }
QCharRef operator=(char c ) { s.ref(p)=c; return *this; }
QCharRef operator=(uchar c ) { s.ref(p)=c; return *this; }
QCharRef operator=(QChar c ) { s.ref(p)=c; return *this; }
QCharRef operator=(const QCharRef& c ) { s.ref(p)=c.unicode(); return *this; }
QCharRef operator=(ushort rc ) { s.ref(p)=rc; return *this; }
QCharRef operator=(short rc ) { s.ref(p)=rc; return *this; }
QCharRef operator=(uint rc ) { s.ref(p)=rc; return *this; }
QCharRef operator=(int rc ) { s.ref(p)=rc; return *this; }
operator QChar () const { return s.constref(p); }
bool isNull() const { return unicode()==0; }
bool isPrint() const { return s.constref(p).isPrint(); }
bool isPunct() const { return s.constref(p).isPunct(); }
bool isSpace() const { return s.constref(p).isSpace(); }
bool isMark() const { return s.constref(p).isMark(); }
bool isLetter() const { return s.constref(p).isLetter(); }
bool isNumber() const { return s.constref(p).isNumber(); }
bool isLetterOrNumber() { return s.constref(p).isLetterOrNumber(); }
bool isDigit() const { return s.constref(p).isDigit(); }
int digitValue() const { return s.constref(p).digitValue(); }
QChar lower() { return s.constref(p).lower(); }
QChar upper() { return s.constref(p).upper(); }
QChar::Category category() const { return s.constref(p).category(); }
QChar::Direction direction() const { return s.constref(p).direction(); }
QChar::Joining joining() const { return s.constref(p).joining(); }
bool mirrored() const { return s.constref(p).mirrored(); }
QChar mirroredChar() const { return s.constref(p).mirroredChar(); }
QString decomposition() const { return s.constref(p).decomposition(); }
QChar::Decomposition decompositionTag() const { return s.constref(p).decompositionTag(); }
uchar cell() const { return s.constref(p).cell(); }
uchar row() const { return s.constref(p).row(); }
};
inline QCharRef QString::at( uint i ) { return QCharRef(this,i); }
inline QCharRef QString::operator[]( int i ) { return at((uint)i); }
class QConstString : private QString {
public:
QConstString( QChar* unicode, uint length );
~QConstString();
const QString& string() const { return *this; }
};
QDataStream &operator<<( QDataStream &, const QString & );
QDataStream &operator>>( QDataStream &, QString & );
inline QString::QString() :
d(shared_null ? shared_null : makeSharedNull())
{
d->ref();
}
inline QString::~QString()
{
if ( d->deref() ) {
if ( d == shared_null )
shared_null = 0;
d->deleteSelf();
}
}
inline QString &QString::operator=( QChar c )
{ return *this = QString(c); }
inline QString &QString::operator=( char c )
{ return *this = QString(QChar(c)); }
inline bool QString::isNull() const
{ return unicode() == 0; }
inline bool QString::operator!() const
{ return isNull(); }
inline uint QString::length() const
{ return d->len; }
inline bool QString::isEmpty() const
{ return length() == 0; }
inline QString QString::copy() const
{ return QString( *this ); }
inline QString &QString::prepend( const QString & s )
{ return insert(0,s); }
inline QString &QString::prepend( QChar c )
{ return insert(0,c); }
inline QString &QString::prepend( char c )
{ return insert(0,c); }
inline QString &QString::append( const QString & s )
{ return operator+=(s); }
inline QString &QString::append( QChar c )
{ return operator+=(c); }
inline QString &QString::append( char c )
{ return operator+=(c); }
inline QString &QString::setNum( short n, int base )
{ return setNum((long)n, base); }
inline QString &QString::setNum( ushort n, int base )
{ return setNum((ulong)n, base); }
inline QString &QString::setNum( int n, int base )
{ return setNum((long)n, base); }
inline QString &QString::setNum( uint n, int base )
{ return setNum((ulong)n, base); }
inline QString &QString::setNum( float n, char f, int prec )
{ return setNum((double)n,f,prec); }
inline QString QString::arg(int a, int fieldwidth, int base) const
{ return arg((long)a, fieldwidth, base); }
inline QString QString::arg(uint a, int fieldwidth, int base) const
{ return arg((ulong)a, fieldwidth, base); }
inline QString QString::arg(short a, int fieldwidth, int base) const
{ return arg((long)a, fieldwidth, base); }
inline QString QString::arg(ushort a, int fieldwidth, int base) const
{ return arg((ulong)a, fieldwidth, base); }
inline int QString::find( char c, int index, bool cs ) const
{ return find(QChar(c), index, cs); }
inline int QString::findRev( char c, int index, bool cs) const
{ return findRev( QChar(c), index, cs ); }
inline int QString::find( const char* str, int index ) const
{ return find(QString::fromLatin1(str), index); }
inline int QString::findRev( const char* str, int index ) const
{ return findRev(QString::fromLatin1(str), index); }
bool operator!=( const QString &s1, const QString &s2 );
bool operator<( const QString &s1, const QString &s2 );
bool operator<=( const QString &s1, const QString &s2 );
bool operator==( const QString &s1, const QString &s2 );
bool operator>( const QString &s1, const QString &s2 );
bool operator>=( const QString &s1, const QString &s2 );
bool operator!=( const QString &s1, const char *s2 );
bool operator<( const QString &s1, const char *s2 );
bool operator<=( const QString &s1, const char *s2 );
bool operator==( const QString &s1, const char *s2 );
bool operator>( const QString &s1, const char *s2 );
bool operator>=( const QString &s1, const char *s2 );
bool operator!=( const char *s1, const QString &s2 );
bool operator<( const char *s1, const QString &s2 );
bool operator<=( const char *s1, const QString &s2 );
bool operator==( const char *s1, const QString &s2 );
bool operator>=( const char *s1, const QString &s2 );
inline QString operator+( const QString &s1, const QString &s2 )
{
QString tmp( s1 );
tmp += s2;
return tmp;
}
inline QString operator+( const QString &s1, const char *s2 )
{
QString tmp( s1 );
tmp += QString::fromLatin1(s2);
return tmp;
}
inline QString operator+( const char *s1, const QString &s2 )
{
QString tmp = QString::fromLatin1( s1 );
tmp += s2;
return tmp;
}
inline QString operator+( const QString &s1, QChar c2 )
{
QString tmp( s1 );
tmp += c2;
return tmp;
}
inline QString operator+( const QString &s1, char c2 )
{
QString tmp( s1 );
tmp += c2;
return tmp;
}
inline QString operator+( QChar c1, const QString &s2 )
{
QString tmp;
tmp += c1;
tmp += s2;
return tmp;
}
inline QString operator+( char c1, const QString &s2 )
{
QString tmp;
tmp += c1;
tmp += s2;
return tmp;
}
# 43 "../qtools/qtextstream.h" 2
# 1 "/usr/include/stdio.h" 1 3 4
typedef off_t fpos_t;
struct __sbuf {
unsigned char *_base;
int _size;
};
typedef struct __sFILE {
unsigned char *_p;
int _r;
int _w;
short _flags;
short _file;
struct __sbuf _bf;
int _lbfsize;
void *_cookie;
int (*_close) (void *) ;
int (*_read) (void *, char *, int) ;
fpos_t (*_seek) (void *, fpos_t, int) ;
int (*_write) (void *, const char *, int) ;
struct __sbuf _ub;
unsigned char *_up;
int _ur;
unsigned char _ubuf[3];
unsigned char _nbuf[1];
struct __sbuf _lb;
int _blksize;
fpos_t _offset;
} FILE;
extern "C" {
extern FILE __sF[];
};
extern "C" {
void clearerr (FILE *) ;
int fclose (FILE *) ;
int feof (FILE *) ;
int ferror (FILE *) ;
int fflush (FILE *) ;
int fgetc (FILE *) ;
int fgetpos (FILE *, fpos_t *) ;
char *fgets (char *, int, FILE *) ;
FILE *fopen (const char *, const char *) ;
int fprintf (FILE *, const char *, ...) ;
int fputc (int, FILE *) ;
int fputs (const char *, FILE *) ;
size_t fread (void *, size_t, size_t, FILE *) ;
FILE *freopen (const char *, const char *, FILE *) ;
int fscanf (FILE *, const char *, ...) ;
int fseek (FILE *, long, int) ;
int fseeko (FILE *, off_t, int) ;
int fsetpos (FILE *, const fpos_t *) ;
long ftell (FILE *) ;
off_t ftello (FILE *) ;
size_t fwrite (const void *, size_t, size_t, FILE *) ;
int getc (FILE *) ;
int getchar (void) ;
char *gets (char *) ;
extern int sys_nerr;
extern char *sys_errlist[];
void perror (const char *) ;
int printf (const char *, ...) ;
int putc (int, FILE *) ;
int putchar (int) ;
int puts (const char *) ;
int remove (const char *) ;
int rename (const char *, const char *) ;
void rewind (FILE *) ;
int scanf (const char *, ...) ;
void setbuf (FILE *, char *) ;
int setvbuf (FILE *, char *, int, size_t) ;
int sprintf (char *, const char *, ...) ;
int sscanf (const char *, const char *, ...) ;
FILE *tmpfile (void) ;
char *tmpnam (char *) ;
int ungetc (int, FILE *) ;
int vfprintf (FILE *, const char *, char * ) ;
int vprintf (const char *, char * ) ;
int vsprintf (char *, const char *, char * ) ;
};
extern "C" {
char *ctermid (char *) ;
char *ctermid_r (char *) ;
char *cuserid (char *) ;
FILE *fdopen (int, const char *) ;
int fileno (FILE *) ;
void flockfile (FILE *) ;
int ftrylockfile (FILE *) ;
void funlockfile (FILE *) ;
void _flockfile_debug (FILE *, const char *, int) ;
int getc_unlocked (FILE *) ;
int putc_unlocked (int, FILE *) ;
int getchar_unlocked (void) ;
int putchar_unlocked (int) ;
};
extern "C" {
int asprintf (char **, const char *, ...)
__attribute__((format (printf, 2, 3)));
char *fgetln (FILE *, size_t *) ;
int fpurge (FILE *) ;
int getw (FILE *) ;
int pclose (FILE *) ;
FILE *popen (const char *, const char *) ;
int putw (int, FILE *) ;
void setbuffer (FILE *, char *, int) ;
int setlinebuf (FILE *) ;
char *tempnam (const char *, const char *) ;
int snprintf (char *, size_t, const char *, ...)
__attribute__((format (printf, 3, 4)));
int vasprintf (char **, const char *, char * )
__attribute__((format (printf, 2, 0)));
int vsnprintf (char *, size_t, const char *, char * )
__attribute__((format (printf, 3, 0)));
int vscanf (const char *, char * )
__attribute__((format (scanf, 1, 0)));
int vsscanf (const char *, const char *, char * )
__attribute__((format (scanf, 2, 0)));
};
extern "C" {
FILE *funopen (const void *,
int (*)(void *, char *, int),
int (*)(void *, const char *, int),
fpos_t (*)(void *, fpos_t, int),
int (*)(void *)) ;
};
extern "C" {
int __srget (FILE *) ;
int __svfscanf (FILE *, const char *, char * ) ;
int __swbuf (int, FILE *) ;
};
static inline int __sputc(int _c, FILE *_p) {
if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
return (*_p->_p++ = _c);
else
return (__swbuf(_c, _p));
}
# 382 "/usr/include/stdio.h" 3 4
# 44 "../qtools/qtextstream.h" 2
class QTextCodec;
class QTextDecoder;
class QTextStreamPrivate;
class QTextStream
{
public:
enum Encoding { Locale, Latin1, Unicode, UnicodeNetworkOrder,
UnicodeReverse, RawUnicode, UnicodeUTF8 };
void setEncoding( Encoding );
void setCodec( QTextCodec* );
QTextStream();
QTextStream( QIODevice * );
QTextStream( QString*, int mode );
QTextStream( QString&, int mode );
QTextStream( QByteArray, int mode );
QTextStream( FILE *, int mode );
virtual ~QTextStream();
QIODevice *device() const;
void setDevice( QIODevice * );
void unsetDevice();
bool atEnd() const;
bool eof() const;
QTextStream &operator>>( QChar & );
QTextStream &operator>>( char & );
QTextStream &operator>>( signed short & );
QTextStream &operator>>( unsigned short & );
QTextStream &operator>>( signed int & );
QTextStream &operator>>( unsigned int & );
QTextStream &operator>>( signed long & );
QTextStream &operator>>( unsigned long & );
QTextStream &operator>>( float & );
QTextStream &operator>>( double & );
QTextStream &operator>>( char * );
QTextStream &operator>>( QString & );
QTextStream &operator>>( QCString & );
QTextStream &operator<<( QChar );
QTextStream &operator<<( char );
QTextStream &operator<<( signed short );
QTextStream &operator<<( unsigned short );
QTextStream &operator<<( signed int );
QTextStream &operator<<( unsigned int );
QTextStream &operator<<( signed long );
QTextStream &operator<<( unsigned long );
QTextStream &operator<<( float );
QTextStream &operator<<( double );
QTextStream &operator<<( const char* );
QTextStream &operator<<( const QString & );
QTextStream &operator<<( const QCString & );
QTextStream &operator<<( void * );
QTextStream &readRawBytes( char *, uint len );
QTextStream &writeRawBytes( const char* , uint len );
QString readLine();
QString read();
void skipWhiteSpace();
enum {
skipws = 0x0001,
left = 0x0002,
right = 0x0004,
internal = 0x0008,
bin = 0x0010,
oct = 0x0020,
dec = 0x0040,
hex = 0x0080,
showbase = 0x0100,
showpoint = 0x0200,
uppercase = 0x0400,
showpos = 0x0800,
scientific= 0x1000,
fixed = 0x2000
};
static const int basefield;
static const int adjustfield;
static const int floatfield;
int flags() const;
int flags( int f );
int setf( int bits );
int setf( int bits, int mask );
int unsetf( int bits );
void reset();
int width() const;
int width( int );
int fill() const;
int fill( int );
int precision() const;
int precision( int );
private:
long input_int();
void init();
QTextStream &output_int( int, ulong, bool );
QIODevice *dev;
bool isNetworkOrder() { return internalOrder == QChar::networkOrdered(); }
int fflags;
int fwidth;
int fillchar;
int fprec;
bool fstrm;
bool owndev;
QTextCodec *mapper;
QTextStreamPrivate * d;
QChar ungetcBuf;
bool latin1;
bool internalOrder;
bool doUnicodeHeader;
void *reserved_ptr;
QChar eat_ws();
void ts_ungetc( QChar );
QChar ts_getc();
uint ts_getbuf( QChar*, uint );
void ts_putc(int);
void ts_putc(QChar);
bool ts_isspace(QChar);
bool ts_isdigit(QChar);
ulong input_bin();
ulong input_oct();
ulong input_dec();
ulong input_hex();
double input_double();
QTextStream &writeBlock( const char* p, uint len );
QTextStream &writeBlock( const QChar* p, uint len );
private:
QTextStream( const QTextStream & );
QTextStream &operator=( const QTextStream & );
};
typedef QTextStream QTS;
class QTextIStream : public QTextStream {
public:
QTextIStream( QString* s ) :
QTextStream(s,0x0001 ) { }
QTextIStream( QByteArray ba ) :
QTextStream(ba,0x0001 ) { }
QTextIStream( FILE *f ) :
QTextStream(f,0x0001 ) { }
};
class QTextOStream : public QTextStream {
public:
QTextOStream( QString* s ) :
QTextStream(s,0x0002 ) { }
QTextOStream( QByteArray ba ) :
QTextStream(ba,0x0002 ) { }
QTextOStream( FILE *f ) :
QTextStream(f,0x0002 ) { }
};
inline QIODevice *QTextStream::device() const
{ return dev; }
inline bool QTextStream::atEnd() const
{ return dev ? dev->atEnd() : FALSE; }
inline bool QTextStream::eof() const
{ return atEnd(); }
inline int QTextStream::flags() const
{ return fflags; }
inline int QTextStream::flags( int f )
{ int oldf = fflags; fflags = f; return oldf; }
inline int QTextStream::setf( int bits )
{ int oldf = fflags; fflags |= bits; return oldf; }
inline int QTextStream::setf( int bits, int mask )
{ int oldf = fflags; fflags = (fflags & ~mask) | (bits & mask); return oldf; }
inline int QTextStream::unsetf( int bits )
{ int oldf = fflags; fflags &= ~bits; return oldf; }
inline int QTextStream::width() const
{ return fwidth; }
inline int QTextStream::width( int w )
{ int oldw = fwidth; fwidth = w; return oldw; }
inline int QTextStream::fill() const
{ return fillchar; }
inline int QTextStream::fill( int f )
{ int oldc = fillchar; fillchar = f; return oldc; }
inline int QTextStream::precision() const
{ return fprec; }
inline int QTextStream::precision( int p )
{ int oldp = fprec; fprec = p; return oldp; }
inline QChar QTextStream::ts_getc()
{ QChar r; return ( ts_getbuf( &r,1 ) == 1 ? r : QChar((ushort)0xffff) ); }
typedef QTextStream & (*QTSFUNC)(QTextStream &);
typedef int (QTextStream::*QTSMFI)(int);
class QTSManip {
public:
QTSManip( QTSMFI m, int a ) { mf=m; arg=a; }
void exec( QTextStream &s ) { (s.*mf)(arg); }
private:
QTSMFI mf;
int arg;
};
inline QTextStream &operator>>( QTextStream &s, QTSFUNC f )
{ return (*f)( s ); }
inline QTextStream &operator<<( QTextStream &s, QTSFUNC f )
{ return (*f)( s ); }
inline QTextStream &operator<<( QTextStream &s, QTSManip m )
{ m.exec(s); return s; }
QTextStream &bin( QTextStream &s );
QTextStream &oct( QTextStream &s );
QTextStream &dec( QTextStream &s );
QTextStream &hex( QTextStream &s );
QTextStream &endl( QTextStream &s );
QTextStream &flush( QTextStream &s );
QTextStream &ws( QTextStream &s );
QTextStream &reset( QTextStream &s );
inline QTSManip qSetW( int w )
{
QTSMFI func = &QTextStream::width;
return QTSManip(func,w);
}
inline QTSManip qSetFill( int f )
{
QTSMFI func = &QTextStream::fill;
return QTSManip(func,f);
}
inline QTSManip qSetPrecision( int p )
{
QTSMFI func = &QTextStream::precision;
return QTSManip(func,p);
}
inline QTSManip setw( int w )
{
QTSMFI func = &QTextStream::width;
return QTSManip(func,w);
}
inline QTSManip setfill( int f )
{
QTSMFI func = &QTextStream::fill;
return QTSManip(func,f);
}
inline QTSManip setprecision( int p )
{
QTSMFI func = &QTextStream::precision;
return QTSManip(func,p);
}
# 20 "index.cpp" 2
# 1 "../qtools/qdatetime.h" 1
class QDate
{
public:
QDate() { jd=0; }
QDate( int y, int m, int d );
bool isNull() const { return jd == 0; }
bool isValid() const;
int year() const;
int month() const;
int day() const;
int dayOfWeek() const;
int dayOfYear() const;
int daysInMonth() const;
int daysInYear() const;
virtual QString monthName( int month ) const;
virtual QString dayName( int weekday ) const;
QString toString() const;
bool setYMD( int y, int m, int d );
QDate addDays( int days ) const;
int daysTo( const QDate & ) const;
bool operator==( const QDate &d ) const { return jd == d.jd; }
bool operator!=( const QDate &d ) const { return jd != d.jd; }
bool operator<( const QDate &d ) const { return jd < d.jd; }
bool operator<=( const QDate &d ) const { return jd <= d.jd; }
bool operator>( const QDate &d ) const { return jd > d.jd; }
bool operator>=( const QDate &d ) const { return jd >= d.jd; }
static QDate currentDate();
static bool isValid( int y, int m, int d );
static bool leapYear( int year );
protected:
static uint greg2jul( int y, int m, int d );
static void jul2greg( uint jd, int &y, int &m, int &d );
private:
static const char * const monthNames[];
static const char * const weekdayNames[];
uint jd;
friend class QDateTime;
friend QDataStream &operator<<( QDataStream &, const QDate & );
friend QDataStream &operator>>( QDataStream &, QDate & );
};
class QTime
{
public:
QTime() { ds=0; }
QTime( int h, int m, int s=0, int ms=0 );
bool isNull() const { return ds == 0; }
bool isValid() const;
int hour() const;
int minute() const;
int second() const;
int msec() const;
QString toString() const;
bool setHMS( int h, int m, int s, int ms=0 );
QTime addSecs( int secs ) const;
int secsTo( const QTime & ) const;
QTime addMSecs( int ms ) const;
int msecsTo( const QTime & ) const;
bool operator==( const QTime &d ) const { return ds == d.ds; }
bool operator!=( const QTime &d ) const { return ds != d.ds; }
bool operator<( const QTime &d ) const { return ds < d.ds; }
bool operator<=( const QTime &d ) const { return ds <= d.ds; }
bool operator>( const QTime &d ) const { return ds > d.ds; }
bool operator>=( const QTime &d ) const { return ds >= d.ds; }
static QTime currentTime();
static bool isValid( int h, int m, int s, int ms=0 );
void start();
int restart();
int elapsed();
private:
static bool currentTime( QTime * );
uint ds;
friend class QDateTime;
friend QDataStream &operator<<( QDataStream &, const QTime & );
friend QDataStream &operator>>( QDataStream &, QTime & );
};
class QDateTime
{
public:
QDateTime() {}
QDateTime( const QDate & );
QDateTime( const QDate &, const QTime & );
bool isNull() const { return d.isNull() && t.isNull(); }
bool isValid() const { return d.isValid() && t.isValid(); }
QDate date() const { return d; }
QTime time() const { return t; }
void setDate( const QDate &date ) { d=date; }
void setTime( const QTime &time ) { t=time; }
void setTime_t( uint secsSince1Jan1970UTC );
QString toString() const;
QDateTime addDays( int days ) const;
QDateTime addSecs( int secs ) const;
int daysTo( const QDateTime & ) const;
int secsTo( const QDateTime & ) const;
bool operator==( const QDateTime &dt ) const;
bool operator!=( const QDateTime &dt ) const;
bool operator<( const QDateTime &dt ) const;
bool operator<=( const QDateTime &dt ) const;
bool operator>( const QDateTime &dt ) const;
bool operator>=( const QDateTime &dt ) const;
static QDateTime currentDateTime();
private:
QDate d;
QTime t;
friend QDataStream &operator<<( QDataStream &, const QDateTime &);
friend QDataStream &operator>>( QDataStream &, QDateTime & );
};
QDataStream &operator<<( QDataStream &, const QDate & );
QDataStream &operator>>( QDataStream &, QDate & );
QDataStream &operator<<( QDataStream &, const QTime & );
QDataStream &operator>>( QDataStream &, QTime & );
QDataStream &operator<<( QDataStream &, const QDateTime & );
QDataStream &operator>>( QDataStream &, QDateTime & );
# 21 "index.cpp" 2
# 1 "../qtools/qdir.h" 1
# 1 "../qtools/qstrlist.h" 1
# 1 "../qtools/qlist.h" 1
# 1 "../qtools/qglist.h" 1
# 1 "../qtools/qcollection.h" 1
class QGVector;
class QGList;
class QGDict;
class QCollection
{
public:
bool autoDelete() const { return del_item; }
void setAutoDelete( bool enable ) { del_item = enable; }
virtual uint count() const = 0;
virtual void clear() = 0;
typedef void *Item;
protected:
QCollection() { del_item = FALSE; }
QCollection(const QCollection &) { del_item = FALSE; }
virtual ~QCollection() {}
bool del_item;
virtual Item newItem( Item );
virtual void deleteItem( Item );
};
# 42 "../qtools/qglist.h" 2
class QLNode
{
friend class QGList;
friend class QGListIterator;
public:
QCollection::Item getData() { return data; }
private:
QCollection::Item data;
QLNode *prev;
QLNode *next;
QLNode( QCollection::Item d ) { data = d; }
};
class QGList : public QCollection
{
friend class QGListIterator;
friend class QGVector;
public:
uint count() const;
QDataStream &read( QDataStream & );
QDataStream &write( QDataStream & ) const;
protected:
QGList();
QGList( const QGList & );
virtual ~QGList();
QGList &operator=( const QGList & );
bool operator==( const QGList& ) const;
void inSort( QCollection::Item );
void append( QCollection::Item );
bool insertAt( uint index, QCollection::Item );
void relinkNode( QLNode * );
bool removeNode( QLNode * );
bool remove( QCollection::Item = 0 );
bool removeRef( QCollection::Item = 0 );
bool removeFirst();
bool removeLast();
bool removeAt( uint index );
QCollection::Item takeNode( QLNode * );
QCollection::Item take();
QCollection::Item takeAt( uint index );
QCollection::Item takeFirst();
QCollection::Item takeLast();
void sort();
void clear();
int findRef( QCollection::Item, bool = TRUE );
int find( QCollection::Item, bool = TRUE );
uint containsRef( QCollection::Item ) const;
uint contains( QCollection::Item ) const;
QCollection::Item at( uint index );
int at() const;
QLNode *currentNode() const;
QCollection::Item get() const;
QCollection::Item cfirst() const;
QCollection::Item clast() const;
QCollection::Item first();
QCollection::Item last();
QCollection::Item next();
QCollection::Item prev();
void toVector( QGVector * ) const;
virtual int compareItems( QCollection::Item, QCollection::Item );
virtual QDataStream &read( QDataStream &, QCollection::Item & );
virtual QDataStream &write( QDataStream &, QCollection::Item ) const;
private:
void prepend( QCollection::Item );
void heapSortPushDown( QCollection::Item* heap, int first, int last );
QLNode *firstNode;
QLNode *lastNode;
QLNode *curNode;
int curIndex;
uint numNodes;
QGList *iterators;
QLNode *locate( uint );
QLNode *unlink();
};
inline uint QGList::count() const
{
return numNodes;
}
inline bool QGList::removeFirst()
{
first();
return remove();
}
inline bool QGList::removeLast()
{
last();
return remove();
}
inline int QGList::at() const
{
return curIndex;
}
inline QCollection::Item QGList::at( uint index )
{
QLNode *n = locate( index );
return n ? n->data : 0;
}
inline QLNode *QGList::currentNode() const
{
return curNode;
}
inline QCollection::Item QGList::get() const
{
return curNode ? curNode->data : 0;
}
inline QCollection::Item QGList::cfirst() const
{
return firstNode ? firstNode->data : 0;
}
inline QCollection::Item QGList::clast() const
{
return lastNode ? lastNode->data : 0;
}
QDataStream &operator>>( QDataStream &, QGList & );
QDataStream &operator<<( QDataStream &, const QGList & );
class QGListIterator
{
friend class QGList;
protected:
QGListIterator( const QGList & );
QGListIterator( const QGListIterator & );
QGListIterator &operator=( const QGListIterator & );
~QGListIterator();
bool atFirst() const;
bool atLast() const;
QCollection::Item toFirst();
QCollection::Item toLast();
QCollection::Item get() const;
QCollection::Item operator()();
QCollection::Item operator++();
QCollection::Item operator+=(uint);
QCollection::Item operator--();
QCollection::Item operator-=(uint);
protected:
QGList *list;
private:
QLNode *curNode;
};
inline bool QGListIterator::atFirst() const
{
return curNode == list->firstNode;
}
inline bool QGListIterator::atLast() const
{
return curNode == list->lastNode;
}
inline QCollection::Item QGListIterator::get() const
{
return curNode ? curNode->data : 0;
}
# 42 "../qtools/qlist.h" 2
template<class type> class QList : public QGList
{
public:
QList() {}
QList( const QList<type> &l ) : QGList(l) {}
~QList() { clear(); }
QList<type> &operator=(const QList<type> &l)
{ return (QList<type>&)QGList::operator=(l); }
bool operator==( const QList<type> &list ) const
{ return QGList::operator==( list ); }
uint count() const { return QGList::count(); }
bool isEmpty() const { return QGList::count() == 0; }
bool insert( uint i, const type *d){ return QGList::insertAt(i,(QCollection::Item)d); }
void inSort( const type *d ) { QGList::inSort((QCollection::Item)d); }
void prepend( const type *d ) { QGList::insertAt(0,(QCollection::Item)d); }
void append( const type *d ) { QGList::append((QCollection::Item)d); }
bool remove( uint i ) { return QGList::removeAt(i); }
bool remove() { return QGList::remove((QCollection::Item)0); }
bool remove( const type *d ) { return QGList::remove((QCollection::Item)d); }
bool removeRef( const type *d ) { return QGList::removeRef((QCollection::Item)d); }
void removeNode( QLNode *n ) { QGList::removeNode(n); }
bool removeFirst() { return QGList::removeFirst(); }
bool removeLast() { return QGList::removeLast(); }
type *take( uint i ) { return (type *)QGList::takeAt(i); }
type *take() { return (type *)QGList::take(); }
type *takeNode( QLNode *n ) { return (type *)QGList::takeNode(n); }
void clear() { QGList::clear(); }
void sort() { QGList::sort(); }
int find( const type *d ) { return QGList::find((QCollection::Item)d); }
int findNext( const type *d ) { return QGList::find((QCollection::Item)d,FALSE); }
int findRef( const type *d ) { return QGList::findRef((QCollection::Item)d); }
int findNextRef( const type *d ){ return QGList::findRef((QCollection::Item)d,FALSE);}
uint contains( const type *d ) const { return QGList::contains((QCollection::Item)d); }
uint containsRef( const type *d ) const
{ return QGList::containsRef((QCollection::Item)d); }
type *at( uint i ) { return (type *)QGList::at(i); }
int at() const { return QGList::at(); }
type *current() const { return (type *)QGList::get(); }
QLNode *currentNode() const { return QGList::currentNode(); }
type *getFirst() const { return (type *)QGList::cfirst(); }
type *getLast() const { return (type *)QGList::clast(); }
type *first() { return (type *)QGList::first(); }
type *last() { return (type *)QGList::last(); }
type *next() { return (type *)QGList::next(); }
type *prev() { return (type *)QGList::prev(); }
void toVector( QGVector *vec )const{ QGList::toVector(vec); }
private:
void deleteItem( QCollection::Item d );
};
template<> inline void QList<void>::deleteItem( QCollection::Item )
{
}
template<class type> inline void QList<type>::deleteItem( QCollection::Item d )
{
if ( del_item ) delete (type *)d;
}
template<class type> class QListIterator : public QGListIterator
{
public:
QListIterator(const QList<type> &l) :QGListIterator((QGList &)l) {}
~QListIterator() {}
uint count() const { return list->count(); }
bool isEmpty() const { return list->count() == 0; }
bool atFirst() const { return QGListIterator::atFirst(); }
bool atLast() const { return QGListIterator::atLast(); }
type *toFirst() { return (type *)QGListIterator::toFirst(); }
type *toLast() { return (type *)QGListIterator::toLast(); }
operator type *() const { return (type *)QGListIterator::get(); }
type *operator*() { return (type *)QGListIterator::get(); }
type *current() const { return (type *)QGListIterator::get(); }
type *operator()() { return (type *)QGListIterator::operator()();}
type *operator++() { return (type *)QGListIterator::operator++(); }
type *operator+=(uint j) { return (type *)QGListIterator::operator+=(j);}
type *operator--() { return (type *)QGListIterator::operator--(); }
type *operator-=(uint j) { return (type *)QGListIterator::operator-=(j);}
QListIterator<type>& operator=(const QListIterator<type>&it)
{ QGListIterator::operator=(it); return *this; }
};
# 43 "../qtools/qstrlist.h" 2
# 1 "../qtools/qdatastream.h" 1
class QDataStream
{
public:
QDataStream();
QDataStream( QIODevice * );
QDataStream( QByteArray, int mode );
virtual ~QDataStream();
QIODevice *device() const;
void setDevice( QIODevice * );
void unsetDevice();
bool atEnd() const;
bool eof() const;
enum ByteOrder { BigEndian, LittleEndian };
int byteOrder() const;
void setByteOrder( int );
bool isPrintableData() const;
void setPrintableData( bool );
int version() const;
void setVersion( int );
QDataStream &operator>>( Q_INT8 &i );
QDataStream &operator>>( Q_UINT8 &i );
QDataStream &operator>>( Q_INT16 &i );
QDataStream &operator>>( Q_UINT16 &i );
QDataStream &operator>>( Q_INT32 &i );
QDataStream &operator>>( Q_UINT32 &i );
QDataStream &operator>>( Q_INT64 &i );
QDataStream &operator>>( Q_UINT64 &i );
QDataStream &operator>>( float &f );
QDataStream &operator>>( double &f );
QDataStream &operator>>( char *&str );
QDataStream &operator<<( Q_INT8 i );
QDataStream &operator<<( Q_UINT8 i );
QDataStream &operator<<( Q_INT16 i );
QDataStream &operator<<( Q_UINT16 i );
QDataStream &operator<<( Q_INT32 i );
QDataStream &operator<<( Q_UINT32 i );
QDataStream &operator<<( Q_INT64 i );
QDataStream &operator<<( Q_UINT64 i );
QDataStream &operator<<( float f );
QDataStream &operator<<( double f );
QDataStream &operator<<( const char *str );
QDataStream &readBytes( char *&, uint &len );
QDataStream &readRawBytes( char *, uint len );
QDataStream &writeBytes( const char *, uint len );
QDataStream &writeRawBytes( const char *, uint len );
private:
QIODevice *dev;
bool owndev;
int byteorder;
bool printable;
bool noswap;
int ver;
private:
QDataStream( const QDataStream & );
QDataStream &operator=( const QDataStream & );
};
inline QIODevice *QDataStream::device() const
{ return dev; }
inline bool QDataStream::atEnd() const
{ return dev ? dev->atEnd() : TRUE; }
inline bool QDataStream::eof() const
{ return atEnd(); }
inline int QDataStream::byteOrder() const
{ return byteorder; }
inline bool QDataStream::isPrintableData() const
{ return printable; }
inline void QDataStream::setPrintableData( bool p )
{ printable = p; }
inline int QDataStream::version() const
{ return ver; }
inline void QDataStream::setVersion( int v )
{ ver = v; }
inline QDataStream &QDataStream::operator>>( Q_UINT8 &i )
{ return *this >> (Q_INT8&)i; }
inline QDataStream &QDataStream::operator>>( Q_UINT16 &i )
{ return *this >> (Q_INT16&)i; }
inline QDataStream &QDataStream::operator>>( Q_UINT32 &i )
{ return *this >> (Q_INT32&)i; }
inline QDataStream &QDataStream::operator>>( Q_UINT64 &i )
{ return *this >> (Q_INT64&)i; }
inline QDataStream &QDataStream::operator<<( Q_UINT8 i )
{ return *this << (Q_INT8)i; }
inline QDataStream &QDataStream::operator<<( Q_UINT16 i )
{ return *this << (Q_INT16)i; }
inline QDataStream &QDataStream::operator<<( Q_UINT32 i )
{ return *this << (Q_INT32)i; }
inline QDataStream &QDataStream::operator<<( Q_UINT64 i )
{ return *this << (Q_INT64)i; }
# 44 "../qtools/qstrlist.h" 2
typedef QList<char> QStrListBase;
typedef QListIterator<char> QStrListIterator;
class QStrList : public QStrListBase
{
public:
QStrList( bool deepCopies=TRUE ) { dc = deepCopies; del_item = deepCopies; }
QStrList( const QStrList & );
~QStrList() { clear(); }
QStrList& operator=( const QStrList & );
private:
QCollection::Item newItem( QCollection::Item d ) { return dc ? qstrdup( (const char*)d ) : d; }
void deleteItem( QCollection::Item d ) { if ( del_item ) delete[] (char*)d; }
int compareItems( QCollection::Item s1, QCollection::Item s2 ) { return qstrcmp((const char*)s1,
(const char*)s2); }
QDataStream &read( QDataStream &s, QCollection::Item &d )
{ s >> (char *&)d; return s; }
QDataStream &write( QDataStream &s, QCollection::Item d ) const
{ return s << (const char *)d; }
bool dc;
};
class QStrIList : public QStrList
{
public:
QStrIList( bool deepCopies=TRUE ) : QStrList( deepCopies ) {}
~QStrIList() { clear(); }
private:
int compareItems( QCollection::Item s1, QCollection::Item s2 )
{ return qstricmp((const char*)s1,
(const char*)s2); }
};
inline QStrList & QStrList::operator=( const QStrList &strList )
{
clear();
dc = strList.dc;
del_item = dc;
QStrListBase::operator=(strList);
return *this;
}
inline QStrList::QStrList( const QStrList &strList )
: QStrListBase( strList )
{
dc = FALSE;
operator=(strList);
}
# 42 "../qtools/qdir.h" 2
# 1 "../qtools/qfileinfo.h" 1
# 1 "../qtools/qfile.h" 1
class QDir;
class QFile : public QIODevice
{
public:
QFile();
QFile( const QString &name );
~QFile();
QString name() const;
void setName( const QString &name );
typedef QCString (*EncoderFn)( const QString &fileName );
typedef QString (*DecoderFn)( const QCString &localfileName );
static QCString encodeName( const QString &fileName );
static QString decodeName( const QCString &localFileName );
static void setEncodingFunction( EncoderFn );
static void setDecodingFunction( DecoderFn );
bool exists() const;
static bool exists( const QString &fileName );
bool remove();
static bool remove( const QString &fileName );
bool open( int );
bool open( int, FILE * );
bool open( int, int );
void close();
void flush();
uint size() const;
int at() const;
bool at( int );
bool atEnd() const;
int readBlock( char *data, uint len );
int writeBlock( const char *data, uint len );
int writeBlock( const QByteArray& data )
{ return QIODevice::writeBlock(data); }
int readLine( char *data, uint maxlen );
int readLine( QString &, uint maxlen );
int getch();
int putch( int );
int ungetch( int );
int handle() const;
protected:
QString fn;
FILE *fh;
int fd;
int length;
bool ext_f;
void * d;
private:
void init();
QCString ungetchBuffer;
private:
QFile( const QFile & );
QFile &operator=( const QFile & );
};
inline QString QFile::name() const
{ return fn; }
inline int QFile::at() const
{ return ioIndex; }
# 42 "../qtools/qfileinfo.h" 2
class QDir;
struct QFileInfoCache;
class QFileInfo
{
public:
enum PermissionSpec {
ReadUser = 0400, WriteUser = 0200, ExeUser = 0100,
ReadGroup = 0040, WriteGroup = 0020, ExeGroup = 0010,
ReadOther = 0004, WriteOther = 0002, ExeOther = 0001 };
QFileInfo();
QFileInfo( const QString &file );
QFileInfo( const QFile & );
QFileInfo( const QDir &, const QString &fileName );
QFileInfo( const QFileInfo & );
~QFileInfo();
QFileInfo &operator=( const QFileInfo & );
void setFile( const QString &file );
void setFile( const QFile & );
void setFile( const QDir &, const QString &fileName );
bool exists() const;
void refresh() const;
bool caching() const;
void setCaching( bool );
QString filePath() const;
QString fileName() const;
QString absFilePath() const;
QString baseName() const;
QString extension( bool complete = TRUE ) const;
QString dirPath( bool absPath = FALSE ) const;
QDir dir( bool absPath = FALSE ) const;
bool isReadable() const;
bool isWritable() const;
bool isExecutable() const;
bool isRelative() const;
bool convertToAbs();
bool isFile() const;
bool isDir() const;
bool isSymLink() const;
QString readLink() const;
QString owner() const;
uint ownerId() const;
QString group() const;
uint groupId() const;
bool permission( int permissionSpec ) const;
uint size() const;
QDateTime lastModified() const;
QDateTime lastRead() const;
private:
void doStat() const;
static void slashify( QString & );
static void makeAbs( QString & );
QString fn;
QFileInfoCache *fic;
bool cache;
};
inline bool QFileInfo::caching() const
{
return cache;
}
# 43 "../qtools/qdir.h" 2
typedef QList<QFileInfo> QFileInfoList;
typedef QListIterator<QFileInfo> QFileInfoListIterator;
class QStringList;
class QDir
{
public:
enum FilterSpec { Dirs = 0x001,
Files = 0x002,
Drives = 0x004,
NoSymLinks = 0x008,
All = 0x007,
TypeMask = 0x00F,
Readable = 0x010,
Writable = 0x020,
Executable = 0x040,
RWEMask = 0x070,
Modified = 0x080,
Hidden = 0x100,
System = 0x200,
AccessMask = 0x3F0,
DefaultFilter = -1 };
enum SortSpec { Name = 0x00,
Time = 0x01,
Size = 0x02,
Unsorted = 0x03,
SortByMask = 0x03,
DirsFirst = 0x04,
Reversed = 0x08,
IgnoreCase = 0x10,
DefaultSort = -1 };
QDir();
QDir( const QString &path, const QString &nameFilter = QString::null,
int sortSpec = Name | IgnoreCase, int filterSpec = All );
QDir( const QDir & );
virtual ~QDir();
QDir &operator=( const QDir & );
QDir &operator=( const QString &path );
virtual void setPath( const QString &path );
virtual QString path() const;
virtual QString absPath() const;
virtual QString canonicalPath() const;
virtual QString dirName() const;
virtual QString filePath( const QString &fileName,
bool acceptAbsPath = TRUE ) const;
virtual QString absFilePath( const QString &fileName,
bool acceptAbsPath = TRUE ) const;
static QString convertSeparators( const QString &pathName );
virtual bool cd( const QString &dirName, bool acceptAbsPath = TRUE );
virtual bool cdUp();
QString nameFilter() const;
virtual void setNameFilter( const QString &nameFilter );
FilterSpec filter() const;
virtual void setFilter( int filterSpec );
SortSpec sorting() const;
virtual void setSorting( int sortSpec );
bool matchAllDirs() const;
virtual void setMatchAllDirs( bool );
uint count() const;
QString operator[]( int ) const;
virtual QStrList encodedEntryList( int filterSpec = DefaultFilter,
int sortSpec = DefaultSort ) const;
virtual QStrList encodedEntryList( const QString &nameFilter,
int filterSpec = DefaultFilter,
int sortSpec = DefaultSort ) const;
virtual QStringList entryList( int filterSpec = DefaultFilter,
int sortSpec = DefaultSort ) const;
virtual QStringList entryList( const QString &nameFilter,
int filterSpec = DefaultFilter,
int sortSpec = DefaultSort ) const;
virtual const QFileInfoList *entryInfoList( int filterSpec = DefaultFilter,
int sortSpec = DefaultSort ) const;
virtual const QFileInfoList *entryInfoList( const QString &nameFilter,
int filterSpec = DefaultFilter,
int sortSpec = DefaultSort ) const;
static const QFileInfoList *drives();
virtual bool mkdir( const QString &dirName,
bool acceptAbsPath = TRUE ) const;
virtual bool rmdir( const QString &dirName,
bool acceptAbsPath = TRUE ) const;
virtual bool isReadable() const;
virtual bool exists() const;
virtual bool isRoot() const;
virtual bool isRelative() const;
virtual void convertToAbs();
virtual bool operator==( const QDir & ) const;
virtual bool operator!=( const QDir & ) const;
virtual bool remove( const QString &fileName,
bool acceptAbsPath = TRUE );
virtual bool rename( const QString &name, const QString &newName,
bool acceptAbsPaths = TRUE );
virtual bool exists( const QString &name,
bool acceptAbsPath = TRUE );
static char separator();
static bool setCurrent( const QString &path );
static QDir current();
static QDir home();
static QDir root();
static QString currentDirPath();
static QString homeDirPath();
static QString rootDirPath();
static bool match( const QStringList &filters, const QString &fileName );
static bool match( const QString &filter, const QString &fileName );
static QString cleanDirPath( const QString &dirPath );
static bool isRelativePath( const QString &path );
private:
void init();
virtual bool readDirEntries( const QString &nameFilter,
int FilterSpec, int SortSpec );
static void slashify ( QString &);
QString dPath;
QStringList *fList;
QFileInfoList *fiList;
QString nameFilt;
FilterSpec filtS;
SortSpec sortS;
uint dirty : 1;
uint allDirs : 1;
};
inline QString QDir::path() const
{
return dPath;
}
inline QString QDir::nameFilter() const
{
return nameFilt;
}
inline QDir::FilterSpec QDir::filter() const
{
return filtS;
}
inline QDir::SortSpec QDir::sorting() const
{
return sortS;
}
inline bool QDir::matchAllDirs() const
{
return allDirs;
}
inline bool QDir::operator!=( const QDir &d ) const
{
return !(*this == d);
}
struct QDirSortItem {
QString filename_cache;
QFileInfo* item;
};
# 22 "index.cpp" 2
# 1 "message.h" 1
extern void msg(const char *fmt, ...);
extern void warn(const char *file,int line,const char *fmt, ...);
extern void warn_cont(const char *fmt, ...);
extern void warn_undoc(const char *file,int line,const char *fmt, ...);
extern void err(const char *fmt, ...);
void initWarningFormat();
# 24 "index.cpp" 2
# 1 "index.h" 1
# 1 "qtbc.h" 1
# 1 "/usr/include/locale.h" 1 3 4
struct lconv {
char *decimal_point;
char *thousands_sep;
char *grouping;
char *int_curr_symbol;
char *currency_symbol;
char *mon_decimal_point;
char *mon_thousands_sep;
char *mon_grouping;
char *positive_sign;
char *negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;
};
extern "C" {
struct lconv *localeconv (void) ;
char *setlocale (int, const char *) ;
};
# 29 "qtbc.h" 2
inline QCString convertToQCString(const QString &s) { return s.latin1(); }
# 21 "index.h" 2
enum IndexSections
{
isTitlePageStart,
isTitlePageAuthor,
isMainPage,
isPackageIndex,
isModuleIndex,
isNamespaceIndex,
isClassHierarchyIndex,
isCompoundIndex,
isFileIndex,
isPageIndex,
isPackageDocumentation,
isModuleDocumentation,
isNamespaceDocumentation,
isClassDocumentation,
isFileDocumentation,
isExampleDocumentation,
isPageDocumentation,
isEndIndex
};
class OutputList;
void writeIndex(OutputList &ol);
void writeHierarchicalIndex(OutputList &ol);
void writeAlphabeticalIndex(OutputList &ol);
void writeClassHierarchy(OutputList &ol);
void writeFileIndex(OutputList &ol);
void writeSourceIndex(OutputList &ol);
void writeAnnotatedIndex(OutputList &ol);
void writeAnnotatedClassList(OutputList &ol);
void writeMemberIndex(OutputList &ol);
void writeMemberList(OutputList &ol,bool useSections);
void writeHeaderIndex(OutputList &ol);
void writeHeaderFileList(OutputList &ol);
void writeExampleIndex(OutputList &ol);
void writePageIndex(OutputList &ol);
void writeFileMemberIndex(OutputList &ol);
void writeGroupIndex(OutputList &ol);
void writeNamespaceIndex(OutputList &ol);
void writeNamespaceMemberIndex(OutputList &ol);
void writeGraphicalClassHierarchy(OutputList &ol);
void writeGraphInfo(OutputList &ol);
void writePackageIndex(OutputList &ol);
void countDataStructures();
extern int annotatedClasses;
extern int hierarchyClasses;
extern int documentedFunctions;
extern int documentedMembers;
extern int documentedDefines;
extern int documentedFiles;
extern int documentedHtmlFiles;
extern int documentedGroups;
extern int documentedNamespaces;
extern int documentedNamespaceMembers;
extern int documentedIncludeFiles;
extern int documentedPages;
extern int indexedPages;
extern int documentedPackages;
void startTitle(OutputList &ol,const char *fileName);
void endTitle(OutputList &ol,const char *fileName,const char *name);
void startFile(OutputList &ol,const char *name,const char *title,bool external=FALSE);
void endFile(OutputList &ol,bool external=FALSE);
# 25 "index.cpp" 2
# 1 "doxygen.h" 1
# 1 "groupdef.h" 1
# 1 "../qtools/qdict.h" 1
# 1 "../qtools/qgdict.h" 1
class QGDictIterator;
class QGDItList;
class QBaseBucket
{
public:
QCollection::Item getData() { return data; }
QCollection::Item setData( QCollection::Item d ) { return data = d; }
QBaseBucket *getNext() { return next; }
void setNext( QBaseBucket *n) { next = n; }
protected:
QBaseBucket( QCollection::Item d, QBaseBucket *n ) : data(d), next(n) {}
QCollection::Item data;
QBaseBucket *next;
};
class QStringBucket : public QBaseBucket
{
public:
QStringBucket( const QString &k, QCollection::Item d, QBaseBucket *n )
: QBaseBucket(d,n), key(k) {}
const QString &getKey() const { return key; }
private:
QString key;
};
class QAsciiBucket : public QBaseBucket
{
public:
QAsciiBucket( const char *k, QCollection::Item d, QBaseBucket *n )
: QBaseBucket(d,n), key(k) {}
const char *getKey() const { return key; }
private:
const char *key;
};
class QIntBucket : public QBaseBucket
{
public:
QIntBucket( long k, QCollection::Item d, QBaseBucket *n )
: QBaseBucket(d,n), key(k) {}
long getKey() const { return key; }
private:
long key;
};
class QPtrBucket : public QBaseBucket
{
public:
QPtrBucket( void *k, QCollection::Item d, QBaseBucket *n )
: QBaseBucket(d,n), key(k) {}
void *getKey() const { return key; }
private:
void *key;
};
class QGDict : public QCollection
{
public:
uint count() const { return numItems; }
uint size() const { return vlen; }
QCollection::Item look_string( const QString& key, QCollection::Item,
int );
QCollection::Item look_ascii( const char *key, QCollection::Item, int );
QCollection::Item look_int( long key, QCollection::Item, int );
QCollection::Item look_ptr( void *key, QCollection::Item, int );
QDataStream &read( QDataStream & );
QDataStream &write( QDataStream & ) const;
protected:
enum KeyType { StringKey, AsciiKey, IntKey, PtrKey };
QGDict( uint len, KeyType kt, bool cs, bool ck );
QGDict( const QGDict & );
~QGDict();
QGDict &operator=( const QGDict & );
bool remove_string( const QString &key, QCollection::Item item=0 );
bool remove_ascii( const char *key, QCollection::Item item=0 );
bool remove_int( long key, QCollection::Item item=0 );
bool remove_ptr( void *key, QCollection::Item item=0 );
QCollection::Item take_string( const QString &key );
QCollection::Item take_ascii( const char *key );
QCollection::Item take_int( long key );
QCollection::Item take_ptr( void *key );
void clear();
void resize( uint );
int hashKeyString( const QString & );
int hashKeyAscii( const char * );
void statistics() const;
virtual QDataStream &read( QDataStream &, QCollection::Item & );
virtual QDataStream &write( QDataStream &, QCollection::Item ) const;
private:
QBaseBucket **vec;
uint vlen;
uint numItems;
uint keytype : 2;
uint cases : 1;
uint copyk : 1;
QGDItList *iterators;
void unlink_common( int, QBaseBucket *, QBaseBucket * );
QStringBucket *unlink_string( const QString &,
QCollection::Item item = 0 );
QAsciiBucket *unlink_ascii( const char *, QCollection::Item item = 0 );
QIntBucket *unlink_int( long, QCollection::Item item = 0 );
QPtrBucket *unlink_ptr( void *, QCollection::Item item = 0 );
void init( uint, KeyType, bool, bool );
friend class QGDictIterator;
};
class QGDictIterator
{
friend class QGDict;
public:
QGDictIterator( const QGDict & );
QGDictIterator( const QGDictIterator & );
QGDictIterator &operator=( const QGDictIterator & );
~QGDictIterator();
QCollection::Item toFirst();
QCollection::Item get() const;
QString getKeyString() const;
const char *getKeyAscii() const;
long getKeyInt() const;
void *getKeyPtr() const;
QCollection::Item operator()();
QCollection::Item operator++();
QCollection::Item operator+=(uint);
protected:
QGDict *dict;
private:
QBaseBucket *curNode;
uint curIndex;
};
inline QCollection::Item QGDictIterator::get() const
{
return curNode ? curNode->getData() : 0;
}
inline QString QGDictIterator::getKeyString() const
{
return curNode ? ((QStringBucket*)curNode)->getKey() : QString::null;
}
inline const char *QGDictIterator::getKeyAscii() const
{
return curNode ? ((QAsciiBucket*)curNode)->getKey() : 0;
}
inline long QGDictIterator::getKeyInt() const
{
return curNode ? ((QIntBucket*)curNode)->getKey() : 0;
}
inline void *QGDictIterator::getKeyPtr() const
{
return curNode ? ((QPtrBucket*)curNode)->getKey() : 0;
}
# 42 "../qtools/qdict.h" 2
template<class type> class QDict : public QGDict
{
public:
QDict(int size=17, bool caseSensitive=TRUE)
: QGDict(size,StringKey,caseSensitive,FALSE) {}
QDict( const QDict<type> &d ) : QGDict(d) {}
~QDict() { clear(); }
QDict<type> &operator=(const QDict<type> &d)
{ return (QDict<type>&)QGDict::operator=(d); }
uint count() const { return QGDict::count(); }
uint size() const { return QGDict::size(); }
bool isEmpty() const { return QGDict::count() == 0; }
void insert( const QString &k, const type *d )
{ QGDict::look_string(k,(Item)d,1); }
void replace( const QString &k, const type *d )
{ QGDict::look_string(k,(Item)d,2); }
bool remove( const QString &k ) { return QGDict::remove_string(k); }
type *take( const QString &k ) { return (type *)QGDict::take_string(k); }
type *find( const QString &k ) const
{ return (type *)((QGDict*)this)->QGDict::look_string(k,0,0); }
type *operator[]( const QString &k ) const
{ return (type *)((QGDict*)this)->QGDict::look_string(k,0,0); }
void clear() { QGDict::clear(); }
void resize( uint n ) { QGDict::resize(n); }
void statistics() const { QGDict::statistics(); }
private:
void deleteItem( Item d );
};
template<> inline void QDict<void>::deleteItem( Item )
{
}
template<class type> inline void QDict<type>::deleteItem( QCollection::Item d )
{
if ( del_item ) delete (type *)d;
}
template<class type> class QDictIterator : public QGDictIterator
{
public:
QDictIterator(const QDict<type> &d) :QGDictIterator((QGDict &)d) {}
~QDictIterator() {}
uint count() const { return dict->count(); }
bool isEmpty() const { return dict->count() == 0; }
type *toFirst() { return (type *)QGDictIterator::toFirst(); }
operator type *() const { return (type *)QGDictIterator::get(); }
type *current() const { return (type *)QGDictIterator::get(); }
QString currentKey() const{ return QGDictIterator::getKeyString(); }
type *operator()() { return (type *)QGDictIterator::operator()(); }
type *operator++() { return (type *)QGDictIterator::operator++(); }
type *operator+=(uint j) { return (type *)QGDictIterator::operator+=(j);}
};
# 23 "groupdef.h" 2
# 1 "definition.h" 1
class FileDef;
class OutputList;
class SectionDict;
class MemberList;
class MemberDict;
class MemberDef;
class Definition
{
public:
enum DefType
{
TypeClass, TypeMember, TypeFile, TypeGroup, TypeNamespace, TypePackage
};
virtual DefType definitionType() = 0;
Definition(
const char *defFileName,int defLine,
const char *name,const char *b=0,const char *d=0);
virtual ~Definition();
const QCString& name() const { return n; }
virtual QCString getOutputFileBase() const = 0;
const QCString sourceName() const { return getOutputFileBase()+"-source"; }
const QCString& documentation() const { return doc; }
const QCString& briefDescription() const { return brief; }
void setName(const char *name) { n=name; }
void setDocumentation(const char *d,bool stripWhiteSpace=TRUE)
{
if (stripWhiteSpace)
doc=((QCString)d).stripWhiteSpace();
else
doc=d;
}
void setBriefDescription(const char *b);
virtual bool hasDocumentation();
virtual bool isLinkableInProject() = 0;
virtual bool isLinkable() = 0;
bool isReference() const { return !ref.isEmpty(); }
void setReference(const char *r) { ref=r; }
QCString getReference() const { return ref; }
QCString nameToFile(const char *name,bool allowDot=FALSE);
void addSectionsToDefinition(QList<QCString> *anchorList);
void writeDocAnchorsToTagFile();
void setBodySegment(int bls,int ble)
{
startBodyLine=bls;
endBodyLine=ble;
}
void setBodyDef(FileDef *fd) { bodyDef=fd; }
int getStartBodyLine() const { return startBodyLine; }
int getEndBodyLine() const { return endBodyLine; }
FileDef *getBodyDef() { return bodyDef; }
void writeSourceDef(OutputList &ol,const char *scopeName);
void writeInlineCode(OutputList &ol,const char *scopeName);
void writeSourceRefs(OutputList &ol,const char *scopeName);
void addSourceReference(MemberDef *d);
void setRefItems(int todoId,int testId,int bugId)
{
if (todoId!=0) m_todoId=todoId;
if (testId!=0) m_testId=testId;
if (bugId!=0) m_bugId=bugId;
}
int todoId() const { return m_todoId; }
int testId() const { return m_testId; }
int bugId() const { return m_bugId; }
QCString getDefFileName() const { return defFileName; }
int getDefLine() const { return defLine; }
protected:
int startBodyLine;
int endBodyLine;
FileDef *bodyDef;
QCString defFileName;
int defLine;
private:
QCString n;
QCString brief;
QCString doc;
QCString ref;
SectionDict *sectionDict;
MemberList *sourceRefList;
MemberDict *sourceRefDict;
int m_testId;
int m_todoId;
int m_bugId;
};
class DefinitionList : public QList<Definition>
{
public:
~DefinitionList() {}
int compareItems(QCollection::Item item1,QCollection::Item item2)
{
return qstricmp (((Definition *)item1)->name(),
((Definition *)item2)->name()
);
}
};
class DefinitionListIterator : public QListIterator<Definition>
{
public:
DefinitionListIterator(const DefinitionList &l) :
QListIterator<Definition>(l) {}
~DefinitionListIterator() {}
};
# 24 "groupdef.h" 2
# 1 "memberlist.h" 1
# 1 "memberdef.h" 1
# 1 "entry.h" 1
enum Protection { Public, Protected, Private } ;
enum Specifier { Normal, Virtual, Pure } ;
enum MethodTypes { Method, Signal, Slot, DCOP, Property };
struct BaseInfo
{
BaseInfo(const char *n,Protection p,Specifier v) : name(n),prot(p),virt(v) {}
QCString name;
Protection prot;
Specifier virt;
};
struct Argument
{
Argument() {}
Argument(const Argument &a)
{
attrib=a.attrib.copy();
type=a.type.copy();
name=a.name.copy();
defval=a.defval.copy();
docs=a.docs.copy();
array=a.array.copy();
}
Argument &operator=(const Argument &a)
{
if (this!=&a)
{
attrib=a.attrib.copy();
type=a.type.copy();
name=a.name.copy();
defval=a.defval.copy();
docs=a.docs.copy();
array=a.array.copy();
}
return *this;
}
bool hasDocumentation() const
{
return !name.isEmpty() && !docs.isEmpty();
}
QCString attrib;
QCString type;
QCString name;
QCString array;
QCString defval;
QCString docs;
};
class ArgumentList : public QList<Argument>
{
public:
ArgumentList() : QList<Argument>(),
constSpecifier(FALSE),
volatileSpecifier(FALSE),
pureSpecifier(FALSE) {}
~ArgumentList() {}
bool hasDocumentation() const;
bool constSpecifier;
bool volatileSpecifier;
bool pureSpecifier;
};
typedef QListIterator<Argument> ArgumentListIterator;
struct TagInfo
{
QCString tagName;
QCString fileName;
QCString anchor;
};
class Entry
{
public:
enum Sections {
CLASS_SEC = 0x00000001,
STRUCT_SEC = 0x00000002,
UNION_SEC = 0x00000004,
EXCEPTION_SEC = 0x00000008,
NAMESPACE_SEC = 0x00000010,
INTERFACE_SEC = 0x00000020,
COMPOUND_MASK = CLASS_SEC | STRUCT_SEC | UNION_SEC |
INTERFACE_SEC | EXCEPTION_SEC,
SCOPE_MASK = COMPOUND_MASK | NAMESPACE_SEC,
CLASSDOC_SEC = 0x00000100,
STRUCTDOC_SEC = 0x00000200,
UNIONDOC_SEC = 0x00000400,
EXCEPTIONDOC_SEC = 0x00000800,
NAMESPACEDOC_SEC = 0x00001000,
INTERFACEDOC_SEC = 0x00002000,
COMPOUNDDOC_MASK = CLASSDOC_SEC | STRUCTDOC_SEC | UNIONDOC_SEC |
INTERFACEDOC_SEC | EXCEPTIONDOC_SEC,
SOURCE_SEC = 0x00010000,
HEADER_SEC = 0x00020000,
FILE_MASK = SOURCE_SEC | HEADER_SEC,
ENUMDOC_SEC = 0x00100000,
ENUM_SEC = 0x00200000,
EMPTY_SEC = 0x00300000,
PAGEDOC_SEC = 0x00400000,
VARIABLE_SEC = 0x00500000,
FUNCTION_SEC = 0x00600000,
TYPEDEF_SEC = 0x00700000,
MEMBERDOC_SEC = 0x00800000,
OVERLOADDOC_SEC = 0x00900000,
EXAMPLE_SEC = 0x00a00000,
VARIABLEDOC_SEC = 0x00b00000,
FILEDOC_SEC = 0x00c00000,
DEFINEDOC_SEC = 0x00d00000,
INCLUDE_SEC = 0x00e00000,
DEFINE_SEC = 0x00f00000,
GROUPDOC_SEC = 0x01000000,
USINGDIR_SEC = 0x01100000,
MAINPAGEDOC_SEC = 0x01200000,
MEMBERGRP_SEC = 0x01300000,
USINGDECL_SEC = 0x01400000,
PACKAGE_SEC = 0x01500000
};
enum MemberSpecifier
{
Inline = 0x1,
Explicit = 0x2,
Mutable = 0x4
};
Entry();
Entry(const Entry &);
~Entry();
int getSize();
void addSubEntry (Entry* e) ;
void reset();
int section;
Protection protection;
MethodTypes mtype;
bool stat;
bool explicitExternal;
bool proto;
int memSpec;
int initLines;
bool subGrouping;
Specifier virt;
Entry *parent;
QCString type;
QCString name;
QCString args;
QCString bitfields;
ArgumentList *argList;
ArgumentList *tArgList;
ArgumentList *mtArgList;
QCString scopeSpec;
QCString memberSpec;
QCString program;
QCString initializer;
QCString includeFile;
QCString includeName;
QCString doc;
QCString relates;
QCString brief;
QCString inside;
QCString exception;
int bodyLine;
int endBodyLine;
int mGrpId;
QList<Entry> *sublist;
QList<BaseInfo> *extends;
QList<QCString> *groups;
QList<QCString> *anchors;
QCString fileName;
int startLine;
int todoId;
int testId;
int bugId;
TagInfo *tagInfo;
static int num;
private:
Entry &operator=(const Entry &);
} ;
typedef QList<Entry> EntryList;
typedef QListIterator<Entry> EntryListIterator;
# 25 "memberdef.h" 2
class ClassDef;
class NamespaceDef;
class GroupDef;
class FileDef;
class MemberList;
class MemberGroup;
class ExampleList;
class ExampleDict;
class OutputList;
class GroupDef;
class QTextStream;
struct SourceReference
{
FileDef *fd;
QCString anchor;
};
class MemberDef : public Definition
{
public:
enum MemberType {
Define,
Function,
Variable,
Typedef,
Enumeration,
EnumValue,
Prototype,
Signal,
Slot,
Friend,
DCOP,
Property
};
MemberDef(const char *defFileName,int defLine,
const char *type,const char *name,const char *args,
const char *excp,Protection prot,Specifier virt,bool stat,
bool related,MemberType t,const ArgumentList *tal,
const ArgumentList *al);
~MemberDef();
DefType definitionType() { return TypeMember; }
QCString getOutputFileBase() const;
const char *declaration() const { return decl; }
const char *definition() const { return def; }
const char *typeString() const { return type; }
const char *argsString() const { return args; }
const char *excpString() const { return exception; }
const char *bitfieldString() const { return bitfields; }
QCString anchor() const;
const QCString &initializer() const { return init; }
int initializerLines() const { return initLines; }
int getMemberSpecifiers() const { return memSpec; }
MemberList *getSectionList() const { return section; }
ClassDef *getClassDef() const { return classDef; }
GroupDef *getGroupDef() const { return group; }
FileDef *getFileDef() const { return fileDef; }
NamespaceDef* getNamespaceDef() const { return nspace; }
Protection protection() const { return prot; }
Specifier virtualness() const { return virt; }
MemberType memberType() const { return mtype; }
bool isSignal() const { return mtype==Signal; }
bool isSlot() const { return mtype==Slot; }
bool isVariable() const { return mtype==Variable; }
bool isEnumerate() const { return mtype==Enumeration; }
bool isEnumValue() const { return mtype==EnumValue; }
bool isTypedef() const { return mtype==Typedef; }
bool isFunction() const { return mtype==Function; }
bool isDefine() const { return mtype==Define; }
bool isFriend() const { return mtype==Friend; }
bool isDCOP() const { return mtype==DCOP; }
bool isProperty() const { return mtype==Property; }
bool isRelated() const { return related; }
bool isStatic() const { return stat; }
bool isInline() const { return (memSpec&Entry::Inline)!=0; }
bool isExplicit() const { return (memSpec&Entry::Explicit)!=0; }
bool isMutable() const { return (memSpec&Entry::Mutable)!=0; }
bool isExternal() const { return explExt; }
bool isLinkableInProject();
bool isLinkable();
bool detailsAreVisible() const;
bool hasDocumentation();
void setMemberType(MemberType t) { mtype=t; }
void setDefinition(const char *d) { def=d; }
void setFileDef(FileDef *fd) { fileDef=fd; }
void setAnchor(const char *a) { anc=a; }
void setProtection(Protection p) { prot=p; }
void setMemberSpecifiers(int s) { memSpec=s; }
void mergeMemberSpecifiers(int s) { memSpec|=s; }
void setInitializer(const char *i) { init=i;
initLines=init.contains('\n');
}
void setBitfields(const char *s) { bitfields = s; }
void setMaxInitLines(int lines) { userInitLines=lines; }
void setMemberClass(ClassDef *cd) { classDef=cd; }
void setSectionList(MemberList *sl) { section=sl; }
void setGroupDef(GroupDef *gd) { group=gd; }
void setExplicitExternal(bool b) { explExt=b; }
void makeRelated() { related=TRUE; }
void writeLink(OutputList &ol,
ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd);
void writeDeclaration(OutputList &ol,
ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,
bool inGroup);
void writeDocumentation(MemberList *ml,OutputList &ol,
const char *scopeName,Definition *container);
void warnIfUndocumented();
void setReimplements(MemberDef *md) { redefines=md; }
void insertReimplementedBy(MemberDef *md);
MemberDef *reimplements() const { return redefines; }
MemberList *reimplementedBy() const { return redefinedBy; }
void insertEnumField(MemberDef *md);
void setEnumScope(MemberDef *md) { enumScope=md; }
MemberDef *getEnumScope() const { return enumScope; }
void setEnumDecl(OutputList &ed);
void setEnumUsed() { eUsed=TRUE; }
bool enumUsed() const { return eUsed; }
OutputList *enumDecl() const { return enumDeclList; }
MemberList *enumFieldList() const { return enumFields; }
void setDocumentedEnumValues(bool value) { docEnumValues=value; }
bool hasDocumentedEnumValues() const { return docEnumValues; }
void setAnonymousEnumType(MemberDef *md) { annEnumType = md; }
MemberDef *getAnonymousEnumType() const { return annEnumType; }
bool addExample(const char *anchor,const char *name,const char *file);
bool hasExamples();
ExampleList *getExampleList() const { return exampleList; }
void setPrototype(bool p) { proto=p; }
bool isPrototype() const { return proto; }
ArgumentList *argumentList() const { return argList; }
void setArgumentList(ArgumentList *al)
{ if (argList) delete argList;
argList = al;
}
ArgumentList *templateArguments() const { return tArgList; }
void setScopeDefTemplateArguments(ArgumentList *t);
ArgumentList *scopeDefTemplateArguments() const { return scopeTAL; }
void setMemberDefTemplateArguments(ArgumentList *t);
ArgumentList *memberDefTemplateArguments() const { return membTAL; }
void setNamespace(NamespaceDef *nd) { nspace=nd; }
void setMemberGroup(MemberGroup *grp);
MemberGroup *getMemberGroup() const { return memberGroup; }
void setMemberGroupId(int id) { grpId=id; }
int getMemberGroupId() const { return grpId; }
void setFromAnnonymousScope(bool b) { annScope=b; }
void setFromAnnonymousMember(MemberDef *m) { annMemb=m; }
bool fromAnnonymousScope() const { return annScope; }
bool annonymousDeclShown() const { return annUsed; }
void setIndentDepth( int i) { indDepth=i; }
int indentDepth() { return indDepth; }
bool visibleMemberGroup(bool hideNoHeader);
QCString getScopeString() const;
private:
ClassDef *classDef;
FileDef *fileDef;
MemberDef *redefines;
MemberDef *enumScope;
MemberDef *annEnumType;
MemberList *redefinedBy;
MemberDef *memDef;
MemberDef *memDec;
ExampleList *exampleList;
ExampleDict *exampleDict;
MemberList *enumFields;
OutputList *enumDeclList;
NamespaceDef *nspace;
QCString type;
QCString args;
QCString bitfields;
QCString exception;
QCString init;
int initLines;
QCString decl;
QCString declFile;
int declLine;
QCString def;
QCString anc;
Specifier virt;
Protection prot;
bool related;
bool stat;
int memSpec;
MemberType mtype;
bool eUsed;
bool proto;
bool docEnumValues;
bool annScope;
bool annUsed;
bool annShown;
int indDepth;
int maxInitLines;
int userInitLines;
MemberList *section;
MemberDef *annMemb;
ArgumentList *argList;
ArgumentList *tArgList;
ArgumentList *scopeTAL;
ArgumentList *membTAL;
int grpId;
MemberGroup *memberGroup;
GroupDef *group;
bool explExt;
MemberDef(const MemberDef &);
MemberDef &operator=(const MemberDef &);
};
# 22 "memberlist.h" 2
class GroupDef;
class MemberGroup;
class MemberGroupList;
class MemberList : public QList<MemberDef>
{
public:
MemberList();
~MemberList();
bool insert(uint index,const MemberDef *md);
void inSort(const MemberDef *md);
void append(const MemberDef *md);
int compareItems(QCollection::Item item1,QCollection::Item item2);
int varCount() const { return varCnt; }
int funcCount() const { return funcCnt; }
int enumCount() const { return enumCnt; }
int enumValueCount() const { return enumValCnt; }
int typedefCount() const { return typeCnt; }
int protoCount() const { return protoCnt; }
int defineCount() const { return defCnt; }
int friendCount() const { return friendCnt; }
void countDecMembers(bool inGroup,bool countSubGroups,bool sectionPerType);
void countDocMembers(bool listOfGroup=FALSE);
int totalCount() const
{ return
m_count;
}
void writePlainDeclarations(OutputList &ol,
ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,
bool inGroup=FALSE,bool countSubGroups=TRUE);
void writeDeclarations(OutputList &ol,
ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,
const char *title,const char *subtitle,
bool inGroup=FALSE,bool countSubGroups=TRUE);
void writeDocumentation(OutputList &ol,const char *scopeName,
Definition *container);
void addMemberGroup(MemberGroup *mg);
private:
int varCnt,funcCnt,enumCnt,enumValCnt,typeCnt,protoCnt,defCnt,friendCnt;
int m_count;
MemberGroupList *memberGroupList;
};
class MemberListIterator : public QListIterator<MemberDef>
{
public:
MemberListIterator(const QList<MemberDef> &list);
};
class MemberDict : public QDict<MemberDef>
{
public:
MemberDict(int size) : QDict<MemberDef>(size) {}
~MemberDict() {}
};
# 25 "groupdef.h" 2
# 1 "htmlhelp.h" 1
class QFile;
class HtmlHelpIndex;
class HtmlHelp
{
enum ImageNumber {
BOOK_CLOSED=1, BOOK_OPEN,
BOOK_CLOSED_NEW, BOOK_OPEN_NEW,
FOLDER_CLOSED, FOLDER_OPEN,
FOLDER_CLOSED_NEW,FOLDER_OPEN_NEW,
QUERY, QUERY_NEW,
TEXT, TEXT_NEW,
WEB_DOC, WEB_DOC_NEW,
WEB_LINK, WEB_LINK_NEW,
INFO, INFO_NEW,
LINK, LINK_NEW,
BOOKLET, BOOKLET_NEW,
EMAIL, EMAIL_NEW,
EMAIL2, EMAIL2_NEW,
IMAGE, IMAGE_NEW,
AUDIO, AUDIO_NEW,
MUSIC, MUSIC_NEW,
VIDEO, VIDEO_NEW,
INDEX, INDEX_NEW,
IDEA, IDEA_NEW,
NOTE, NOTE_NEW,
TOOL, TOOL_NEW
};
public:
static HtmlHelp *getInstance();
void initialize();
void finalize();
int incContentsDepth();
int decContentsDepth();
int contentsDepth() { return dc; }
void addContentsItem(bool isDir,
const char *name,
const char *ref = 0,
const char *anchor = 0);
void addIndexItem(const char *level1, const char *level2,
const char *ref, const char *anchor);
void addIndexFile(const char *name);
private:
void createProjectFile();
HtmlHelp();
QFile *cf,*kf;
QTextStream cts,kts;
HtmlHelpIndex *index;
int dc;
QStrList indexFiles;
static HtmlHelp *theInstance;
};
# 27 "groupdef.h" 2
class FileList;
class ClassList;
class FileDef;
class ClassDef;
class NamespaceDef;
class GroupList;
class OutputList;
class NamespaceList;
class MemberGroupList;
class MemberGroupDict;
class MemberNameInfoDict;
class PageSDict;
class PageInfo;
class GroupDef : public Definition
{
public:
GroupDef(const char *fileName,int line,const char *name,const char *title);
~GroupDef();
DefType definitionType() { return TypeGroup; }
QCString getOutputFileBase() const { return fileName; }
const char *groupTitle() const { return title; }
void addFile(const FileDef *def);
void addClass(const ClassDef *def);
void addNamespace(const NamespaceDef *def);
void addGroup(const GroupDef *def);
void addPage(PageInfo *def);
void addExample(const PageInfo *def);
void insertMember(MemberDef *def);
void writeDocumentation(OutputList &ol);
int countMembers() const;
bool isLinkableInProject()
{
return hasDocumentation() && !isReference();
}
bool isLinkable()
{
return isLinkableInProject() || isReference();
}
void computeAnchors();
void addMembersToMemberGroup();
void distributeMemberGroupDocumentation();
bool visited;
friend void writeGroupTreeNode(OutputList&, GroupDef*);
protected:
void addMemberListToGroup(MemberList *,bool (MemberDef::*)() const);
private:
QCString title;
QCString fileName;
FileList *fileList;
ClassList *classList;
NamespaceList *namespaceList;
GroupList *groupList;
PageSDict *pageDict;
PageSDict *exampleDict;
MemberList *allMemberList;
MemberNameInfoDict *allMemberNameInfoDict;
MemberList defineMembers;
MemberList protoMembers;
MemberList typedefMembers;
MemberList enumMembers;
MemberList enumValMembers;
MemberList funcMembers;
MemberList varMembers;
MemberGroupList *memberGroupList;
MemberGroupDict *memberGroupDict;
};
class GroupList : public QList<GroupDef>
{
};
class GroupListIterator : public QListIterator<GroupDef>
{
public:
GroupListIterator(const GroupList &l) : QListIterator<GroupDef>(l) {}
};
void addClassToGroups(Entry *root,ClassDef *cd);
void addNamespaceToGroups(Entry *root,NamespaceDef *nd);
void addGroupToGroups(Entry *root,GroupDef *subGroup);
void addMemberToGroups(Entry *root,MemberDef *md);
void addPageToGroups(Entry *root,PageInfo *pi);
void addExampleToGroups(Entry *root,PageInfo *eg);
# 24 "doxygen.h" 2
# 1 "filedef.h" 1
# 1 "../qtools/qintdict.h" 1
template<class type> class QIntDict : public QGDict
{
public:
QIntDict(int size=17) : QGDict(size,IntKey,0,0) {}
QIntDict( const QIntDict<type> &d ) : QGDict(d) {}
~QIntDict() { clear(); }
QIntDict<type> &operator=(const QIntDict<type> &d)
{ return (QIntDict<type>&)QGDict::operator=(d); }
uint count() const { return QGDict::count(); }
uint size() const { return QGDict::size(); }
bool isEmpty() const { return QGDict::count() == 0; }
void insert( long k, const type *d )
{ QGDict::look_int(k,(Item)d,1); }
void replace( long k, const type *d )
{ QGDict::look_int(k,(Item)d,2); }
bool remove( long k ) { return QGDict::remove_int(k); }
type *take( long k ) { return (type*)QGDict::take_int(k); }
type *find( long k ) const
{ return (type *)((QGDict*)this)->QGDict::look_int(k,0,0); }
type *operator[]( long k ) const
{ return (type *)((QGDict*)this)->QGDict::look_int(k,0,0); }
void clear() { QGDict::clear(); }
void resize( uint n ) { QGDict::resize(n); }
void statistics() const { QGDict::statistics(); }
private:
void deleteItem( Item d );
};
template<> inline void QIntDict<void>::deleteItem( QCollection::Item )
{
}
template<class type> inline void QIntDict<type>::deleteItem( QCollection::Item d )
{
if ( del_item ) delete (type *)d;
}
template<class type> class QIntDictIterator : public QGDictIterator
{
public:
QIntDictIterator(const QIntDict<type> &d) :QGDictIterator((QGDict &)d) {}
~QIntDictIterator() {}
uint count() const { return dict->count(); }
bool isEmpty() const { return dict->count() == 0; }
type *toFirst() { return (type *)QGDictIterator::toFirst(); }
operator type *() const { return (type *)QGDictIterator::get(); }
type *current() const { return (type *)QGDictIterator::get(); }
long currentKey() const { return QGDictIterator::getKeyInt(); }
type *operator()() { return (type *)QGDictIterator::operator()(); }
type *operator++() { return (type *)QGDictIterator::operator++(); }
type *operator+=(uint j) { return (type *)QGDictIterator::operator+=(j);}
};
# 23 "filedef.h" 2
# 1 "config.h" 1
extern void parseConfig(const QCString &config,const char *fn);
extern void writeTemplateConfig(QFile *f,bool shortList);
extern void checkConfig();
extern void configStrToVal();
extern void substituteEnvironmentVars();
struct Config
{
static void init();
static QCString projectName;
static QCString projectNumber;
static QCString outputDir;
static QCString outputLanguage;
static bool extractAllFlag;
static bool extractPrivateFlag;
static bool extractStaticFlag;
static bool hideMemberFlag;
static bool hideClassFlag;
static bool briefMemDescFlag;
static bool repeatBriefFlag;
static bool alwaysDetailsFlag;
static bool fullPathNameFlag;
static QStrList stripFromPath;
static bool internalDocsFlag;
static bool classDiagramFlag;
static bool sourceBrowseFlag;
static bool inlineSourceFlag;
static bool stripCommentsFlag;
static bool caseSensitiveNames;
static bool hideScopeNames;
static bool verbatimHeaderFlag;
static bool showIncFileFlag;
static bool autoBriefFlag;
static bool inheritDocsFlag;
static bool inlineInfoFlag;
static bool sortMembersFlag;
static bool distributeDocFlag;
static int tabSize;
static QStrList sectionFilterList;
static bool generateTodoList;
static bool generateTestList;
static bool generateBugList;
static QStrList aliasList;
static int maxInitLines;
static bool optimizeForCFlag;
static bool showUsedFilesFlag;
static bool quietFlag;
static bool warningFlag;
static bool warningUndocFlag;
static QCString warnFormat;
static QCString warnLogFile;
static QStrList inputSources;
static QStrList filePatternList;
static bool recursiveFlag;
static QStrList excludeSources;
static QStrList excludePatternList;
static QStrList examplePath;
static QStrList examplePatternList;
static QStrList imagePath;
static QCString inputFilter;
static bool filterForSourceFlag;
static bool alphaIndexFlag;
static int colsInAlphaIndex;
static QStrList ignorePrefixList;
static bool generateHtml;
static QCString htmlOutputDir;
static QCString headerFile;
static QCString footerFile;
static QCString htmlStyleSheet;
static bool htmlAlignMemberFlag;
static bool htmlHelpFlag;
static bool htmlHelpChiFlag;
static bool htmlHelpTocFlag;
static bool htmlHelpTocExpandFlag;
static bool noIndexFlag;
static int enumValuesPerLine;
static bool ftvHelpFlag;
static int treeViewWidth;
static bool generateLatex;
static QCString latexOutputDir;
static bool compactLatexFlag;
static QCString paperType;
static QStrList extraPackageList;
static QCString latexHeaderFile;
static bool pdfHyperFlag;
static bool usePDFLatexFlag;
static bool latexBatchModeFlag;
static bool generateRTF;
static QCString rtfOutputDir;
static bool compactRTFFlag;
static bool rtfHyperFlag;
static QCString rtfStylesheetFile;
static bool generateMan;
static QCString manOutputDir;
static QCString manExtension;
static bool preprocessingFlag;
static bool macroExpansionFlag;
static bool onlyPredefinedFlag;
static bool searchIncludeFlag;
static QStrList includePath;
static QStrList includeFilePatternList;
static QStrList predefined;
static QStrList expandAsDefinedList;
static QStrList tagFileList;
static QCString genTagFile;
static bool allExtFlag;
static QCString perlPath;
static bool haveDotFlag;
static bool classGraphFlag;
static bool collGraphFlag;
static bool includeGraphFlag;
static bool includedByGraphFlag;
static bool gfxHierarchyFlag;
static QCString dotPath;
static int maxDotGraphWidth;
static int maxDotGraphHeight;
static bool generateLegend;
static bool dotCleanUp;
static bool searchEngineFlag;
static QCString cgiName;
static QCString cgiURL;
static QCString docURL;
static QCString docAbsPath;
static QCString binAbsPath;
static QStrList extDocPathList;
};
# 25 "filedef.h" 2
class FileDef;
class FileList;
class ClassList;
class ClassDef;
class MemberDef;
class OutputList;
class NamespaceDef;
class NamespaceList;
class NamespaceDict;
class MemberGroupList;
class MemberGroupDict;
class PackageDef;
struct IncludeInfo
{
IncludeInfo() { fileDef=0; local=FALSE; }
~IncludeInfo() {}
FileDef *fileDef;
QCString includeName;
bool local;
};
class FileDef : public Definition
{
friend class FileName;
public:
FileDef(const char *p,const char *n,const char *ref=0);
~FileDef();
DefType definitionType() { return TypeFile; }
QCString name() const
{
if (Config::fullPathNameFlag)
return filename;
else
return Definition::name();
}
QCString getOutputFileBase() const { return diskname; }
QCString absFilePath() const { return filepath; }
QCString includeName() const { return diskname+"-source"; }
QCString docName() const { return docname; }
void addSourceRef(int line,Definition *d,MemberDef *md);
Definition *getSourceDefinition(int lineNr);
MemberDef *getSourceMember(int lineNr);
QCString getPath() const { return path; }
bool isLinkableInProject()
{
return hasDocumentation() && !isReference();
}
bool isLinkable()
{
return isLinkableInProject() || isReference();
}
void writeDocumentation(OutputList &ol);
void writeSource(OutputList &ol);
friend void generatedFileNames();
void insertMember(MemberDef *md);
void insertClass(ClassDef *cd);
void insertNamespace(NamespaceDef *nd);
void computeAnchors();
void setPackageDef(PackageDef *pd) { package=pd; }
PackageDef *packageDef() const { return package; }
void addUsingDirective(NamespaceDef *nd);
NamespaceList *getUsedNamespaces() const { return usingDirList; }
void addUsingDeclaration(ClassDef *cd);
ClassList *getUsedClasses() const { return usingDeclList; }
bool generateSourceFile() const;
void addIncludeDependency(FileDef *fd,const char *incName,bool local);
void addIncludedByDependency(FileDef *fd,const char *incName,bool local);
QList<IncludeInfo> *includeFileList() const { return includeList; }
QList<IncludeInfo> *includedByFileList() const { return includedByList; }
void addMembersToMemberGroup();
void distributeMemberGroupDocumentation();
MemberList allMemberList;
MemberList defineMembers;
MemberList protoMembers;
MemberList typedefMembers;
MemberList enumMembers;
MemberList funcMembers;
MemberList varMembers;
protected:
void addMemberListToGroup(MemberList *,bool (MemberDef::*)() const);
private:
ClassList *classList;
QDict<IncludeInfo> *includeDict;
QList<IncludeInfo> *includeList;
QDict<IncludeInfo> *includedByDict;
QList<IncludeInfo> *includedByList;
NamespaceDict *namespaceDict;
NamespaceList *namespaceList;
NamespaceList *usingDirList;
ClassList *usingDeclList;
QCString path;
QCString filepath;
QCString diskname;
QCString filename;
QCString docname;
QIntDict<Definition> *srcDefDict;
QIntDict<MemberDef> *srcMemberDict;
bool isSource;
MemberGroupList *memberGroupList;
MemberGroupDict *memberGroupDict;
PackageDef *package;
};
# 208 "filedef.h"
class FileList : public QList<FileDef>
{
public:
FileList() : m_pathName("tmp") {}
FileList(const char *path) : QList<FileDef>(), m_pathName(path) {}
~FileList() {}
QCString path() const { return m_pathName; }
int compareItems(QCollection::Item item1,QCollection::Item item2)
{
FileDef *md1 = (FileDef *)item1;
FileDef *md2 = (FileDef *)item2;
return qstricmp (md1->name(),md2->name());
}
private:
QCString m_pathName;
};
class OutputNameList : public QList<FileList>
{
public:
OutputNameList() : QList<FileList>() {}
~OutputNameList() {}
int compareItems(QCollection::Item item1,QCollection::Item item2)
{
FileList *fl1 = (FileList *)item1;
FileList *fl2 = (FileList *)item2;
return qstricmp (fl1->path(),fl2->path());
}
};
class OutputNameDict : public QDict<FileList>
{
public:
OutputNameDict(int size) : QDict<FileList>(size) {}
~OutputNameDict() {}
};
# 25 "doxygen.h" 2
# 1 "classdef.h" 1
class MemberDict;
class ClassList;
class OutputList;
class FileDef;
class BaseClassList;
class MemberInfoList;
class MemberInfoDict;
class NamespaceDef;
class MemberDef;
class ExampleList;
class MemberNameInfoList;
class MemberNameInfoDict;
class UsesClassDict;
class MemberGroupList;
class MemberGroupDict;
class QTextStream;
class PackageDef;
struct IncludeInfo;
class ClassDef : public Definition
{
public:
enum CompoundType { Class=Entry::CLASS_SEC,
Struct=Entry::STRUCT_SEC,
Union=Entry::UNION_SEC,
Interface=Entry::INTERFACE_SEC,
Exception=Entry::EXCEPTION_SEC
};
DefType definitionType() { return TypeClass; }
QCString getOutputFileBase() const { return fileName; }
QCString displayName() const;
CompoundType compoundType() const { return compType; }
QCString compoundTypeString() const;
BaseClassList *baseClasses() { return inherits; }
BaseClassList *subClasses() { return inheritedBy; }
MemberNameInfoList *memberNameInfoList() { return allMemberNameInfoList; }
MemberNameInfoDict *memberNameInfoDict() { return allMemberNameInfoDict; }
void writeDocumentation(OutputList &ol);
void writeMemberList(OutputList &ol);
void writeDeclaration(OutputList &ol,MemberDef *md,bool inGroup);
Protection protection() const { return prot; }
bool isLinkableInProject();
bool isLinkable()
{
return isLinkableInProject() || isReference();
}
bool isVisibleInHierarchy();
ArgumentList *templateArguments() const { return tempArgs; }
ArgumentList *outerTemplateArguments() const;
NamespaceDef *getNamespaceDef() { return nspace; }
FileDef *getFileDef() const { return fileDef; }
PackageDef *packageDef() const;
bool isBaseClass(ClassDef *bcd);
UsesClassDict *usedImplementationClasses() const
{
return usesImplClassDict;
}
UsesClassDict *usedInterfaceClasses() const
{
return usesIntfClassDict;
}
MemberList pubMembers;
MemberList proMembers;
MemberList priMembers;
MemberList pubStaticMembers;
MemberList proStaticMembers;
MemberList priStaticMembers;
MemberList pubSlots;
MemberList proSlots;
MemberList priSlots;
MemberList pubAttribs;
MemberList proAttribs;
MemberList priAttribs;
MemberList pubStaticAttribs;
MemberList proStaticAttribs;
MemberList priStaticAttribs;
MemberList pubTypes;
MemberList proTypes;
MemberList priTypes;
MemberList related;
MemberList signals;
MemberList friends;
MemberList dcopMethods;
MemberList properties;
MemberList constructors;
MemberList typedefMembers;
MemberList enumMembers;
MemberList enumValMembers;
MemberList functionMembers;
MemberList relatedMembers;
MemberList variableMembers;
MemberList propertyMembers;
void insertBaseClass(ClassDef *,const char *name,Protection p,Specifier s,const char *t=0);
void insertSubClass(ClassDef *,Protection p,Specifier s,const char *t=0);
void setIncludeFile(FileDef *fd,const char *incName,bool local);
void insertMember(MemberDef *);
void insertUsedFile(const char *);
void computeAnchors();
void computeMemberGroups();
void setAnchor(MemberDef *);
void dumpMembers();
bool addExample(const char *anchor,const char *name, const char *file);
void addMembersToMemberGroup();
void distributeMemberGroupDocumentation();
void setNamespace(NamespaceDef *nd) { nspace = nd; }
void setTemplateArguments(ArgumentList *al);
void mergeMembers();
void setFileDef(FileDef *fd) { fileDef=fd; }
void determineImplUsageRelation();
void determineIntfUsageRelation();
void setSubGrouping(bool enabled) { subGrouping = enabled; }
void setProtection(Protection p) { prot=p; }
ClassDef(const char *fileName,int startLine,
const char *name,CompoundType ct,
const char *ref=0,const char *fName=0);
~ClassDef();
bool visited;
protected:
void addUsedInterfaceClasses(MemberDef *md,const char *typeStr);
void addMemberListToGroup(MemberList *);
bool hasExamples();
bool hasNonReferenceSuperClass();
private:
QCString fileName;
IncludeInfo *incInfo;
QCString incName;
QCString memListFileName;
QCString scopelessName;
BaseClassList *inherits;
BaseClassList *inheritedBy;
NamespaceDef *nspace;
MemberGroupList *memberGroupList;
MemberGroupDict *memberGroupDict;
MemberNameInfoList *allMemberNameInfoList;
MemberNameInfoDict *allMemberNameInfoDict;
ArgumentList *tempArgs;
QStrList files;
ExampleList *exampleList;
ExampleDict *exampleDict;
CompoundType compType;
Protection prot;
FileDef *fileDef;
UsesClassDict *usesImplClassDict;
UsesClassDict *usesIntfClassDict;
bool subGrouping;
};
struct UsesClassDef
{
UsesClassDef(ClassDef *cd) : classDef(cd)
{
accessors = new QDict<void>(17);
containment = TRUE;
}
~UsesClassDef()
{
delete accessors;
}
void addAccessor(const char *s)
{
if (accessors->find(s)==0)
{
accessors->insert(s,(void *)666);
}
}
ClassDef *classDef;
QDict<void> *accessors;
QCString templSpecifiers;
bool containment;
};
class UsesClassDict : public QDict<UsesClassDef>
{
public:
UsesClassDict(int size) : QDict<UsesClassDef>(size) {}
~UsesClassDict() {}
};
class UsesClassDictIterator : public QDictIterator<UsesClassDef>
{
public:
UsesClassDictIterator(const QDict<UsesClassDef> &d)
: QDictIterator<UsesClassDef>(d) {}
~UsesClassDictIterator() {}
};
struct BaseClassDef
{
BaseClassDef(ClassDef *cd,const char *n,Protection p,
Specifier v,const char *t) :
classDef(cd), usedName(n), prot(p), virt(v), templSpecifiers(t) {}
ClassDef *classDef;
QCString usedName;
Protection prot;
Specifier virt;
QCString templSpecifiers;
};
class BaseClassList : public QList<BaseClassDef>
{
public:
~BaseClassList() {}
int compareItems(QCollection::Item item1,QCollection::Item item2)
{
ClassDef *c1=((BaseClassDef *)item1)->classDef;
ClassDef *c2=((BaseClassDef *)item2)->classDef;
if (c1==0 || c2==0)
return FALSE;
else
return qstricmp (c1->name(),c2->name());
}
};
class BaseClassListIterator : public QListIterator<BaseClassDef>
{
public:
BaseClassListIterator(const BaseClassList &bcl) :
QListIterator<BaseClassDef>(bcl) {}
};
# 26 "doxygen.h" 2
# 1 "classlist.h" 1
class ClassList : public QList<ClassDef>
{
public:
ClassList();
~ClassList();
int compareItems(QCollection::Item item1,QCollection::Item item2);
void writeDeclaration(OutputList &ol,const ClassDef::CompoundType *filter=0,
const char *header=0);
};
class ClassListIterator : public QListIterator<ClassDef>
{
public:
ClassListIterator(const ClassList &list);
};
class ClassDict : public QDict<ClassDef>
{
public:
ClassDict(int size) : QDict<ClassDef>(size) {}
~ClassDict() {}
};
# 28 "doxygen.h" 2
# 1 "membername.h" 1
class MemberName : public QList<MemberDef>
{
public:
MemberName(const char *name);
~MemberName();
const char *memberName() const { return name; }
int compareItems(QCollection::Item item1,QCollection::Item item2);
private:
QCString name;
};
class MemberNameIterator : public QListIterator<MemberDef>
{
public:
MemberNameIterator( const MemberName &list);
};
class MemberNameList : public QList<MemberName>
{
public:
MemberNameList();
~MemberNameList();
int compareItems(QCollection::Item item1,QCollection::Item item2);
};
class MemberNameListIterator : public QListIterator<MemberName>
{
public:
MemberNameListIterator( const MemberNameList &list );
};
typedef QDict<MemberName> MemberNameDict;
struct MemberInfo
{
MemberInfo(MemberDef *md,Protection p,Specifier v,bool inh) :
memberDef(md), prot(p), virt(v), inherited(inh), ambigClass(0) {}
~MemberInfo() {}
MemberDef *memberDef;
Protection prot;
Specifier virt;
bool inherited;
QCString scopePath;
QCString ambiguityResolutionScope;
ClassDef *ambigClass;
};
class MemberNameInfo : public QList<MemberInfo>
{
public:
MemberNameInfo(const char *name);
~MemberNameInfo() {}
const char *memberName() const { return name; }
int compareItems(QCollection::Item item1,QCollection::Item item2);
private:
QCString name;
};
class MemberNameInfoIterator : public QListIterator<MemberInfo>
{
public:
MemberNameInfoIterator(const MemberNameInfo &mnii)
: QListIterator<MemberInfo>(mnii) {}
};
class MemberNameInfoList : public QList<MemberNameInfo>
{
public:
~MemberNameInfoList() {}
int compareItems(QCollection::Item item1,QCollection::Item item2)
{ return qstricmp (
((MemberNameInfo *)item1)->memberName(),
((MemberNameInfo *)item2)->memberName()
);
}
};
class MemberNameInfoDict : public QDict<MemberNameInfo>
{
public:
MemberNameInfoDict(int size) : QDict<MemberNameInfo>(size) {}
~MemberNameInfoDict() {}
};
class MemberNameInfoListIterator : public QListIterator<MemberNameInfo>
{
public:
MemberNameInfoListIterator(const MemberNameInfoList &mil) :
QListIterator<MemberNameInfo>(mil) {}
};
# 29 "doxygen.h" 2
# 1 "filename.h" 1
class FileName : public FileList
{
public:
FileName(const char *fn,const char *name);
~FileName();
const char *fileName() const { return name; }
const char *fullName() const { return fName; }
void generateDiskNames();
int compareItems(QCollection::Item item1,QCollection::Item item2);
private:
QCString name;
QCString fName;
};
class FileNameIterator : public QListIterator<FileDef>
{
public:
FileNameIterator(const FileName &list);
};
class FileNameList : public QList<FileName>
{
public:
FileNameList();
~FileNameList();
void generateDiskNames();
int compareItems(QCollection::Item item1,QCollection::Item item2);
};
class FileNameListIterator : public QListIterator<FileName>
{
public:
FileNameListIterator( const FileNameList &list );
};
class FileNameDict : public QDict<FileName>
{
public:
FileNameDict(uint size) :
QDict<FileName>(size,Config::caseSensitiveNames) {}
~FileNameDict() {}
};
# 30 "doxygen.h" 2
# 1 "namespacedef.h" 1
class ClassDef;
class OutputList;
class ClassList;
class ClassDict;
class MemberDef;
class NamespaceList;
class MemberGroupDict;
class MemberGroupList;
class NamespaceDef : public Definition
{
public:
NamespaceDef(const char *defFileName,int defLine,
const char *name,const char *ref=0);
~NamespaceDef();
DefType definitionType() { return TypeNamespace; }
QCString getOutputFileBase() const { return fileName; }
void insertUsedFile(const char *fname);
void writeDocumentation(OutputList &ol);
void insertClass(ClassDef *cd);
void insertMember(MemberDef *md);
void computeAnchors();
int countMembers();
void addUsingDirective(NamespaceDef *nd);
NamespaceList *getUsedNamespaces() const { return usingDirList; }
void addUsingDeclaration(ClassDef *cd);
ClassList *getUsedClasses() const { return usingDeclList; }
bool isLinkableInProject()
{
int i = name().findRev("::");
if (i==-1) i=0; else i+=2;
return !name().isEmpty() && name().at(i)!='@' &&
hasDocumentation() && !isReference();
}
bool isLinkable()
{
return isLinkableInProject() || isReference();
}
void addMembersToMemberGroup();
void distributeMemberGroupDocumentation();
protected:
void addMemberListToGroup(MemberList *,bool (MemberDef::*)() const);
private:
QCString fileName;
QStrList files;
ClassList *classList;
ClassDict *classDict;
NamespaceList *usingDirList;
ClassList *usingDeclList;
MemberList allMemberList;
MemberList defineMembers;
MemberList protoMembers;
MemberList typedefMembers;
MemberList enumMembers;
MemberList enumValMembers;
MemberList funcMembers;
MemberList varMembers;
MemberGroupList *memberGroupList;
MemberGroupDict *memberGroupDict;
};
class NamespaceList : public QList<NamespaceDef>
{
public:
~NamespaceList() {}
int compareItems(QCollection::Item item1,QCollection::Item item2)
{
return qstricmp (((NamespaceDef *)item1)->name(),
((NamespaceDef *)item2)->name()
);
}
};
class NamespaceListIterator : public QListIterator<NamespaceDef>
{
public:
NamespaceListIterator(const NamespaceList &l) :
QListIterator<NamespaceDef>(l) {}
};
class NamespaceDict : public QDict<NamespaceDef>
{
public:
NamespaceDict(int size) : QDict<NamespaceDef>(size) {}
~NamespaceDict() {}
};
# 31 "doxygen.h" 2
# 1 "formula.h" 1
class Formula
{
public:
Formula(const char *text);
~Formula();
int getId();
QCString getFormulaText() const { return form; }
private:
int number;
QCString form;
};
class FormulaList : public QList<Formula>
{
public:
void generateBitmaps(const char *path);
};
class FormulaListIterator : public QListIterator<Formula>
{
public:
FormulaListIterator(const FormulaList &l) :
QListIterator<Formula>(l) {}
};
class FormulaDict : public QDict<Formula>
{
public:
FormulaDict(uint size) :
QDict<Formula>(size) {}
~FormulaDict() {}
};
# 32 "doxygen.h" 2
# 1 "section.h" 1
# 1 "sortdict.h" 1
template<class T> class SDict;
template<class T>
class SList : public QList<T>
{
public:
SList(SDict<T> *owner) : m_owner(owner) {}
~SList() {}
int compareItems(QCollection::Item item1,QCollection::Item item2)
{
return m_owner->compareItems(item1,item2);
}
private:
SDict<T> *m_owner;
};
template<class T>
class SDict
{
private:
SList<T> *m_list;
QDict<T> *m_dict;
public:
SDict(int size)
{
m_list = new SList<T>(this);
m_dict = new QDict<T>(size);
}
virtual ~SDict()
{
delete m_list;
delete m_dict;
}
void append(const char *key,const T *d)
{
m_list->append(d);
m_dict->insert(key,d);
}
void inSort(const char *key,const T *d)
{
m_list->inSort(d);
m_dict->insert(key,d);
}
void setAutoDelete(bool val)
{
m_list->setAutoDelete(val);
}
T *find(const char *key)
{
return m_dict->find(key);
}
virtual int compareItems(QCollection::Item item1,QCollection::Item item2)
{
return item1!=item2;
}
void clear()
{
m_list->clear();
m_dict->clear();
}
int count()
{
return m_list->count();
}
class Iterator;
friend class Iterator;
class Iterator
{
public:
Iterator(const SDict<T> &dict)
{
m_li = new QListIterator<T>(*dict.m_list);
}
virtual ~Iterator()
{
delete m_li;
}
T *toFirst() const
{
return m_li->toFirst();
}
T *current() const
{
return m_li->current();
}
T *operator++()
{
return m_li->operator++();
}
private:
QListIterator<T> *m_li;
};
};
# 25 "section.h" 2
class Definition;
struct SectionInfo
{
enum SectionType { Section, Subsection, Anchor };
SectionInfo(const char *l,const char *t,SectionType st,const char *r=0)
{ label=l; title=t; type=st; ref=r; definition=0; pageRef=0; generated=FALSE; }
~SectionInfo() {}
QCString label;
QCString title;
QCString ref;
SectionType type;
Definition *definition;
PageInfo *pageRef;
QCString fileName;
bool generated;
};
class SectionDict : public QDict<SectionInfo>
{
public:
SectionDict(int size) : QDict<SectionInfo>(size) {}
~SectionDict() {}
};
# 33 "doxygen.h" 2
# 1 "membergroup.h" 1
class MemberDef;
class ClassDef;
class NamespaceDef;
class FileDef;
class MemberList;
class GroupDef;
class OutputList;
class Definition;
class MemberGroup
{
public:
MemberGroup(int id,const char *header,const char *docs);
~MemberGroup();
QCString header() const { return grpHeader; }
int groupId() const { return grpId; }
void insertMember(MemberDef *);
void setAnchors();
void writePlainDeclarations(OutputList &ol,
ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,
bool inGroup=TRUE);
void writeDeclarations(OutputList &ol,
ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd);
QCString documentation() { return doc; }
bool allMembersInSameSection() { return inSameSection; }
void addToDeclarationSection();
int countDecMembers(bool sectionPerType);
void distributeMemberGroupDocumentation();
private:
MemberList *memberList;
int grpId;
QCString grpHeader;
QCString fileName;
Definition *scope;
QCString doc;
MemberList *inDeclSection;
bool inSameSection;
int numDeclMembers;
};
class MemberGroupList : public QList<MemberGroup>
{
};
class MemberGroupListIterator : public QListIterator<MemberGroup>
{
public:
MemberGroupListIterator(const MemberGroupList &l) :
QListIterator<MemberGroup>(l) {}
};
class MemberGroupDict : public QIntDict<MemberGroup>
{
public:
MemberGroupDict(int size) : QIntDict<MemberGroup>(size) {}
~MemberGroupDict() {}
};
class MemberGroupDictIterator : public QIntDictIterator<MemberGroup>
{
public:
MemberGroupDictIterator(const MemberGroupDict &d) :
QIntDictIterator<MemberGroup>(d) {}
~MemberGroupDictIterator() {}
};
# 34 "doxygen.h" 2
# 1 "packagedef.h" 1
class ClassList;
class ClassDef;
class PackageList;
class OutputList;
class PackageDef : public Definition
{
public:
PackageDef(const char *fName,int line, const char *name,const char *ref=0);
~PackageDef();
DefType definitionType() { return TypePackage; }
QCString getOutputFileBase() const { return packageFileName; }
void addClass(const ClassDef *def);
void writeDocumentation(OutputList &ol);
bool isLinkableInProject()
{
return hasDocumentation() && !isReference();
}
bool isLinkable()
{
return isLinkableInProject() || isReference();
}
private:
QCString packageFileName;
ClassList *classList;
};
class PackageSDict : public SDict<PackageDef>
{
public:
PackageSDict(int size) : SDict<PackageDef>(size) {}
};
# 35 "doxygen.h" 2
class PageSList;
class PageSDict;
class PageInfo;
typedef QList<QCString> StringList;
typedef QDict<FileDef> FileDict;
typedef QDict<QCString> StringDict;
typedef QDict<GroupDef> GroupDict;
extern QCString spaces;
class Doxygen
{
public:
static ClassList classList;
static ClassDict classDict;
static PageSDict *exampleSDict;
static PageSDict *pageSDict;
static PageInfo *mainPage;
static FileNameDict *includeNameDict;
static FileNameDict *exampleNameDict;
static FileNameDict *inputNameDict;
static FileNameDict *imageNameDict;
static QStrList tagfileList;
static MemberNameList memberNameList;
static MemberNameList functionNameList;
static MemberNameDict memberNameDict;
static MemberNameDict functionNameDict;
static FileList fileList;
static FileDict fileDict;
static ClassDef unrelatedClass;
static QTextStream tagFile;
static SectionDict sectionDict;
static FileNameList inputNameList;
static StringDict typedefDict;
static StringDict namespaceAliasDict;
static GroupList groupList;
static GroupDict groupDict;
static NamespaceList namespaceList;
static NamespaceDict namespaceDict;
static FormulaList formulaList;
static FormulaDict formulaDict;
static FormulaDict formulaNameDict;
static StringDict tagDestinationDict;
static StringDict aliasDict;
static QIntDict<QCString> memberHeaderDict;
static QIntDict<QCString> memberDocDict;
static QDict<void> expandAsDefinedDict;
static PackageSDict packageDict;
};
void initDoxygen();
void readConfiguration(int argc, char **argv);
void parseInput();
void generateOutput();
# 26 "index.cpp" 2
# 1 "doc.h" 1
class OutputDocInterface;
extern void parseDoc(OutputDocInterface &ol,
const char *fileName,int startLine,
const char *clName, const char *memName,
const QCString &docString);
extern void parseExample(OutputDocInterface &ol,const QCString &docString,
const char *fileName);
extern void parseText(OutputDocInterface &ol,const QCString &txtString);
# 27 "index.cpp" 2
# 1 "code.h" 1
class OutputDocInterface;
class FileDef;
class MemberDef;
extern void parseCode(OutputDocInterface &,const char *,const QCString &,
bool ,const char *,FileDef *fd=0,
int startLine=-1,int endLine=-1,bool inlineFragment=FALSE);
extern void initParseCodeContext();
extern void setParameterList(MemberDef *md);
# 28 "index.cpp" 2
# 1 "outputlist.h" 1
# 1 "outputgen.h" 1
# 1 "../qtools/qbuffer.h" 1
class QBuffer : public QIODevice
{
public:
QBuffer();
QBuffer( QByteArray );
~QBuffer();
QByteArray buffer() const;
bool setBuffer( QByteArray );
bool open( int );
void close();
void flush();
uint size() const;
int at() const;
bool at( int );
int readBlock( char *p, uint );
int writeBlock( const char *p, uint );
int readLine( char *p, uint );
int getch();
int putch( int );
int ungetch( int );
protected:
QByteArray a;
private:
uint a_len;
uint a_inc;
private:
QBuffer( const QBuffer & );
QBuffer &operator=( const QBuffer & );
};
inline QByteArray QBuffer::buffer() const
{ return a; }
inline uint QBuffer::size() const
{ return a.size(); }
inline int QBuffer::at() const
{ return ioIndex; }
# 23 "outputgen.h" 2
# 1 "../qtools/qstack.h" 1
template<class type> class QStack : private QGList
{
public:
QStack() {}
QStack( const QStack<type> &s ) : QGList(s) {}
~QStack() { clear(); }
QStack<type> &operator=(const QStack<type> &s)
{ return (QStack<type>&)QGList::operator=(s); }
bool autoDelete() const { return QCollection::autoDelete(); }
void setAutoDelete( bool del ) { QCollection::setAutoDelete(del); }
uint count() const { return QGList::count(); }
bool isEmpty() const { return QGList::count() == 0; }
void push( const type *d ) { QGList::insertAt(0,Item(d)); }
type *pop() { return (type *)QGList::takeFirst(); }
bool remove() { return QGList::removeFirst(); }
void clear() { QGList::clear(); }
type *top() const { return (type *)QGList::cfirst(); }
operator type *() const { return (type *)QGList::cfirst(); }
type *current() const { return (type *)QGList::cfirst(); }
private:
void deleteItem( Item d ) { if ( del_item ) delete (type *)d; }
};
# 25 "outputgen.h" 2
class ClassDiagram;
class DotClassGraph;
class DotInclDepGraph;
class DotGfxHierarchyTable;
class BaseOutputDocInterface
{
public:
virtual void startItemList() = 0;
virtual void writeListItem() = 0;
virtual void endItemList() = 0;
virtual void docify(const char *s) = 0;
virtual void writeChar(char c) = 0;
virtual void writeString(const char *text) = 0;
virtual void newParagraph() = 0;
virtual void startEnumList() = 0;
virtual void endEnumList() = 0;
virtual void writeObjectLink(const char *ref,const char *file,
const char *anchor, const char *text) = 0;
virtual void writeCodeLink(const char *ref,const char *file,
const char *anchor,const char *text) = 0;
virtual void startHtmlLink(const char *url) = 0;
virtual void endHtmlLink() = 0;
virtual void writeMailLink(const char *url) = 0;
virtual void startBold() = 0;
virtual void endBold() = 0;
virtual void startTypewriter() = 0;
virtual void endTypewriter() = 0;
virtual void startEmphasis() = 0;
virtual void endEmphasis() = 0;
virtual void startCodeFragment() = 0;
virtual void endCodeFragment() = 0;
virtual void startPreFragment() = 0;
virtual void endPreFragment() = 0;
virtual void writeRuler() = 0;
virtual void startDescription() = 0;
virtual void endDescription() = 0;
virtual void startDescItem() = 0;
virtual void endDescItem() = 0;
virtual void startSubsection() = 0;
virtual void endSubsection() = 0;
virtual void startSubsubsection() = 0;
virtual void endSubsubsection() = 0;
virtual void startCenter() = 0;
virtual void endCenter() = 0;
virtual void startSmall() = 0;
virtual void endSmall() = 0;
virtual void startSubscript() = 0;
virtual void endSubscript() = 0;
virtual void startSuperscript() = 0;
virtual void endSuperscript() = 0;
virtual void startTable(int cols) = 0;
virtual void endTable() = 0;
virtual void nextTableRow() = 0;
virtual void endTableRow() = 0;
virtual void nextTableColumn() = 0;
virtual void endTableColumn() = 0;
virtual void writeQuote() = 0;
virtual void writeCopyright() = 0;
virtual void writeUmlaut(char) = 0;
virtual void writeAcute(char) = 0;
virtual void writeGrave(char) = 0;
virtual void writeCirc(char) = 0;
virtual void writeTilde(char) = 0;
virtual void writeRing(char) = 0;
virtual void writeSharpS() = 0;
virtual void writeCCedil(char) = 0;
virtual void startDescList() = 0;
virtual void endDescList() = 0;
virtual void startParamList() = 0;
virtual void endParamList() = 0;
virtual void endDescTitle() = 0;
virtual void writeDescItem() = 0;
virtual void startTitle() = 0;
virtual void endTitle() = 0;
virtual void writeAnchor(const char *fileName,const char *name) = 0;
virtual void startSection(const char *,const char *,bool) = 0;
virtual void endSection(const char *,bool) = 0;
virtual void writeSectionRef(const char *,const char *,
const char *,const char *) = 0;
virtual void writeSectionRefItem(const char *,const char *,const char *) = 0;
virtual void lineBreak() = 0;
virtual void addIndexItem(const char *s1,const char *s2) = 0;
virtual void writeFormula(const char *,const char *) = 0;
virtual void writeNonBreakableSpace() = 0;
virtual void startImage(const char *,const char *,bool) = 0;
virtual void endImage(bool) = 0;
virtual void startDescTable() = 0;
virtual void endDescTable() = 0;
virtual void startDescTableTitle() = 0;
virtual void endDescTableTitle() = 0;
virtual void startDescTableData() = 0;
virtual void endDescTableData() = 0;
virtual void startTextLink(const char *file,const char *anchor) = 0;
virtual void endTextLink() = 0;
virtual void startPageRef() = 0;
virtual void endPageRef(const char *,const char *) = 0;
virtual void startCodeLine() = 0;
virtual void endCodeLine() = 0;
virtual void startCodeAnchor(const char *label) = 0;
virtual void endCodeAnchor() = 0;
virtual void startFontClass(const char *) = 0;
virtual void endFontClass() = 0;
virtual void codify(const char *s) = 0;
};
class OutputGenerator : public BaseOutputDocInterface
{
public:
enum OutputType { Html, Latex, Man, RTF, XML };
OutputGenerator();
virtual ~OutputGenerator();
virtual OutputGenerator *copy() = 0;
virtual void append(const OutputGenerator *) = 0;
virtual void enable() = 0;
virtual void disable() = 0;
virtual void enableIf(OutputType o) = 0;
virtual void disableIf(OutputType o) = 0;
virtual void disableIfNot(OutputType o) = 0;
virtual bool isEnabled(OutputType o) = 0;
virtual OutputGenerator *get(OutputType o) = 0;
void clear() { b.close(); a.resize(0); b.setBuffer(a);
b.open(0x0002 ); t.setDevice(&b); }
void startPlainFile(const char *name);
void endPlainFile();
QCString getContents() const;
bool isEnabled() const { return active; }
void pushGeneratorState();
void popGeneratorState();
virtual void startFile(const char *name,const char *title,bool ext) = 0;
virtual void writeFooter(int,bool) = 0;
virtual void endFile() = 0;
virtual void startIndexSection(IndexSections) = 0;
virtual void endIndexSection(IndexSections) = 0;
virtual void startProjectNumber() = 0;
virtual void endProjectNumber() = 0;
virtual void writeStyleInfo(int part) = 0;
virtual void startTitleHead(const char *) = 0;
virtual void endTitleHead(const char *fileName,const char *name) = 0;
virtual void startIndexList() = 0;
virtual void endIndexList() = 0;
virtual void startAlphabeticalIndexList() = 0;
virtual void endAlphabeticalIndexList() = 0;
virtual void writeIndexHeading(const char *s) = 0;
virtual void writeIndexItem(const char *ref,const char *file,
const char *text) = 0;
virtual void startGroupHeader() = 0;
virtual void endGroupHeader() = 0;
virtual void startMemberSections() = 0;
virtual void endMemberSections() = 0;
virtual void startMemberHeader() = 0;
virtual void endMemberHeader() = 0;
virtual void startMemberSubtitle() = 0;
virtual void endMemberSubtitle() = 0;
virtual void startMemberList() = 0;
virtual void endMemberList() = 0;
virtual void startMemberItem(int) = 0;
virtual void endMemberItem(bool) = 0;
virtual void startMemberGroupHeader(bool) = 0;
virtual void endMemberGroupHeader() = 0;
virtual void startMemberGroupDocs() = 0;
virtual void endMemberGroupDocs() = 0;
virtual void startMemberGroup() = 0;
virtual void endMemberGroup(bool) = 0;
virtual void insertMemberAlign() = 0;
virtual void startMemberDoc(const char *,const char *,
const char *,const char *) = 0;
virtual void endMemberDoc() = 0;
virtual void startDoxyAnchor(const char *fName,const char *anchor,
const char *name) = 0;
virtual void endDoxyAnchor(const char *fileName,const char *anchor) = 0;
virtual void writeLatexSpacing() = 0;
virtual void writeStartAnnoItem(const char *type,const char *file,
const char *path,const char *name) = 0;
virtual void writeEndAnnoItem(const char *name) = 0;
virtual void startMemberDescription() = 0;
virtual void endMemberDescription() = 0;
virtual void startIndent() = 0;
virtual void endIndent() = 0;
virtual void writeSynopsis() = 0;
virtual void startClassDiagram() = 0;
virtual void endClassDiagram(ClassDiagram &,const char *,const char *) = 0;
virtual void startDotGraph() = 0;
virtual void endDotGraph(DotClassGraph &g) = 0;
virtual void startInclDepGraph() = 0;
virtual void endInclDepGraph(DotInclDepGraph &g) = 0;
virtual void writeGraphicalHierarchy(DotGfxHierarchyTable &g) = 0;
virtual void startQuickIndexItem(const char *s,const char *l) = 0;
virtual void endQuickIndexItem() = 0;
virtual void startTextBlock(bool) = 0;
virtual void endTextBlock() = 0;
virtual void lastIndexPage() = 0;
virtual void startMemberDocPrefixItem() = 0;
virtual void endMemberDocPrefixItem() = 0;
virtual void startMemberDocName() = 0;
virtual void endMemberDocName() = 0;
virtual void startParameter(bool) = 0;
virtual void endParameter(bool) = 0;
protected:
QTextStream fs;
QByteArray a;
QBuffer b;
QTextStream t;
QFile *file;
QCString dir;
bool active;
private:
OutputGenerator(const OutputGenerator &o);
OutputGenerator &operator=(const OutputGenerator &o);
QStack<bool> *genStack;
};
class OutputDocInterface : public BaseOutputDocInterface
{
public:
virtual ~OutputDocInterface() {}
virtual OutputDocInterface *clone() = 0;
virtual void disableAllBut(OutputGenerator::OutputType o) = 0;
virtual void enableAll() = 0;
virtual void disableAll()= 0;
virtual void disable(OutputGenerator::OutputType o) = 0;
virtual void enable(OutputGenerator::OutputType o) = 0;
virtual bool isEnabled(OutputGenerator::OutputType o) = 0;
virtual void append(const OutputDocInterface *g) = 0;
virtual void pushGeneratorState() = 0;
virtual void popGeneratorState() = 0;
};
# 24 "outputlist.h" 2
class ClassDiagram;
class DotClassGraph;
class DotInclDepGraph;
class DotGfxHierarchyTable;
class OutputList : public OutputDocInterface
{
public:
OutputList(bool);
virtual ~OutputList();
OutputList(const OutputList *ol);
OutputList &operator=(const OutputList &ol);
OutputList &operator+=(const OutputList &ol);
void add(const OutputGenerator *);
void disableAllBut(OutputGenerator::OutputType o);
void enableAll();
void disableAll();
void disable(OutputGenerator::OutputType o);
void enable(OutputGenerator::OutputType o);
bool isEnabled(OutputGenerator::OutputType o);
void pushGeneratorState();
void popGeneratorState();
OutputDocInterface *clone()
{
return new OutputList(this);
}
void append(const OutputDocInterface *g)
{
operator+=(*(OutputList *)g);
}
void startIndexSection(IndexSections is)
{ forall(&OutputGenerator::startIndexSection,is); }
void endIndexSection(IndexSections is)
{ forall(&OutputGenerator::endIndexSection,is); }
void startProjectNumber()
{ forall(&OutputGenerator::startProjectNumber); }
void endProjectNumber()
{ forall(&OutputGenerator::endProjectNumber); }
void writeStyleInfo(int part)
{ forall(&OutputGenerator::writeStyleInfo,part); }
void startFile(const char *name,const char *title,bool external)
{ forall(&OutputGenerator::startFile,name,title,external); }
void writeFooter(int fase,bool external)
{ forall(&OutputGenerator::writeFooter,fase,external); }
void endFile()
{ forall(&OutputGenerator::endFile); }
void startTitleHead(const char *fileName)
{ forall(&OutputGenerator::startTitleHead,fileName); }
void endTitleHead(const char *fileName,const char *name)
{ forall(&OutputGenerator::endTitleHead,fileName,name); }
void startTitle()
{ forall(&OutputGenerator::startTitle); }
void endTitle()
{ forall(&OutputGenerator::endTitle); }
void newParagraph()
{ forall(&OutputGenerator::newParagraph); }
void writeString(const char *text)
{ forall(&OutputGenerator::writeString,text); }
void startIndexList()
{ forall(&OutputGenerator::startIndexList); }
void endIndexList()
{ forall(&OutputGenerator::endIndexList); }
void startItemList()
{ forall(&OutputGenerator::startItemList); }
void endItemList()
{ forall(&OutputGenerator::endItemList); }
void startEnumList()
{ forall(&OutputGenerator::startEnumList); }
void endEnumList()
{ forall(&OutputGenerator::endEnumList); }
void startAlphabeticalIndexList()
{ forall(&OutputGenerator::startAlphabeticalIndexList); }
void endAlphabeticalIndexList()
{ forall(&OutputGenerator::endAlphabeticalIndexList); }
void writeIndexHeading(const char *s)
{ forall(&OutputGenerator::writeIndexHeading,s); }
void writeIndexItem(const char *ref,const char *file,const char *text)
{ forall(&OutputGenerator::writeIndexItem,ref,file,text); }
void docify(const char *s)
{ forall(&OutputGenerator::docify,s); }
void codify(const char *s)
{ forall(&OutputGenerator::codify,s); }
void writeObjectLink(const char *ref,const char *file,
const char *anchor, const char *text)
{ forall(&OutputGenerator::writeObjectLink,ref,file,anchor,text); }
void writeCodeLink(const char *ref,const char *file,
const char *anchor,const char *text)
{ forall(&OutputGenerator::writeCodeLink,ref,file,anchor,text); }
void startTextLink(const char *file,const char *anchor)
{ forall(&OutputGenerator::startTextLink,file,anchor); }
void endTextLink()
{ forall(&OutputGenerator::endTextLink); }
void startHtmlLink(const char *url)
{ forall(&OutputGenerator::startHtmlLink,url); }
void endHtmlLink()
{ forall(&OutputGenerator::endHtmlLink); }
void writeMailLink(const char *url)
{ forall(&OutputGenerator::writeMailLink,url); }
void writeStartAnnoItem(const char *type,const char *file,
const char *path,const char *name)
{ forall(&OutputGenerator::writeStartAnnoItem,type,file,path,name); }
void writeEndAnnoItem(const char *name)
{ forall(&OutputGenerator::writeEndAnnoItem,name); }
void startTypewriter()
{ forall(&OutputGenerator::startTypewriter); }
void endTypewriter()
{ forall(&OutputGenerator::endTypewriter); }
void startGroupHeader()
{ forall(&OutputGenerator::startGroupHeader); }
void endGroupHeader()
{ forall(&OutputGenerator::endGroupHeader); }
void writeListItem()
{ forall(&OutputGenerator::writeListItem); }
void startMemberSections()
{ forall(&OutputGenerator::startMemberSections); }
void endMemberSections()
{ forall(&OutputGenerator::endMemberSections); }
void startMemberHeader()
{ forall(&OutputGenerator::startMemberHeader); }
void endMemberHeader()
{ forall(&OutputGenerator::endMemberHeader); }
void startMemberSubtitle()
{ forall(&OutputGenerator::startMemberSubtitle); }
void endMemberSubtitle()
{ forall(&OutputGenerator::endMemberSubtitle); }
void startMemberList()
{ forall(&OutputGenerator::startMemberList); }
void endMemberList()
{ forall(&OutputGenerator::endMemberList); }
void startMemberItem(int i1)
{ forall(&OutputGenerator::startMemberItem,i1); }
void endMemberItem(bool b2)
{ forall(&OutputGenerator::endMemberItem,b2); }
void startMemberGroupHeader(bool b)
{ forall(&OutputGenerator::startMemberGroupHeader,b); }
void endMemberGroupHeader()
{ forall(&OutputGenerator::endMemberGroupHeader); }
void startMemberGroupDocs()
{ forall(&OutputGenerator::startMemberGroupDocs); }
void endMemberGroupDocs()
{ forall(&OutputGenerator::endMemberGroupDocs); }
void startMemberGroup()
{ forall(&OutputGenerator::startMemberGroup); }
void endMemberGroup(bool last)
{ forall(&OutputGenerator::endMemberGroup,last); }
void insertMemberAlign()
{ forall(&OutputGenerator::insertMemberAlign); }
void writeRuler()
{ forall(&OutputGenerator::writeRuler); }
void writeAnchor(const char *fileName,const char *name)
{ forall(&OutputGenerator::writeAnchor,fileName,name); }
void startCodeFragment()
{ forall(&OutputGenerator::startCodeFragment); }
void endCodeFragment()
{ forall(&OutputGenerator::endCodeFragment); }
void startPreFragment()
{ forall(&OutputGenerator::startPreFragment); }
void endPreFragment()
{ forall(&OutputGenerator::endPreFragment); }
void startCodeLine()
{ forall(&OutputGenerator::startCodeLine); }
void endCodeLine()
{ forall(&OutputGenerator::endCodeLine); }
void startEmphasis()
{ forall(&OutputGenerator::startEmphasis); }
void endEmphasis()
{ forall(&OutputGenerator::endEmphasis); }
void writeChar(char c)
{ forall(&OutputGenerator::writeChar,c); }
void startMemberDoc(const char *clName,const char *memName,
const char *anchor,const char *title)
{ forall(&OutputGenerator::startMemberDoc,clName,memName,anchor,title); }
void endMemberDoc()
{ forall(&OutputGenerator::endMemberDoc); }
void startDoxyAnchor(const char *fName,const char *anchor, const char *name)
{ forall(&OutputGenerator::startDoxyAnchor,fName,anchor,name); }
void endDoxyAnchor(const char *fn,const char *anchor)
{ forall(&OutputGenerator::endDoxyAnchor,fn,anchor); }
void startCodeAnchor(const char *label)
{ forall(&OutputGenerator::startCodeAnchor,label); }
void endCodeAnchor()
{ forall(&OutputGenerator::endCodeAnchor); }
void writeLatexSpacing()
{ forall(&OutputGenerator::writeLatexSpacing); }
void startDescription()
{ forall(&OutputGenerator::startDescription); }
void endDescription()
{ forall(&OutputGenerator::endDescription); }
void startDescItem()
{ forall(&OutputGenerator::startDescItem); }
void endDescItem()
{ forall(&OutputGenerator::endDescItem); }
void startSubsection()
{ forall(&OutputGenerator::startSubsection); }
void endSubsection()
{ forall(&OutputGenerator::endSubsection); }
void startSubsubsection()
{ forall(&OutputGenerator::startSubsubsection); }
void endSubsubsection()
{ forall(&OutputGenerator::endSubsubsection); }
void startCenter()
{ forall(&OutputGenerator::startCenter); }
void endCenter()
{ forall(&OutputGenerator::endCenter); }
void startSmall()
{ forall(&OutputGenerator::startSmall); }
void endSmall()
{ forall(&OutputGenerator::endSmall); }
void startSubscript()
{ forall(&OutputGenerator::startSubscript); }
void endSubscript()
{ forall(&OutputGenerator::endSubscript); }
void startSuperscript()
{ forall(&OutputGenerator::startSuperscript); }
void endSuperscript()
{ forall(&OutputGenerator::endSuperscript); }
void startTable(int cols)
{ forall(&OutputGenerator::startTable,cols); }
void endTable()
{ forall(&OutputGenerator::endTable); }
void nextTableRow()
{ forall(&OutputGenerator::nextTableRow); }
void endTableRow()
{ forall(&OutputGenerator::endTableRow); }
void nextTableColumn()
{ forall(&OutputGenerator::nextTableColumn); }
void endTableColumn()
{ forall(&OutputGenerator::endTableColumn); }
void lineBreak()
{ forall(&OutputGenerator::lineBreak); }
void startBold()
{ forall(&OutputGenerator::startBold); }
void endBold()
{ forall(&OutputGenerator::endBold); }
void writeCopyright()
{ forall(&OutputGenerator::writeCopyright); }
void writeQuote()
{ forall(&OutputGenerator::writeQuote); }
void writeUmlaut(char c)
{ forall(&OutputGenerator::writeUmlaut,c); }
void writeAcute(char c)
{ forall(&OutputGenerator::writeAcute,c); }
void writeGrave(char c)
{ forall(&OutputGenerator::writeGrave,c); }
void writeCirc(char c)
{ forall(&OutputGenerator::writeCirc,c); }
void writeTilde(char c)
{ forall(&OutputGenerator::writeTilde,c); }
void writeRing(char c)
{ forall(&OutputGenerator::writeRing,c); }
void writeSharpS()
{ forall(&OutputGenerator::writeSharpS); }
void writeCCedil(char c)
{ forall(&OutputGenerator::writeCCedil,c); }
void startMemberDescription()
{ forall(&OutputGenerator::startMemberDescription); }
void endMemberDescription()
{ forall(&OutputGenerator::endMemberDescription); }
void startDescList()
{ forall(&OutputGenerator::startDescList); }
void endDescList()
{ forall(&OutputGenerator::endDescList); }
void startParamList()
{ forall(&OutputGenerator::startParamList); }
void endParamList()
{ forall(&OutputGenerator::endParamList); }
void endDescTitle()
{ forall(&OutputGenerator::endDescTitle); }
void writeDescItem()
{ forall(&OutputGenerator::writeDescItem); }
void startIndent()
{ forall(&OutputGenerator::startIndent); }
void endIndent()
{ forall(&OutputGenerator::endIndent); }
void startSection(const char *lab,const char *title,bool sub)
{ forall(&OutputGenerator::startSection,lab,title,sub); }
void endSection(const char *lab,bool sub)
{ forall(&OutputGenerator::endSection,lab,sub); }
void writeSectionRef(const char *ref,const char *file,
const char *anchor, const char *title)
{ forall(&OutputGenerator::writeSectionRef,ref,file,anchor,title); }
void writeSectionRefItem(const char *page,const char *lab, const char *title)
{ forall(&OutputGenerator::writeSectionRefItem,page,lab,title); }
void addIndexItem(const char *s1,const char *s2)
{ forall(&OutputGenerator::addIndexItem,s1,s2); }
void writeSynopsis()
{ forall(&OutputGenerator::writeSynopsis); }
void startClassDiagram()
{ forall(&OutputGenerator::startClassDiagram); }
void endClassDiagram(ClassDiagram &d,const char *f,const char *n)
{ forall(&OutputGenerator::endClassDiagram,d,f,n); }
void startPageRef()
{ forall(&OutputGenerator::startPageRef); }
void endPageRef(const char *c,const char *a)
{ forall(&OutputGenerator::endPageRef,c,a); }
void startQuickIndexItem(const char *s,const char *l)
{ forall(&OutputGenerator::startQuickIndexItem,s,l); }
void endQuickIndexItem()
{ forall(&OutputGenerator::endQuickIndexItem); }
void writeFormula(const char *n,const char *t)
{ forall(&OutputGenerator::writeFormula,n,t); }
void writeNonBreakableSpace()
{ forall(&OutputGenerator::writeNonBreakableSpace); }
void startImage(const char *n,const char *s,bool c)
{ forall(&OutputGenerator::startImage,n,s,c); }
void endImage(bool c)
{ forall(&OutputGenerator::endImage,c); }
void startDescTable()
{ forall(&OutputGenerator::startDescTable); }
void endDescTable()
{ forall(&OutputGenerator::endDescTable); }
void startDescTableTitle()
{ forall(&OutputGenerator::startDescTableTitle); }
void endDescTableTitle()
{ forall(&OutputGenerator::endDescTableTitle); }
void startDescTableData()
{ forall(&OutputGenerator::startDescTableData); }
void endDescTableData()
{ forall(&OutputGenerator::endDescTableData); }
void startDotGraph()
{ forall(&OutputGenerator::startDotGraph); }
void endDotGraph(DotClassGraph &g)
{ forall(&OutputGenerator::endDotGraph,g); }
void startInclDepGraph()
{ forall(&OutputGenerator::startInclDepGraph); }
void endInclDepGraph(DotInclDepGraph &g)
{ forall(&OutputGenerator::endInclDepGraph,g); }
void writeGraphicalHierarchy(DotGfxHierarchyTable &g)
{ forall(&OutputGenerator::writeGraphicalHierarchy,g); }
void startTextBlock(bool dense=FALSE)
{ forall(&OutputGenerator::startTextBlock,dense); }
void endTextBlock()
{ forall(&OutputGenerator::endTextBlock); }
void lastIndexPage()
{ forall(&OutputGenerator::lastIndexPage); }
void startMemberDocPrefixItem()
{ forall(&OutputGenerator::startMemberDocPrefixItem); }
void endMemberDocPrefixItem()
{ forall(&OutputGenerator::endMemberDocPrefixItem); }
void startMemberDocName()
{ forall(&OutputGenerator::startMemberDocName); }
void endMemberDocName()
{ forall(&OutputGenerator::endMemberDocName); }
void startParameter(bool first)
{ forall(&OutputGenerator::startParameter,first); }
void endParameter(bool last)
{ forall(&OutputGenerator::endParameter,last); }
void startFontClass(const char *c)
{ forall(&OutputGenerator::startFontClass,c); }
void endFontClass()
{ forall(&OutputGenerator::endFontClass); }
void startPlainFile(const char *name)
{
OutputGenerator *og=outputs->first();
while (og)
{
if (og->isEnabled()) (og->startPlainFile)(name);
og=outputs->next();
}
}
void endPlainFile()
{
OutputGenerator *og=outputs->first();
while (og)
{
if (og->isEnabled()) (og->endPlainFile)();
og=outputs->next();
}
}
private:
void debug();
void clear();
void forall(void (OutputGenerator::*func)());
void forall(void (OutputGenerator::*func)( const char * ), const char * ) ;
void forall(void (OutputGenerator::*func)( char ), char ) ;
void forall(void (OutputGenerator::*func)( IndexSections ), IndexSections ) ;
void forall(void (OutputGenerator::*func)( int ), int ) ;
void forall(void (OutputGenerator::*func)( DotClassGraph & ), DotClassGraph & ) ;
void forall(void (OutputGenerator::*func)( DotInclDepGraph & ), DotInclDepGraph & ) ;
void forall(void (OutputGenerator::*func)( DotGfxHierarchyTable & ), DotGfxHierarchyTable & ) ;
void forall(void (OutputGenerator::*func)( bool ), bool ) ;
void forall(void (OutputGenerator::*func)( bool , int ), bool , int ) ;
void forall(void (OutputGenerator::*func)( bool , bool ), bool , bool ) ;
void forall(void (OutputGenerator::*func)( int , bool ), int , bool ) ;
void forall(void (OutputGenerator::*func)( const char * , const char * ), const char * , const char * ) ;
void forall(void (OutputGenerator::*func)( const char * , bool ), const char * , bool ) ;
void forall(void (OutputGenerator::*func)( const char * , const char * , bool ), const char * , const char * , bool ) ;
void forall(void (OutputGenerator::*func)( uchar , uchar , uchar ), uchar , uchar , uchar ) ;
void forall(void (OutputGenerator::*func)( const char * , const char * , const char * ), const char * , const char * , const char * ) ;
void forall(void (OutputGenerator::*func)( ClassDiagram & , const char * , const char * ), ClassDiagram & , const char * , const char * ) ;
void forall(void (OutputGenerator::*func)( const char * , const char * , const char * , const char * ), const char * , const char * , const char * , const char * ) ;
OutputList(const OutputList &ol);
QList<OutputGenerator> *outputs;
};
# 31 "index.cpp" 2
# 1 "util.h" 1
# 1 "/usr/include/ctype.h" 1 3 4
extern const char *_ctype_;
extern const short *_tolower_tab_;
extern const short *_toupper_tab_;
extern "C" {
extern int isalnum (int) ;
extern int isalpha (int) ;
extern int iscntrl (int) ;
extern int isdigit (int) ;
extern int isgraph (int) ;
extern int islower (int) ;
extern int isprint (int) ;
extern int ispunct (int) ;
extern int isspace (int) ;
extern int isupper (int) ;
extern int isxdigit (int) ;
extern int tolower (int) ;
extern int toupper (int) ;
extern int isblank (int) ;
extern int isascii (int) ;
extern int toascii (int) ;
extern int _tolower (int) ;
extern int _toupper (int) ;
};
# 24 "util.h" 2
class ClassDef;
class FileDef;
class MemberList;
class NamespaceDef;
class FileNameDict;
class ArgumentList;
class OutputList;
class OutputDocInterface;
class MemberDef;
class ExampleList;
class ClassList;
class BaseClassList;
class GroupDef;
class NamespaceList;
class TextGeneratorIntf
{
public:
virtual void writeString(const char *) const = 0;
virtual void writeBreak() const = 0;
virtual void writeLink(const char *extRef,const char *file,
const char *anchor,const char *text
) const = 0;
};
class TextGeneratorOLImpl : public TextGeneratorIntf
{
public:
TextGeneratorOLImpl(OutputDocInterface &od);
void writeString(const char *s) const;
void writeBreak() const;
void writeLink(const char *extRef,const char *file,
const char *anchor,const char *text
) const;
private:
OutputDocInterface &m_od;
};
extern void linkifyText(const TextGeneratorIntf &ol,const char *clName,const char *name,
const char *text,bool autoBreak=FALSE,bool external=TRUE);
extern void setAnchors(char id,MemberList *ml,int groupId=-1);
extern QCString fileToString(const char *name,bool filter=FALSE);
extern QCString dateToString(bool);
extern bool getDefs(const QCString &scopeName,
const QCString &memberName,
const char *,
MemberDef *&md,
ClassDef *&cd,
FileDef *&fd,
NamespaceDef *&nd,
GroupDef *&gd,
bool forceEmptyScope=FALSE,
FileDef *currentFile=0
);
extern bool generateRef(OutputDocInterface &od,const char *,
const char *,bool inSeeBlock,const char * =0);
extern bool generateLink(OutputDocInterface &od,const char *,
const char *,bool inSeeBlock,const char *);
extern void generateFileRef(OutputDocInterface &od,const char *,
const char *linkTxt=0);
void writePageRef(OutputDocInterface &od,const char *cn,const char *mn);
extern bool matchArguments(ArgumentList *,ArgumentList *,
const char *cl=0,const char *ns=0,bool checkCV=TRUE,
NamespaceList *usingList=0);
extern void mergeArguments(ArgumentList *,ArgumentList *);
extern QCString substituteClassNames(const QCString &s);
extern QCString convertFileName(const QCString &s);
extern QCString substitute(const char *s,const char *src,const char *dst);
extern QCString resolveDefines(const char *n);
extern ClassDef *getClass(const char *key);
extern ClassDef *getResolvedClass(const char *key,bool *pIsTypeDef=0);
extern NamespaceDef *getResolvedNamespace(const char *key);
extern FileDef *findFileDef(const FileNameDict *fnDict,const char *n,
bool &ambig);
extern QCString showFileDefMatches(const FileNameDict *fnDict,const char *n);
extern int guessSection(const char *name);
extern bool isId(char c);
extern QCString removeRedundantWhiteSpace(const QCString &s);
QCString argListToString(ArgumentList *al);
QCString tempArgListToString(ArgumentList *al);
QCString generateMarker(int id);
void writeExample(OutputList &ol,ExampleList *el);
QCString stripAnnonymousScope(const QCString &s);
QCString stripAnnonymousNamespaceScope(const QCString &s);
QCString stripFromPath(const QCString &path);
bool rightScopeMatch(const QCString &scope, const QCString &name);
bool leftScopeMatch(const QCString &scope, const QCString &name);
QCString substituteKeywords(const QCString &s,const char *title);
int getPrefixIndex(const QCString &name);
QCString removeAnonymousScopes(const QCString &s);
QCString replaceAnonymousScopes(const QCString &s);
void initClassHierarchy(ClassList *cl);
bool hasVisibleRoot(BaseClassList *bcl);
int minClassDistance(ClassDef *cd,ClassDef *bcd,int level=0);
QCString convertNameToFile(const char *name,bool allowDots=FALSE);
void extractNamespaceName(const QCString &scopeName,
QCString &className,QCString &namespaceName);
QCString insertTemplateSpecifierInScope(const QCString &scope,const QCString &templ);
QCString stripScope(const char *name);
int iSystem(const char *command,const char *args,bool isBatchFile=FALSE);
QCString convertToHtml(const char *s);
QCString convertToXML(const char *s);
const char * getOverloadDocs();
# 32 "index.cpp" 2
# 1 "language.h" 1
# 1 "translator.h" 1
class Translator
{
protected:
QCString Win1250ToISO88592(const QCString & sInput)
{
static const char WinToISOTab[] = {
'\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87',
'\x88', '\x89', '\xA9', '\x8B', '\xA6', '\xAB', '\xAE', '\xAC',
'\x90', '\x91', '\x92', '\x93', '\x94', '\x2E', '\x96', '\x97',
'\x98', '\x99', '\xB9', '\x9B', '\xB6', '\xBB', '\xBE', '\xBC',
'\xA0', '\x20', '\x20', '\xA3', '\xA4', '\xA1', '\xA6', '\xA7',
'\x22', '\xA9', '\xAA', '\x3C', '\xAC', '\x2D', '\xAE', '\xAF',
'\x2E', '\x2B', '\x20', '\xB3', '\x27', '\x75', '\xB6', '\xB7',
'\x20', '\xB1', '\xBA', '\x3E', '\xA5', '\x22', '\xB5', '\xBF',
'\xC0', '\xC1', '\xC2', '\xC3', '\xC4', '\xC5', '\xC6', '\xC7',
'\xC8', '\xC9', '\xCA', '\xCB', '\xCC', '\xCD', '\xCE', '\xCF',
'\xD0', '\xD1', '\xD2', '\xD3', '\xD4', '\xD5', '\xD6', '\xD7',
'\xD8', '\xD9', '\xDA', '\xDB', '\xDC', '\xDD', '\xDE', '\xDF',
'\xE0', '\xE1', '\xE2', '\xE3', '\xE4', '\xE5', '\xE6', '\xE7',
'\xE8', '\xE9', '\xEA', '\xEB', '\xEC', '\xED', '\xEE', '\xEF',
'\xF0', '\xF1', '\xF2', '\xF3', '\xF4', '\xF5', '\xF6', '\x2D',
'\xF8', '\xF9', '\xFA', '\xFB', '\xFC', '\xFD', '\xFE', '\xFF',
'\0'
};
QCString result;
int len = sInput.length();
for (int i = 0; i < len; ++i)
{
unsigned int c = sInput[i];
result += (c > 127) ? WinToISOTab[c & 0x7F] : c;
}
return result;
}
QCString ISO88592ToWin1250(const QCString & sInput)
{
static const char ISOToWinTab[] = {
'\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87',
'\x88', '\x89', '\x8A', '\x8B', '\x8C', '\x8D', '\x8E', '\x8F',
'\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97',
'\x98', '\x99', '\x9A', '\x9B', '\x9C', '\x9D', '\x9E', '\x9F',
'\xA0', '\xA5', '\xA2', '\xA3', '\xA4', '\xBC', '\x8C', '\xA7',
'\xA8', '\x8A', '\xAA', '\x8D', '\x8F', '\xAD', '\x8E', '\xAF',
'\xB0', '\xB9', '\xB2', '\xB3', '\xB4', '\xBE', '\x9C', '\xB7',
'\xB8', '\x9A', '\xBA', '\x9D', '\x9F', '\xBD', '\x9E', '\xBF',
'\xC0', '\xC1', '\xC2', '\xC3', '\xC4', '\xC5', '\xC6', '\xC7',
'\xC8', '\xC9', '\xCA', '\xCB', '\xCC', '\xCD', '\xCE', '\xCF',
'\xD0', '\xD1', '\xD2', '\xD3', '\xD4', '\xD5', '\xD6', '\xD7',
'\xD8', '\xD9', '\xDA', '\xDB', '\xDC', '\xDD', '\xDE', '\xDF',
'\xE0', '\xE1', '\xE2', '\xE3', '\xE4', '\xE5', '\xE6', '\xE7',
'\xE8', '\xE9', '\xEA', '\xEB', '\xEC', '\xED', '\xEE', '\xEF',
'\xF0', '\xF1', '\xF2', '\xF3', '\xF4', '\xF5', '\xF6', '\xF7',
'\xF8', '\xF9', '\xFA', '\xFB', '\xFC', '\xFD', '\xFE', '\xFF',
'\0'
};
QCString result;
int len = sInput.length();
for (int i = 0; i < len; ++i)
{
unsigned int c = sInput[i];
result += (c > 127) ? ISOToWinTab[c & 0x7F] : c;
}
return result;
}
public:
virtual QCString idLanguage()
{ return "english"; }
virtual QCString latexLanguageSupportCommand()
{
return "";
}
virtual QCString latexBabelPackage()
{ return ""; }
virtual QCString idLanguageCharset()
{
return "iso-8859-1";
}
virtual QCString trRelatedFunctions()
{ return "Related Functions"; }
virtual QCString trRelatedSubscript()
{ return "(Note that these are not member functions.)"; }
virtual QCString trDetailedDescription()
{ return "Detailed Description"; }
virtual QCString trMemberTypedefDocumentation()
{ return "Member Typedef Documentation"; }
virtual QCString trMemberEnumerationDocumentation()
{ return "Member Enumeration Documentation"; }
virtual QCString trMemberFunctionDocumentation()
{ return "Member Function Documentation"; }
virtual QCString trMemberDataDocumentation()
{
if (Config::optimizeForCFlag)
{
return "Field Documentation";
}
else
{
return "Member Data Documentation";
}
}
virtual QCString trMore()
{ return "More..."; }
virtual QCString trListOfAllMembers()
{ return "List of all members."; }
virtual QCString trMemberList()
{ return "Member List"; }
virtual QCString trThisIsTheListOfAllMembers()
{ return "This is the complete list of members for "; }
virtual QCString trIncludingInheritedMembers()
{ return ", including all inherited members."; }
virtual QCString trGeneratedAutomatically(const char *s)
{ QCString result="Generated automatically by Doxygen";
if (s) result+=(QCString)" for "+s;
result+=" from the source code.";
return result;
}
virtual QCString trEnumName()
{ return "enum name"; }
virtual QCString trEnumValue()
{ return "enum value"; }
virtual QCString trDefinedIn()
{ return "defined in"; }
virtual QCString trVerbatimText(const char *f)
{ return (QCString)"This is the verbatim text of the "+f+" include file."; }
virtual QCString trModules()
{ return "Modules"; }
virtual QCString trClassHierarchy()
{ return "Class Hierarchy"; }
virtual QCString trCompoundList()
{
if (Config::optimizeForCFlag)
{
return "Data Structures";
}
else
{
return "Compound List";
}
}
virtual QCString trFileList()
{ return "File List"; }
virtual QCString trHeaderFiles()
{ return "Header Files"; }
virtual QCString trCompoundMembers()
{
if (Config::optimizeForCFlag)
{
return "Data Fields";
}
else
{
return "Compound Members";
}
}
virtual QCString trFileMembers()
{
if (Config::optimizeForCFlag)
{
return "Globals";
}
else
{
return "File Members";
}
}
virtual QCString trRelatedPages()
{ return "Related Pages"; }
virtual QCString trExamples()
{ return "Examples"; }
virtual QCString trSearch()
{ return "Search"; }
virtual QCString trClassHierarchyDescription()
{ return "This inheritance list is sorted roughly, "
"but not completely, alphabetically:";
}
virtual QCString trFileListDescription(bool extractAll)
{
QCString result="Here is a list of all ";
if (!extractAll) result+="documented ";
result+="files with brief descriptions:";
return result;
}
virtual QCString trCompoundListDescription()
{
if (Config::optimizeForCFlag)
{
return "Here are the data structures with brief descriptions:";
}
else
{
return "Here are the classes, structs, "
"unions and interfaces with brief descriptions:";
}
}
virtual QCString trCompoundMembersDescription(bool extractAll)
{
QCString result="Here is a list of all ";
if (!extractAll) result+="documented ";
result+="class members with links to ";
if (extractAll)
result+="the class documentation for each member:";
else
result+="the classes they belong to:";
return result;
}
virtual QCString trFileMembersDescription(bool extractAll)
{
QCString result="Here is a list of all ";
if (!extractAll) result+="documented ";
if (Config::optimizeForCFlag)
{
result+="functions, variables, defines, enums, and typedefs";
}
else
{
result+="file members";
}
result+=" with links to ";
if (extractAll)
result+="the files they belong to:";
else
result+="the documentation:";
return result;
}
virtual QCString trHeaderFilesDescription()
{ return "Here are the header files that make up the API:"; }
virtual QCString trExamplesDescription()
{ return "Here is a list of all examples:"; }
virtual QCString trRelatedPagesDescription()
{ return "Here is a list of all related documentation pages:"; }
virtual QCString trModulesDescription()
{ return "Here is a list of all modules:"; }
virtual QCString trNoDescriptionAvailable()
{ return "No description available"; }
virtual QCString trDocumentation()
{ return "Documentation"; }
virtual QCString trModuleIndex()
{ return "Module Index"; }
virtual QCString trHierarchicalIndex()
{ return "Hierarchical Index"; }
virtual QCString trCompoundIndex()
{
if (Config::optimizeForCFlag)
{
return "Data Structure Index";
}
else
{
return "Compound Index";
}
}
virtual QCString trFileIndex()
{ return "File Index"; }
virtual QCString trModuleDocumentation()
{ return "Module Documentation"; }
virtual QCString trClassDocumentation()
{ return "Class Documentation"; }
virtual QCString trFileDocumentation()
{ return "File Documentation"; }
virtual QCString trExampleDocumentation()
{ return "Example Documentation"; }
virtual QCString trPageDocumentation()
{ return "Page Documentation"; }
virtual QCString trReferenceManual()
{ return "Reference Manual"; }
virtual QCString trDefines()
{ return "Defines"; }
virtual QCString trFuncProtos()
{ return "Function Prototypes"; }
virtual QCString trTypedefs()
{ return "Typedefs"; }
virtual QCString trEnumerations()
{ return "Enumerations"; }
virtual QCString trFunctions()
{ return "Functions"; }
virtual QCString trVariables()
{ return "Variables"; }
virtual QCString trEnumerationValues()
{ return "Enumeration values"; }
virtual QCString trAuthor()
{ return "Author"; }
virtual QCString trDefineDocumentation()
{ return "Define Documentation"; }
virtual QCString trFunctionPrototypeDocumentation()
{ return "Function Prototype Documentation"; }
virtual QCString trTypedefDocumentation()
{ return "Typedef Documentation"; }
virtual QCString trEnumerationTypeDocumentation()
{ return "Enumeration Type Documentation"; }
virtual QCString trEnumerationValueDocumentation()
{ return "Enumeration Value Documentation"; }
virtual QCString trFunctionDocumentation()
{ return "Function Documentation"; }
virtual QCString trVariableDocumentation()
{ return "Variable Documentation"; }
virtual QCString trCompounds()
{
if (Config::optimizeForCFlag)
{
return "Data Structures";
}
else
{
return "Compounds";
}
}
virtual QCString trFiles()
{ return "Files"; }
virtual QCString trGeneratedAt(const char *date,const char *projName)
{
QCString result=(QCString)"Generated at "+date;
if (projName) result+=(QCString)" for "+projName;
result+=(QCString)" by";
return result;
}
virtual QCString trWrittenBy()
{
return "written by";
}
virtual QCString trClassDiagram(const char *clName)
{
return (QCString)"Inheritance diagram for "+clName+":";
}
virtual QCString trForInternalUseOnly()
{ return "For internal use only."; }
virtual QCString trReimplementedForInternalReasons()
{ return "Reimplemented for internal reasons; the API is not affected."; }
virtual QCString trWarning()
{ return "Warning"; }
virtual QCString trBugsAndLimitations()
{ return "Bugs and limitations"; }
virtual QCString trVersion()
{ return "Version"; }
virtual QCString trDate()
{ return "Date"; }
virtual QCString trAuthors()
{ return "Author(s)"; }
virtual QCString trReturns()
{ return "Returns"; }
virtual QCString trSeeAlso()
{ return "See also"; }
virtual QCString trParameters()
{ return "Parameters"; }
virtual QCString trExceptions()
{ return "Exceptions"; }
virtual QCString trGeneratedBy()
{ return "Generated by"; }
virtual QCString trNamespaceList()
{ return "Namespace List"; }
virtual QCString trNamespaceListDescription(bool extractAll)
{
QCString result="Here is a list of all ";
if (!extractAll) result+="documented ";
result+="namespaces with brief descriptions:";
return result;
}
virtual QCString trFriends()
{ return "Friends"; }
virtual QCString trRelatedFunctionDocumentation()
{ return "Friends And Related Function Documentation"; }
virtual QCString trCompoundReference(const char *clName,
ClassDef::CompoundType compType,
bool isTemplate)
{
QCString result=(QCString)clName+" ";
switch(compType)
{
case ClassDef::Class: result+=" Class"; break;
case ClassDef::Struct: result+=" Struct"; break;
case ClassDef::Union: result+=" Union"; break;
case ClassDef::Interface: result+=" Interface"; break;
case ClassDef::Exception: result+=" Exception"; break;
}
if (isTemplate) result+=" Template";
result+=" Reference";
return result;
}
virtual QCString trFileReference(const char *fileName)
{
QCString result=fileName;
result+=" File Reference";
return result;
}
virtual QCString trNamespaceReference(const char *namespaceName)
{
QCString result=namespaceName;
result+=" Namespace Reference";
return result;
}
virtual QCString trPublicMembers()
{ return "Public Methods"; }
virtual QCString trPublicSlots()
{ return "Public Slots"; }
virtual QCString trSignals()
{ return "Signals"; }
virtual QCString trStaticPublicMembers()
{ return "Static Public Methods"; }
virtual QCString trProtectedMembers()
{ return "Protected Methods"; }
virtual QCString trProtectedSlots()
{ return "Protected Slots"; }
virtual QCString trStaticProtectedMembers()
{ return "Static Protected Methods"; }
virtual QCString trPrivateMembers()
{ return "Private Methods"; }
virtual QCString trPrivateSlots()
{ return "Private Slots"; }
virtual QCString trStaticPrivateMembers()
{ return "Static Private Methods"; }
virtual QCString trWriteList(int numEntries)
{
QCString result;
int i;
for (i=0;i<numEntries;i++)
{
result+=generateMarker(i);
if (i!=numEntries-1)
{
if (i<numEntries-2)
result+=", ";
else
result+=", and ";
}
}
return result;
}
virtual QCString trInheritsList(int numEntries)
{
return "Inherits "+trWriteList(numEntries)+".";
}
virtual QCString trInheritedByList(int numEntries)
{
return "Inherited by "+trWriteList(numEntries)+".";
}
virtual QCString trReimplementedFromList(int numEntries)
{
return "Reimplemented from "+trWriteList(numEntries)+".";
}
virtual QCString trReimplementedInList(int numEntries)
{
return "Reimplemented in "+trWriteList(numEntries)+".";
}
virtual QCString trNamespaceMembers()
{ return "Namespace Members"; }
virtual QCString trNamespaceMemberDescription(bool extractAll)
{
QCString result="Here is a list of all ";
if (!extractAll) result+="documented ";
result+="namespace members with links to ";
if (extractAll)
result+="the namespace documentation for each member:";
else
result+="the namespaces they belong to:";
return result;
}
virtual QCString trNamespaceIndex()
{ return "Namespace Index"; }
virtual QCString trNamespaceDocumentation()
{ return "Namespace Documentation"; }
virtual QCString trNamespaces()
{ return "Namespaces"; }
virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
bool single)
{
QCString result=(QCString)"The documentation for this ";
switch(compType)
{
case ClassDef::Class: result+="class"; break;
case ClassDef::Struct: result+="struct"; break;
case ClassDef::Union: result+="union"; break;
case ClassDef::Interface: result+="interface"; break;
case ClassDef::Exception: result+="exception"; break;
}
result+=" was generated from the following file";
if (single) result+=":"; else result+="s:";
return result;
}
virtual QCString trAlphabeticalList()
{ return "Alphabetical List"; }
virtual QCString trReturnValues()
{ return "Return values"; }
virtual QCString trMainPage()
{ return "Main Page"; }
virtual QCString trPageAbbreviation()
{ return "p."; }
virtual QCString trSources()
{
return "Sources";
}
virtual QCString trDefinedAtLineInSourceFile()
{
return "Definition at line @0 of file @1.";
}
virtual QCString trDefinedInSourceFile()
{
return "Definition in file @0.";
}
virtual QCString trDeprecated()
{
return "Deprecated";
}
virtual QCString trCollaborationDiagram(const char *clName)
{
return (QCString)"Collaboration diagram for "+clName+":";
}
virtual QCString trInclDepGraph(const char *fName)
{
return (QCString)"Include dependency graph for "+fName+":";
}
virtual QCString trConstructorDocumentation()
{
return "Constructor & Destructor Documentation";
}
virtual QCString trGotoSourceCode()
{
return "Go to the source code of this file.";
}
virtual QCString trGotoDocumentation()
{
return "Go to the documentation of this file.";
}
virtual QCString trPrecondition()
{
return "Precondition";
}
virtual QCString trPostcondition()
{
return "Postcondition";
}
virtual QCString trInvariant()
{
return "Invariant";
}
virtual QCString trInitialValue()
{
return "Initial value:";
}
virtual QCString trCode()
{
return "code";
}
virtual QCString trGraphicalHierarchy()
{
return "Graphical Class Hierarchy";
}
virtual QCString trGotoGraphicalHierarchy()
{
return "Go to the graphical class hierarchy";
}
virtual QCString trGotoTextualHierarchy()
{
return "Go to the textual class hierarchy";
}
virtual QCString trPageIndex()
{
return "Page Index";
}
virtual QCString trNote()
{
return "Note";
}
virtual QCString trPublicTypes()
{
return "Public Types";
}
virtual QCString trPublicAttribs()
{
if (Config::optimizeForCFlag)
{
return "Data Fields";
}
else
{
return "Public Attributes";
}
}
virtual QCString trStaticPublicAttribs()
{
return "Static Public Attributes";
}
virtual QCString trProtectedTypes()
{
return "Protected Types";
}
virtual QCString trProtectedAttribs()
{
return "Protected Attributes";
}
virtual QCString trStaticProtectedAttribs()
{
return "Static Protected Attributes";
}
virtual QCString trPrivateTypes()
{
return "Private Types";
}
virtual QCString trPrivateAttribs()
{
return "Private Attributes";
}
virtual QCString trStaticPrivateAttribs()
{
return "Static Private Attributes";
}
virtual QCString trTodo()
{
return "Todo";
}
virtual QCString trTodoList()
{
return "Todo List";
}
virtual QCString trReferencedBy()
{
return "Referenced by";
}
virtual QCString trRemarks()
{
return "Remarks";
}
virtual QCString trAttention()
{
return "Attention";
}
virtual QCString trInclByDepGraph()
{
return "This graph shows which files directly or "
"indirectly include this file:";
}
virtual QCString trSince()
{
return "Since";
}
virtual QCString trLegendTitle()
{
return "Graph Legend";
}
virtual QCString trLegendDocs()
{
return
"This page explains how to interpret the graphs that are generated "
"by doxygen.<p>\n"
"Consider the following example:\n"
"\\code\n"
"/*! Invisible class because of truncation */\n"
"class Invisible { };\n\n"
"/*! Truncated class, inheritance relation is hidden */\n"
"class Truncated : public Invisible { };\n\n"
"/* Class not documented with doxygen comments */\n"
"class Undocumented { };\n\n"
"/*! Class that is inherited using public inheritance */\n"
"class PublicBase : public Truncated { };\n\n"
"/*! Class that is inherited using protected inheritance */\n"
"class ProtectedBase { };\n\n"
"/*! Class that is inherited using private inheritance */\n"
"class PrivateBase { };\n\n"
"/*! Class that is used by the Inherited class */\n"
"class Used { };\n\n"
"/*! Super class that inherits a number of other classes */\n"
"class Inherited : public PublicBase,\n"
" protected ProtectedBase,\n"
" private PrivateBase,\n"
" public Undocumented\n"
"{\n"
" private:\n"
" Used *m_usedClass;\n"
"};\n"
"\\endcode\n"
"If the \\c MAX_DOT_GRAPH_HEIGHT tag in the configuration file "
"is set to 200 this will result in the following graph:"
"<p><center><img src=\"graph_legend.gif\"></center>\n"
"<p>\n"
"The boxes in the above graph have the following meaning:\n"
"<ul>\n"
"<li>A filled black box represents the struct or class for which the "
"graph is generated.\n"
"<li>A box with a black border denotes a documented struct or class.\n"
"<li>A box with a grey border denotes an undocumented struct or class.\n"
"<li>A box with a red border denotes a documented struct or class for\n"
"which not all inheritance/containment relations are shown. A graph is "
"truncated if it does not fit within the specified boundaries."
"</ul>\n"
"The arrows have the following meaning:\n"
"<ul>\n"
"<li>A dark blue arrow is used to visualize a public inheritance "
"relation between two classes.\n"
"<li>A dark green arrow is used for protected inheritance.\n"
"<li>A dark red arrow is used for private inheritance.\n"
"<li>A purple dashed arrow is used if a class is contained or used "
"by another class. The arrow is labeled with the variable(s) "
"through which the pointed class or struct is accessible. \n"
"</ul>\n";
}
virtual QCString trLegend()
{
return "legend";
}
virtual QCString trTest()
{
return "Test";
}
virtual QCString trTestList()
{
return "Test List";
}
virtual QCString trDCOPMethods()
{
return "DCOP Methods";
}
virtual QCString trProperties()
{
return "Properties";
}
virtual QCString trPropertyDocumentation()
{
return "Property Documentation";
}
virtual QCString trInterfaces()
{
return "Interfaces";
}
virtual QCString trClasses()
{
if (Config::optimizeForCFlag)
{
return "Data Structures";
}
else
{
return "Classes";
}
}
virtual QCString trPackage(const char *name)
{
return (QCString)"Package "+name;
}
virtual QCString trPackageList()
{
return "Package List";
}
virtual QCString trPackageListDescription()
{
return "Here are the packages with brief descriptions (if available):";
}
virtual QCString trPackages()
{
return "Packages";
}
virtual QCString trPackageDocumentation()
{
return "Package Documentation";
}
virtual QCString trDefineValue()
{
return "Value:";
}
virtual QCString trBug()
{
return "Bug";
}
virtual QCString trBugList()
{
return "Bug List";
}
};
# 21 "language.h" 2
extern Translator *theTranslator;
extern bool setTranslator(const char *languageName);
# 34 "index.cpp" 2
# 1 "ftvhelp.h" 1
class QFile;
class FTVHelp
{
public:
static FTVHelp *getInstance();
void initialize();
void finalize();
int incContentsDepth();
int decContentsDepth();
int contentsDepth() { return m_dc; }
void addContentsItem(bool isDir,
const char *ref,
const char *file,
const char *anchor,
const char *name);
private:
FTVHelp();
QFile *m_cf;
QTextStream m_cts;
int m_dc;
static FTVHelp *m_theInstance;
};
# 36 "index.cpp" 2
# 1 "dot.h" 1
class ClassDef;
class FileDef;
class QTextStream;
class DotNodeList;
enum GraphOutputFormat { GIF , EPS };
struct EdgeInfo
{
enum Colors { Blue=0, Green=1, Red=2, Black=3, Grey=4 };
enum Styles { Solid=0, Dashed=1 };
EdgeInfo() : m_color(0), m_style(0), m_labColor(0) {}
~EdgeInfo() {}
int m_color;
int m_style;
QCString m_label;
QCString m_url;
int m_labColor;
};
class DotNode
{
friend class DotGfxHierarchyTable;
friend class DotClassGraph;
friend class DotInclDepGraph;
friend class DotNodeList;
friend void writeDotGraph(
DotNode *root,
GraphOutputFormat f,
const QCString &baseName,
bool lrRank,
bool renderParents,
int distance,
bool backArrow
);
public:
DotNode(int n,const char *lab,const char *url,int distance = 0,bool rootNode=FALSE);
~DotNode();
void addChild(DotNode *n,
int edgeColor=EdgeInfo::Black,
int edgeStyle=EdgeInfo::Solid,
const char *edgeLab=0,
const char *edgeURL=0,
int edgeLabCol=-1
);
void setDistance(int distance);
void addParent(DotNode *n);
void deleteNode(DotNodeList &deletedList);
void removeChild(DotNode *n);
void removeParent(DotNode *n);
int number() const { return m_number; }
void write(QTextStream &t,GraphOutputFormat f,bool topDown,bool toChildren,
int maxDistance=1000,bool backArrows=TRUE);
int m_subgraphId;
void clearWriteFlag();
private:
void colorConnectedNodes(int curColor);
void writeBox(QTextStream &t,GraphOutputFormat f,
bool hasNonReachableChildren);
void writeArrow(QTextStream &t,GraphOutputFormat f,DotNode *cn,
EdgeInfo *ei,bool topDown, bool pointBack=TRUE);
const DotNode *findDocNode() const;
int m_number;
QCString m_label;
QCString m_url;
QList<DotNode> *m_parents;
QList<DotNode> *m_children;
QList<EdgeInfo> *m_edgeInfo;
bool m_deleted;
bool m_written;
bool m_hasDoc;
int m_distance;
bool m_isRoot;
};
class DotGfxHierarchyTable
{
public:
DotGfxHierarchyTable();
~DotGfxHierarchyTable();
void writeGraph(QTextStream &t,const char *path);
private:
void addHierarchy(DotNode *n,ClassDef *cd,bool hide);
QList<DotNode> *m_rootNodes;
QDict<DotNode> *m_usedNodes;
static int m_curNodeNumber;
DotNodeList *m_rootSubgraphs;
};
class DotClassGraph
{
public:
enum GraphType { Interface, Implementation, Inheritance };
DotClassGraph(ClassDef *cd,GraphType t,int maxRecusionDepth=1000);
~DotClassGraph();
bool isTrivial() const;
void writeGraph(QTextStream &t,GraphOutputFormat f,const char *path,
bool TBRank=TRUE,bool imageMap=TRUE);
QCString diskName() const;
private:
void buildGraph(ClassDef *cd,DotNode *n,int level,bool base);
void addClass(ClassDef *cd,DotNode *n,int prot,const char *label,
int level,const char *usedName,const char *templSpec,
bool base);
DotNode *m_startNode;
QDict<DotNode> *m_usedNodes;
static int m_curNodeNumber;
GraphType m_graphType;
int m_recDepth;
QCString m_diskName;
int m_maxDistance;
};
class DotInclDepGraph
{
public:
DotInclDepGraph(FileDef *fd,bool inverse=FALSE);
~DotInclDepGraph();
void writeGraph(QTextStream &t, GraphOutputFormat f,const char *path,
bool writeImageMap=TRUE);
bool isTrivial() const;
QCString diskName() const;
private:
void buildGraph(DotNode *n,FileDef *fd,int distance);
DotNode *m_startNode;
QDict<DotNode> *m_usedNodes;
static int m_curNodeNumber;
QCString m_diskName;
int m_maxDistance;
bool m_inverse;
};
void generateGraphLegend(const char *path);
# 37 "index.cpp" 2
# 1 "page.h" 1
class PageInfo
{
public:
PageInfo(const char *f, int l,const char *n,const char *d,const char *t) :
defFileName(f), defLine(l), name(n),
doc(d), title(t), todoId(0), testId(0),inGroup(0), sectionDict(0) {}
QCString defFileName;
int defLine;
QCString name;
QCString doc;
QCString title;
QCString reference;
QCString fileName;
QCString getOutputFileBase() const
{ return fileName; }
bool isReference() const { return !reference.isEmpty(); }
QCString getReference() const { return reference; }
void addSections(QList<QCString> *anchorList)
{
if (anchorList)
{
QCString *s=anchorList->first();
while (s)
{
SectionInfo *si=0;
if (!s->isEmpty() && (si=Doxygen::sectionDict[*s]))
{
if (sectionDict==0)
{
sectionDict = new SectionDict(17);
}
if (sectionDict->find(*s)==0)
{
sectionDict->insert(*s,si);
}
si->pageRef = this;
si->fileName = fileName;
}
s=anchorList->next();
}
}
}
void writeDocAnchorsToTagFile()
{
if (!Config::genTagFile.isEmpty() && sectionDict)
{
QDictIterator<SectionInfo> sdi(*sectionDict);
SectionInfo *si;
for (;(si=sdi.current());++sdi)
{
Doxygen::tagFile << " <docanchor>" << si->label << "</docanchor>" << endl;
}
}
}
int todoId;
int testId;
int bugId;
GroupDef *inGroup;
SectionDict *sectionDict;
};
class PageSDict : public SDict<PageInfo>
{
public:
PageSDict(int size) : SDict<PageInfo>(size) {}
~PageSDict() {}
int compareItems(QCollection::Item i1,QCollection::Item i2)
{
return qstricmp (((PageInfo *)i1)->name,((PageInfo *)i2)->name);
}
};
typedef SDict<PageInfo>::Iterator _SDictPageInfoIterator;
class PageSDictIterator : public _SDictPageInfoIterator
{
public:
PageSDictIterator(const PageSDict &d) : _SDictPageInfoIterator(d) {}
~PageSDictIterator() {}
};
# 38 "index.cpp" 2
int annotatedClasses;
int hierarchyClasses;
int documentedFunctions;
int documentedMembers;
int documentedHtmlFiles;
int documentedFiles;
int documentedGroups;
int documentedNamespaces;
int documentedNamespaceMembers;
int documentedIncludeFiles;
int documentedPages;
int indexedPages;
int documentedPackages;
int countClassHierarchy();
int countClassMembers();
int countFileMembers();
void countFiles(int &htmlFiles,int &files);
int countGroups();
int countNamespaces();
int countAnnotatedClasses();
int countNamespaceMembers();
int countIncludeFiles();
void countRelatedPages(int &docPages,int &indexPages);
int countPackages();
void countDataStructures()
{
annotatedClasses = countAnnotatedClasses();
hierarchyClasses = countClassHierarchy();
documentedMembers = countClassMembers();
documentedFunctions = countFileMembers();
countFiles(documentedHtmlFiles,documentedFiles);
countRelatedPages(documentedPages,indexedPages);
documentedGroups = countGroups();
documentedNamespaces = countNamespaces();
documentedNamespaceMembers = countNamespaceMembers();
documentedPackages = countPackages();
}
static bool g_memberIndexLetterUsed[256];
static bool g_fileIndexLetterUsed[256];
static bool g_namespaceIndexLetterUsed[256];
const int maxItemsBeforeQuickIndex = 50;
bool stripWord(QCString &s,QCString w)
{
bool success=FALSE;
if (s.left(w.length())==w)
{
success=TRUE;
s=s.right(s.length()-w.length());
}
return success;
}
QCString abbreviate(const char *s,const char *name)
{
QCString result=s;
QCString start1=(QCString)"The "+name+" class ";
QCString start2=(QCString)"The "+name+" widget ";
QCString start3=(QCString)"The "+name+" file ";
result=result.stripWhiteSpace();
if (!result.isEmpty() && result.at(result.length()-1)=='.')
result=result.left(result.length()-1);
bool found=FALSE;
found = found || stripWord(result,start1);
found = found || stripWord(result,start2);
found = found || stripWord(result,start3);
if (found)
{
bool found=FALSE;
found = found || stripWord(result,"is ");
found = found || stripWord(result,"provides ");
found = found || stripWord(result,"specifies ");
found = found || stripWord(result,"contains ");
found = found || stripWord(result,"represents ");
if (found)
{
stripWord(result,"a ");
stripWord(result,"an ");
stripWord(result,"the ");
}
}
if (!result.isEmpty())
{
int c=result[0];
if (c>='a' && c<='z') c+='A'-'a';
result[0]=c;
}
return result;
}
void writeQuickLinks(OutputList &ol,bool compact ,bool ext=FALSE)
{
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
QCString extLink;
if (ext) { extLink="_doc"; }
if (compact) ol.startCenter(); else ol.startItemList();
if (!compact) ol.writeListItem();
if (Config::ftvHelpFlag)
{
ol.startQuickIndexItem(extLink,"main.html");
}
else
{
ol.startQuickIndexItem(extLink,"index.html");
}
parseText(ol,theTranslator->trMainPage());
ol.endQuickIndexItem();
if (documentedPackages>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"packages.html");
parseText(ol,theTranslator->trPackages());
ol.endQuickIndexItem();
}
if (documentedGroups>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"modules.html");
parseText(ol,theTranslator->trModules());
ol.endQuickIndexItem();
}
if (documentedNamespaces>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"namespaces.html");
parseText(ol,theTranslator->trNamespaceList());
ol.endQuickIndexItem();
}
if (hierarchyClasses>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"hierarchy.html");
parseText(ol,theTranslator->trClassHierarchy());
ol.endQuickIndexItem();
}
if (annotatedClasses>0)
{
if (Config::alphaIndexFlag)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"classes.html");
parseText(ol,theTranslator->trAlphabeticalList());
ol.endQuickIndexItem();
}
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"annotated.html");
parseText(ol,theTranslator->trCompoundList());
ol.endQuickIndexItem();
}
if (documentedHtmlFiles>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"files.html");
parseText(ol,theTranslator->trFileList());
ol.endQuickIndexItem();
}
if (documentedNamespaceMembers>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"namespacemembers.html");
parseText(ol,theTranslator->trNamespaceMembers());
ol.endQuickIndexItem();
}
if (documentedMembers>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"functions.html");
parseText(ol,theTranslator->trCompoundMembers());
ol.endQuickIndexItem();
}
if (documentedFunctions>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"globals.html");
parseText(ol,theTranslator->trFileMembers());
ol.endQuickIndexItem();
}
if (indexedPages>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"pages.html");
parseText(ol,theTranslator->trRelatedPages());
ol.endQuickIndexItem();
}
if (Doxygen::exampleSDict->count()>0)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem(extLink,"examples.html");
parseText(ol,theTranslator->trExamples());
ol.endQuickIndexItem();
}
if (Config::searchEngineFlag)
{
if (!compact) ol.writeListItem();
ol.startQuickIndexItem("_cgi","");
parseText(ol,theTranslator->trSearch());
ol.endQuickIndexItem();
}
if (compact)
{
ol.endCenter();
ol.writeRuler();
}
else
{
ol.endItemList();
}
ol.popGeneratorState();
}
static bool manIsEnabled;
void startTitle(OutputList &ol,const char *fileName)
{
ol.startTitleHead(fileName);
manIsEnabled=ol.isEnabled(OutputGenerator::Man);
if (manIsEnabled) ol.disable(OutputGenerator::Man);
}
void endTitle(OutputList &ol,const char *fileName,const char *name)
{
if (manIsEnabled) ol.enable(OutputGenerator::Man);
ol.endTitleHead(fileName,name);
}
void startFile(OutputList &ol,const char *name,const char *title,bool external)
{
ol.startFile(name,title,external);
if (!Config::noIndexFlag) writeQuickLinks(ol,TRUE,external);
}
void endFile(OutputList &ol,bool external)
{
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
ol.writeFooter(0,external);
if (Config::footerFile.isEmpty())
{
parseText(ol,theTranslator->trGeneratedAt(
dateToString(TRUE),
Config::projectName
));
}
ol.writeFooter(1,external);
if (Config::footerFile.isEmpty())
{
parseText(ol,theTranslator->trWrittenBy());
}
ol.writeFooter(2,external);
ol.popGeneratorState();
ol.endFile();
}
void writeClassTree(OutputList &ol,BaseClassList *bcl,bool hideSuper)
{
HtmlHelp *htmlHelp=0;
FTVHelp *ftvHelp=0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
}
BaseClassListIterator bcli(*bcl);
bool started=FALSE;
for ( ; bcli.current() ; ++bcli)
{
ClassDef *cd=bcli.current()->classDef;
if (cd->isVisibleInHierarchy() && hasVisibleRoot(cd->baseClasses()))
{
if (!started)
{
ol.startIndexList();
if (hasHtmlHelp) htmlHelp->incContentsDepth();
if (hasFtvHelp) ftvHelp->incContentsDepth();
started=TRUE;
}
bool hasChildren = !cd->visited && !hideSuper && cd->subClasses()->count()>0;
if (cd->isLinkable())
{
ol.writeIndexItem(cd->getReference(),cd->getOutputFileBase(),cd->displayName());
if (cd->isReference())
{
ol.startTypewriter();
ol.docify(" [external]");
ol.endTypewriter();
}
if (hasHtmlHelp)
{
htmlHelp->addContentsItem(hasChildren,cd->name(),cd->getOutputFileBase());
}
if (hasFtvHelp)
{
ftvHelp->addContentsItem(hasChildren,cd->getReference(),cd->getOutputFileBase(),0,cd->name());
}
}
else
{
ol.writeIndexItem(0,0,cd->name());
if (hasHtmlHelp)
{
htmlHelp->addContentsItem(hasChildren,cd->name(),0);
}
if (hasFtvHelp)
{
ftvHelp->addContentsItem(hasChildren,0,0,0,cd->name());
}
}
if (hasChildren)
{
bool wasVisited=cd->visited;
cd->visited=TRUE;
writeClassTree(ol,cd->subClasses(),wasVisited);
}
}
}
if (started)
{
ol.endIndexList();
if (hasHtmlHelp) htmlHelp->decContentsDepth();
if (hasFtvHelp) ftvHelp->decContentsDepth();
}
}
void writeClassTree(BaseClassList *cl)
{
HtmlHelp *htmlHelp=0;
FTVHelp *ftvHelp=0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
}
BaseClassListIterator cli(*cl);
bool started=FALSE;
for ( ; cli.current() ; ++cli)
{
ClassDef *cd=cli.current()->classDef;
if (cd->isVisibleInHierarchy() && !cd->visited)
{
if (!started)
{
if (hasHtmlHelp) htmlHelp->incContentsDepth();
if (hasFtvHelp) ftvHelp->incContentsDepth();
started=TRUE;
}
bool hasChildren = cd->subClasses()->count()>0;
if (cd->isLinkable())
{
if (hasHtmlHelp)
{
htmlHelp->addContentsItem(hasChildren,cd->name(),cd->getOutputFileBase());
}
if (hasFtvHelp)
{
ftvHelp->addContentsItem(hasChildren,cd->getReference(),cd->getOutputFileBase(),0,cd->name());
}
}
if (hasChildren)
{
writeClassTree(cd->subClasses());
}
cd->visited=TRUE;
}
}
if (started)
{
if (hasHtmlHelp) htmlHelp->decContentsDepth();
if (hasFtvHelp) ftvHelp->decContentsDepth();
}
}
void writeClassTree(ClassList *cl)
{
HtmlHelp *htmlHelp=0;
FTVHelp *ftvHelp=0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
}
ClassListIterator cli(*cl);
bool started=FALSE;
for ( ; cli.current() ; ++cli)
{
ClassDef *cd=cli.current();
if (cd->isVisibleInHierarchy() && !cd->visited)
{
if (!started)
{
started=TRUE;
}
bool hasChildren = cd->subClasses()->count()>0;
if (cd->isLinkable())
{
if (hasHtmlHelp)
{
htmlHelp->addContentsItem(hasChildren,cd->name(),cd->getOutputFileBase());
}
if (hasFtvHelp)
{
ftvHelp->addContentsItem(hasChildren,cd->getReference(),cd->getOutputFileBase(),0,cd->name());
}
}
if (hasChildren)
{
writeClassTree(cd->subClasses());
}
cd->visited=TRUE;
}
}
}
void writeClassHierarchy(OutputList &ol)
{
initClassHierarchy(&Doxygen::classList);
HtmlHelp *htmlHelp=0;
FTVHelp *ftvHelp=0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
}
bool started=FALSE;
ClassListIterator cli(Doxygen::classList);
for (;cli.current(); ++cli)
{
ClassDef *cd=cli.current();
if (!hasVisibleRoot(cd->baseClasses()))
{
if (cd->isVisibleInHierarchy())
{
if (!started)
{
ol.startIndexList();
if (hasHtmlHelp) htmlHelp->incContentsDepth();
if (hasFtvHelp) ftvHelp->incContentsDepth();
started=TRUE;
}
bool hasChildren = !cd->visited && cd->subClasses()->count()>0;
if (cd->isLinkable())
{
ol.writeIndexItem(cd->getReference(),cd->getOutputFileBase(),cd->displayName());
if (cd->isReference())
{
ol.startTypewriter();
ol.docify(" [external]");
ol.endTypewriter();
}
if (hasHtmlHelp)
{
htmlHelp->addContentsItem(hasChildren,cd->name(),cd->getOutputFileBase());
}
if (hasFtvHelp)
{
ftvHelp->addContentsItem(hasChildren,cd->getReference(),cd->getOutputFileBase(),0,cd->name());
}
}
else
{
ol.writeIndexItem(0,0,cd->displayName());
if (hasHtmlHelp)
{
htmlHelp->addContentsItem(hasChildren,cd->name(),0);
}
if (hasFtvHelp)
{
ftvHelp->addContentsItem(hasChildren,0,0,0,cd->name());
}
}
if (hasChildren)
{
writeClassTree(ol,cd->subClasses(),cd->visited);
cd->visited=TRUE;
}
}
}
}
if (started)
{
ol.endIndexList();
if (hasHtmlHelp) htmlHelp->decContentsDepth();
if (hasFtvHelp) ftvHelp->decContentsDepth();
}
}
int countClassHierarchy()
{
initClassHierarchy(&Doxygen::classList);
int count=0;
ClassListIterator cli(Doxygen::classList);
for ( ; cli.current(); ++cli)
{
if (cli.current()->subClasses()->count()>0) count++;
}
return count;
}
void writeHierarchicalIndex(OutputList &ol)
{
if (hierarchyClasses==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
startFile(ol,"hierarchy","Hierarchical Index");
startTitle(ol,0);
QCString title = theTranslator->trClassHierarchy();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
parseText(ol,title);
endTitle(ol,0,0);
ol.startTextBlock();
HtmlHelp *htmlHelp = 0;
FTVHelp *ftvHelp = 0;
if (Config::generateHtml && Config::htmlHelpFlag )
{
htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(TRUE,htmlHelpTitle,"hierarchy");
}
if (Config::generateHtml && Config::ftvHelpFlag )
{
ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(TRUE,0,"hierarchy",0,ftvHelpTitle);
}
if (Config::haveDotFlag && Config::gfxHierarchyFlag)
{
ol.disable(OutputGenerator::Latex);
ol.disable(OutputGenerator::RTF);
ol.startTextLink("inherits",0);
parseText(ol,theTranslator->trGotoGraphicalHierarchy());
ol.endTextLink();
ol.newParagraph();
ol.enable(OutputGenerator::Latex);
ol.enable(OutputGenerator::RTF);
}
parseText(ol,theTranslator->trClassHierarchyDescription());
ol.endTextBlock();
writeClassHierarchy(ol);
endFile(ol);
ol.popGeneratorState();
}
void writeGraphicalClassHierarchy(OutputList &ol)
{
if (hierarchyClasses==0) return;
ol.disableAllBut(OutputGenerator::Html);
startFile(ol,"inherits","Graphical Class Hierarchy");
startTitle(ol,0);
QCString title = theTranslator->trGraphicalHierarchy();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
parseText(ol,title);
endTitle(ol,0,0);
ol.startTextBlock();
HtmlHelp *htmlHelp = 0;
FTVHelp *ftvHelp = 0;
if (Config::generateHtml && Config::htmlHelpFlag)
{
htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(FALSE,htmlHelpTitle,"inherits");
}
if (Config::generateHtml && Config::ftvHelpFlag)
{
ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(FALSE,0,"inherits",0,ftvHelpTitle);
}
ol.startTextLink("hierarchy",0);
parseText(ol,theTranslator->trGotoTextualHierarchy());
ol.endTextLink();
ol.newParagraph();
ol.endTextBlock();
DotGfxHierarchyTable g;
ol.writeGraphicalHierarchy(g);
endFile(ol);
ol.enableAll();
}
void countFiles(int &htmlFiles,int &files)
{
htmlFiles=0;
files=0;
FileNameListIterator fnli(Doxygen::inputNameList);
FileName *fn;
for (;(fn=fnli.current());++fnli)
{
FileNameIterator fni(*fn);
FileDef *fd;
for (;(fd=fni.current());++fni)
{
bool doc = fd->isLinkableInProject();
bool src = fd->generateSourceFile();
bool nameOk = fd->name().right(4)!=".doc" &&
fd->name().right(4)!=".txt";
if (nameOk)
{
if (doc || src)
{
htmlFiles++;
}
if (doc)
{
files++;
}
}
}
}
}
void writeFileIndex(OutputList &ol)
{
if (documentedHtmlFiles==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
if (documentedFiles==0) ol.disableAllBut(OutputGenerator::Html);
startFile(ol,"files","File Index");
startTitle(ol,0);
QCString title = theTranslator->trFileList();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
parseText(ol,title);
endTitle(ol,0,0);
ol.startTextBlock();
HtmlHelp *htmlHelp = 0;
FTVHelp *ftvHelp = 0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(TRUE,htmlHelpTitle,"files");
htmlHelp->incContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(TRUE,0,"files",0,ftvHelpTitle);
ftvHelp->incContentsDepth();
}
parseText(ol,theTranslator->trFileListDescription(Config::extractAllFlag));
ol.endTextBlock();
OutputNameDict outputNameDict(1009);
OutputNameList outputNameList;
outputNameList.setAutoDelete(TRUE);
if (Config::fullPathNameFlag)
{
FileName *fn=Doxygen::inputNameList.first();
while (fn)
{
FileDef *fd=fn->first();
while (fd)
{
QCString path=fd->getPath();
if (path.isEmpty()) path="[external]";
FileList *fl = outputNameDict.find(path);
if (fl)
{
fl->inSort(fd);
}
else
{
fl = new FileList(path);
fl->inSort(fd);
outputNameList.inSort(fl);
outputNameDict.insert(path,fl);
}
fd=fn->next();
}
fn=Doxygen::inputNameList.next();
}
}
ol.startIndexList();
FileList *fl=0;
if (Config::fullPathNameFlag)
{
fl = outputNameList.first();
}
else
{
fl = Doxygen::inputNameList.first();
}
while (fl)
{
FileDef *fd=fl->first();
while (fd)
{
bool doc = fd->isLinkableInProject();
bool src = fd->generateSourceFile();
bool nameOk = fd->name().right(4)!=".doc" &&
fd->name().right(4)!=".txt";
if (nameOk && (doc || src) &&
!fd->isReference())
{
QCString path;
if (Config::fullPathNameFlag)
{
path=stripFromPath(fd->getPath().copy());
}
if (doc)
{
ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
ol.writeStartAnnoItem("file",
fd->getOutputFileBase(),
path,
fd->name()
);
if (!fd->briefDescription().isEmpty())
{
ol.docify(" (");
OutputList briefOutput(&ol);
parseDoc(briefOutput,fd->absFilePath(),1,
0,0,
abbreviate(fd->briefDescription(),fd->name()));
ol+=briefOutput;
ol.docify(")");
}
ol.writeEndAnnoItem(fd->getOutputFileBase());
ol.popGeneratorState();
}
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
ol.writeListItem();
ol.docify(path);
if (doc)
{
ol.writeObjectLink(0,fd->getOutputFileBase(),0,fd->name());
if (hasHtmlHelp)
{
htmlHelp->addContentsItem(FALSE,fd->name(),fd->getOutputFileBase());
}
if (hasFtvHelp)
{
ftvHelp->addContentsItem(FALSE,fd->getReference(),fd->getOutputFileBase(),0,fd->name());
}
}
else
{
ol.startBold();
ol.docify(fd->name());
ol.endBold();
if (hasHtmlHelp)
{
htmlHelp->addContentsItem(FALSE,fd->name(),0);
}
if (hasFtvHelp)
{
ftvHelp->addContentsItem(FALSE,0,0,0,fd->name());
}
}
if (src)
{
ol.docify(" ");
ol.startTextLink(fd->includeName(),0);
ol.docify("[");
parseText(ol,theTranslator->trCode());
ol.docify("]");
ol.endTextLink();
}
if (!fd->briefDescription().isEmpty())
{
ol.docify(" (");
OutputList briefOutput(&ol);
parseDoc(briefOutput,
fd->absFilePath(),1,
0,0,
abbreviate(fd->briefDescription(),fd->name()));
ol+=briefOutput;
ol.docify(")");
}
ol.popGeneratorState();
}
fd=fl->next();
}
if (Config::fullPathNameFlag)
{
fl=outputNameList.next();
}
else
{
fl=Doxygen::inputNameList.next();
}
}
ol.endIndexList();
if (hasHtmlHelp)
{
htmlHelp->decContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp->decContentsDepth();
}
endFile(ol);
ol.popGeneratorState();
}
int countNamespaces()
{
int count=0;
NamespaceListIterator nli(Doxygen::namespaceList);
NamespaceDef *nd;
for (;(nd=nli.current());++nli)
{
if (nd->isLinkableInProject()) count++;
}
return count;
}
void writeNamespaceIndex(OutputList &ol)
{
if (documentedNamespaces==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
startFile(ol,"namespaces","Namespace Index");
startTitle(ol,0);
QCString title = theTranslator->trNamespaceList();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
parseText(ol,title);
endTitle(ol,0,0);
ol.startTextBlock();
HtmlHelp *htmlHelp = 0;
FTVHelp *ftvHelp = 0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(TRUE,htmlHelpTitle,"namespaces");
htmlHelp->incContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(TRUE,0,"namespaces",0,ftvHelpTitle);
ftvHelp->incContentsDepth();
}
parseText(ol,theTranslator->trNamespaceListDescription(Config::extractAllFlag));
ol.endTextBlock();
bool first=TRUE;
NamespaceDef *nd=Doxygen::namespaceList.first();
while (nd)
{
if (nd->isLinkableInProject())
{
if (first)
{
ol.startIndexList();
first=FALSE;
}
ol.writeStartAnnoItem("namespace",nd->getOutputFileBase(),0,nd->name());
if (!nd->briefDescription().isEmpty())
{
ol.docify(" (");
OutputList briefOutput(&ol);
parseDoc(briefOutput,
nd->getDefFileName(),nd->getDefLine(),
nd->name(),0,
abbreviate(nd->briefDescription(),nd->name()));
ol+=briefOutput;
ol.docify(")");
}
ol.writeEndAnnoItem(nd->getOutputFileBase());
if (hasHtmlHelp)
{
htmlHelp->addContentsItem(FALSE,nd->name(),nd->getOutputFileBase());
}
if (hasFtvHelp)
{
ftvHelp->addContentsItem(FALSE,nd->getReference(),nd->getOutputFileBase(),0,nd->name());
}
}
nd=Doxygen::namespaceList.next();
}
if (!first) ol.endIndexList();
if (hasHtmlHelp)
{
htmlHelp->decContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp->decContentsDepth();
}
endFile(ol);
ol.popGeneratorState();
}
int countAnnotatedClasses()
{
int count=0;
ClassListIterator cli(Doxygen::classList);
ClassDef *cd;
for (;(cd=cli.current());++cli)
{
if (cd->isLinkableInProject())
{
count++;
}
}
return count;
}
void writeAnnotatedClassList(OutputList &ol)
{
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
ol.startIndexList();
ClassListIterator cli(Doxygen::classList);
ClassDef *cd;
for (;(cd=cli.current());++cli)
{
if (cd->isLinkableInProject())
{
QCString type=cd->compoundTypeString();
ol.writeStartAnnoItem(type,cd->getOutputFileBase(),0,cd->displayName());
if (!cd->briefDescription().isEmpty())
{
ol.docify(" (");
OutputList briefOutput(&ol);
parseDoc(briefOutput,
cd->getDefFileName(),cd->getDefLine(),
cd->name(),0,
abbreviate(cd->briefDescription(),cd->name()));
ol+=briefOutput;
ol.docify(")");
}
ol.writeEndAnnoItem(cd->getOutputFileBase());
if (hasHtmlHelp)
{
HtmlHelp::getInstance()->addContentsItem(FALSE,cd->name(),cd->getOutputFileBase());
}
if (hasFtvHelp)
{
FTVHelp::getInstance()->addContentsItem(FALSE,cd->getReference(),cd->getOutputFileBase(),0,cd->name());
}
}
}
ol.endIndexList();
}
void writePackageList(OutputList &ol)
{
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
ol.startIndexList();
PackageSDict::Iterator pdi(Doxygen::packageDict);
PackageDef *pd;
for (;(pd=pdi.current());++pdi)
{
if (!pd->isReference())
{
ol.writeStartAnnoItem("package",pd->getOutputFileBase(),0,pd->name());
if (!pd->briefDescription().isEmpty())
{
ol.docify(" (");
OutputList briefOutput(&ol);
parseDoc(briefOutput,
pd->getDefFileName(),pd->getDefLine(),
pd->name(),0,
abbreviate(pd->briefDescription(),pd->name()));
ol+=briefOutput;
ol.docify(")");
}
ol.writeEndAnnoItem(pd->getOutputFileBase());
if (hasHtmlHelp)
{
HtmlHelp::getInstance()->addContentsItem(FALSE,pd->name(),pd->getOutputFileBase());
}
if (hasFtvHelp)
{
FTVHelp::getInstance()->addContentsItem(FALSE,pd->getReference(),pd->getOutputFileBase(),0,pd->name());
}
}
}
ol.endIndexList();
}
void writeAlphabeticalClassList(OutputList &ol)
{
ol.startAlphabeticalIndexList();
ClassListIterator cli(Doxygen::classList);
ClassDef *cd;
char startLetter=0;
int headerItems=0;
for (;(cd=cli.current());++cli)
{
if (cd->isLinkableInProject())
{
int index = getPrefixIndex(cd->name());
if (((_toupper_tab_ + 1)[(unsigned char)( cd->name().at(index) )]) !=startLetter)
{
startLetter= ((_toupper_tab_ + 1)[(unsigned char)( cd->name().at(index) )]) ;
headerItems++;
}
}
}
const int columns = Config::colsInAlphaIndex;
int i,j;
int totalItems = headerItems + annotatedClasses;
int rows = (totalItems + columns - 1)/columns;
int itemsInLastRow = (totalItems + columns -1)%columns + 1;
ClassList *colList = new ClassList[columns];
int col=0,row=0;
startLetter=0;
for (cli.toFirst();(cd=cli.current());++cli)
{
if (cd->isLinkableInProject())
{
int index = getPrefixIndex(cd->name());
if (((_toupper_tab_ + 1)[(unsigned char)( cd->name().at(index) )]) !=startLetter)
{
startLetter= ((_toupper_tab_ + 1)[(unsigned char)( cd->name().at(index) )]) ;
colList[col].append((ClassDef *)8);
row++;
if ( row >= rows + ((col<itemsInLastRow) ? 0 : -1))
{
colList[col].append(cd);
col++;
row=0;
}
}
colList[col].append(cd);
row++;
if ( row >= rows + ((col<itemsInLastRow) ? 0 : -1)) { col++; row=0; }
}
}
ClassListIterator **colIterators = new ClassListIterator*[columns];
for (i=0;i<columns;i++)
{
colIterators[i] = new ClassListIterator(colList[i]);
}
for (i=0;i<rows;i++)
{
ol.nextTableRow();
int colsInRow = (i<rows-1) ? columns : itemsInLastRow;
for (j=0;j<colsInRow;j++)
{
ClassDef *cd = colIterators[j]->current();
if (cd==(ClassDef *)8)
{
cd=++(*colIterators[j]);
if (cd)
{
int index = getPrefixIndex(cd->name());
startLetter= ((_toupper_tab_ + 1)[(unsigned char)( cd->name().at(index) )]) ;
char s[2]; s[0]=startLetter; s[1]=0;
ol.writeIndexHeading(s);
}
}
else if (cd)
{
QCString cname;
QCString namesp;
if (Config::hideScopeNames)
{
cname=cd->displayName();
}
else
{
extractNamespaceName(cd->name(),cname,namesp);
}
ol.writeObjectLink(cd->getReference(),
cd->getOutputFileBase(),0,cname);
if (!namesp.isEmpty())
{
ol.docify(" (");
NamespaceDef *nd = getResolvedNamespace(namesp);
if (nd && nd->isLinkable())
{
ol.writeObjectLink(nd->getReference(),
nd->getOutputFileBase(),0,namesp);
}
else
{
ol.docify(namesp);
}
ol.docify(")");
}
ol.writeNonBreakableSpace();
++(*colIterators[j]);
}
ol.endTableColumn();
if (j<colsInRow-1) ol.nextTableColumn();
}
ol.endTableRow();
}
ol.endAlphabeticalIndexList();
for (i=0;i<columns;i++)
{
delete colIterators[i];
}
delete[] colIterators;
delete[] colList;
}
void writeAlphabeticalIndex(OutputList &ol)
{
if (annotatedClasses==0) return;
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
startFile(ol,"classes.html","Alphabetical index");
startTitle(ol,0);
parseText(ol,Config::projectName+" "+theTranslator->trCompoundIndex());
endTitle(ol,0,0);
writeAlphabeticalClassList(ol);
endFile(ol);
ol.popGeneratorState();
}
void writeAnnotatedIndex(OutputList &ol)
{
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
if (annotatedClasses==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
startFile(ol,"annotated","Annotated Index");
startTitle(ol,0);
QCString title = theTranslator->trCompoundList();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
parseText(ol,title);
endTitle(ol,0,0);
ol.startTextBlock();
HtmlHelp *htmlHelp = 0;
FTVHelp *ftvHelp = 0;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(TRUE,htmlHelpTitle,"annotated");
htmlHelp->incContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(TRUE,0,"annotated",0,ftvHelpTitle);
ftvHelp->incContentsDepth();
}
parseText(ol,theTranslator->trCompoundListDescription());
ol.endTextBlock();
writeAnnotatedClassList(ol);
if (hasHtmlHelp)
{
htmlHelp->decContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp->decContentsDepth();
}
endFile(ol);
ol.popGeneratorState();
}
void writePackageIndex(OutputList &ol)
{
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
if (documentedPackages==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
startFile(ol,"packages","Package Index");
startTitle(ol,0);
QCString title = theTranslator->trPackageList();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
parseText(ol,title);
endTitle(ol,0,0);
ol.startTextBlock();
HtmlHelp *htmlHelp = 0;
FTVHelp *ftvHelp = 0;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(TRUE,htmlHelpTitle,"packages");
htmlHelp->incContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(TRUE,0,"packages",0,ftvHelpTitle);
ftvHelp->incContentsDepth();
}
parseText(ol,theTranslator->trPackageListDescription());
ol.endTextBlock();
writePackageList(ol);
if (hasHtmlHelp)
{
htmlHelp->decContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp->decContentsDepth();
}
endFile(ol);
ol.popGeneratorState();
}
void writeMemberList(OutputList &ol,bool useSections)
{
bool first = TRUE;
char lastChar = 0;
MemberName *mn=Doxygen::memberNameList.first();
while (mn)
{
MemberDef *md=mn->first();
bool found=FALSE;
bool isFunc=FALSE;
while (md && !found)
{
ClassDef *cd;
if (
md->isLinkableInProject() &&
(cd=md->getClassDef()) &&
cd->isLinkableInProject()
)
{
found=TRUE;
isFunc=md->isFunction();
}
md=mn->next();
}
if (found)
{
if (useSections)
{
QCString name = mn->memberName();
if (((_tolower_tab_ + 1)[(unsigned char)( name.at(0) )]) !=lastChar)
{
if (!first) ol.endItemList();
char cs[2];
lastChar=cs[0]= ((_tolower_tab_ + 1)[(unsigned char)( name.at(0) )]) ;cs[1]='\0';
QCString anchor=(QCString)"index_"+cs;
QCString title=(QCString)"- "+cs+" -";
ol.startSection(anchor,title,TRUE);
ol.docify(title);
ol.endSection(anchor,TRUE);
ol.startItemList();
first=FALSE;
}
}
else if (first)
{
first=FALSE;
ol.startItemList();
}
ol.writeListItem();
ol.docify(mn->memberName());
if (isFunc) ol.docify("()");
ol.writeString("\n");
int count=0;
md=mn->last();
QCString prevName;
while (md)
{
ClassDef *cd=md->getClassDef();
if (
md->isLinkableInProject() &&
prevName!=cd->displayName() &&
cd->isLinkableInProject()
)
{
if (count==0)
ol.docify(": ");
else
ol.docify(", ");
ol.writeObjectLink(cd->getReference(),cd->getOutputFileBase(),md->anchor(),
cd->displayName());
count++;
prevName=cd->displayName();
}
md=mn->prev();
}
}
mn=Doxygen::memberNameList.next();
}
ol.endItemList();
}
int countClassMembers()
{
int i=0;for (i=0;i<256;i++) g_memberIndexLetterUsed[i]=FALSE;
int count=0;
MemberName *mn=Doxygen::memberNameList.first();
while (mn)
{
MemberDef *md=mn->first();
bool found=FALSE;
ClassDef *cd;
while (md && !found)
{
if (
md->isLinkableInProject() &&
(cd=md->getClassDef()) &&
cd->isLinkableInProject()
)
{
found=TRUE;
}
md=mn->next();
}
if (found)
{
QCString n = mn->memberName();
if (!n.isEmpty()) g_memberIndexLetterUsed[((_tolower_tab_ + 1)[(unsigned char)( n.at(0) )]) ]=TRUE;
count++;
}
mn=Doxygen::memberNameList.next();
}
return count;
}
void writeQuickMemberIndex(OutputList &ol,bool *charUsed)
{
bool first=TRUE;
int i;
ol.startCenter();
for (i=33;i<127;i++)
{
QCString anchor="index_";
char is[2];is[0]=(char)i;is[1]='\0';
if (charUsed[i])
{
if (!first)
{
ol.writeString(" | ");
}
ol.startTextLink(0,anchor+is);
ol.writeString(is);
ol.endTextLink();
first=FALSE;
}
}
ol.endCenter();
ol.newParagraph();
}
void writeMemberIndex(OutputList &ol)
{
if (documentedMembers==0) return;
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
startFile(ol,"functions","Compound Member Index");
QCString title = theTranslator->trCompoundMembers();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
startTitle(ol,0);
parseText(ol,title);
endTitle(ol,0,0);
bool quickIndex = documentedMembers>maxItemsBeforeQuickIndex;
if (quickIndex)
{
writeQuickMemberIndex(ol,g_memberIndexLetterUsed);
}
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag;
if (hasHtmlHelp)
{
HtmlHelp *htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(FALSE,htmlHelpTitle,"functions");
}
if (hasFtvHelp)
{
FTVHelp *ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(FALSE,0,"functions",0,ftvHelpTitle);
}
parseText(ol,theTranslator->trCompoundMembersDescription(Config::extractAllFlag));
writeMemberList(ol,quickIndex);
endFile(ol);
ol.popGeneratorState();
}
void writeFileMemberList(OutputList &ol,bool useSections)
{
char lastChar=0;
bool first=TRUE;
MemberName *mn=Doxygen::functionNameList.first();
while (mn)
{
MemberDef *md=mn->first();
bool found=FALSE;
while (md && !found)
{
FileDef *fd=md->getFileDef();
bool hasDocs = md->getFileDef() &&
md->getFileDef()->isLinkableInProject();
if (fd && hasDocs &&
md->isLinkableInProject()
) found=TRUE;
else
md=mn->next();
}
if (found)
{
if (useSections)
{
QCString name = mn->memberName();
if (((_tolower_tab_ + 1)[(unsigned char)( name.at(0) )]) !=lastChar)
{
if (!first) ol.endItemList();
char cs[2];
lastChar=cs[0]= ((_tolower_tab_ + 1)[(unsigned char)( name.at(0) )]) ;cs[1]='\0';
QCString anchor=(QCString)"index_"+cs;
QCString title=(QCString)"- "+cs+" -";
ol.startSection(anchor,title,TRUE);
ol.docify(title);
ol.endSection(anchor,TRUE);
ol.startItemList();
first=FALSE;
}
}
else if (first)
{
first=FALSE;
ol.startItemList();
}
ol.writeListItem();
ol.docify(md->name());
if (md->isFunction()) ol.docify("()");
ol.writeString("\n");
int count=0;
md=mn->last();
QCString prevName;
while (md)
{
FileDef *fd=md->getFileDef();
bool hasDocs = md->getFileDef() &&
md->getFileDef()->isLinkableInProject();
if (fd && hasDocs &&
md->isLinkableInProject() &&
prevName!=fd->name())
{
if (count==0)
ol.docify(": ");
else
ol.docify(", ");
QCString baseName=fd->name().copy();
ol.writeObjectLink(fd->getReference(),
fd->getOutputFileBase(),md->anchor(), baseName);
count++;
prevName=fd->name();
}
md=mn->prev();
}
}
mn=Doxygen::functionNameList.next();
}
ol.endItemList();
}
void writeNamespaceMemberList(OutputList &ol,bool useSections)
{
char lastChar=0;
bool first=TRUE;
MemberName *mn=Doxygen::functionNameList.first();
while (mn)
{
MemberDef *md=mn->first();
bool found=FALSE;
while (md && !found)
{
NamespaceDef *nd=md->getNamespaceDef();
if (nd && nd->isLinkableInProject() && md->isLinkableInProject())
found=TRUE;
else
md=mn->next();
}
if (found)
{
if (useSections)
{
QCString name = mn->memberName();
if (((_tolower_tab_ + 1)[(unsigned char)( name.at(0) )]) !=lastChar)
{
if (!first) ol.endItemList();
char cs[2];
lastChar=cs[0]= ((_tolower_tab_ + 1)[(unsigned char)( name.at(0) )]) ;cs[1]='\0';
QCString anchor=(QCString)"index_"+cs;
QCString title=(QCString)"- "+cs+" -";
ol.startSection(anchor,title,TRUE);
ol.docify(title);
ol.endSection(anchor,TRUE);
ol.startItemList();
first=FALSE;
}
}
else if (first)
{
ol.startItemList();
first=FALSE;
}
ol.writeListItem();
ol.docify(md->name());
if (md->isFunction()) ol.docify("()");
ol.writeString("\n");
int count=0;
md=mn->last();
QCString prevName;
while (md)
{
NamespaceDef *nd=md->getNamespaceDef();
if (nd && nd->isLinkableInProject() && md->isLinkableInProject() &&
prevName!=nd->name()
)
{
if (count==0)
ol.docify(": ");
else
ol.docify(", ");
ol.writeObjectLink(nd->getReference(),nd->getOutputFileBase(),
md->anchor(),nd->name());
count++;
prevName=nd->name();
}
md=mn->prev();
}
}
mn=Doxygen::functionNameList.next();
}
if (!first) ol.endItemList();
}
int countNamespaceMembers()
{
int i=0;for (i=0;i<256;i++) g_namespaceIndexLetterUsed[i]=FALSE;
int count=0;
MemberName *mn=Doxygen::functionNameList.first();
while (mn)
{
MemberDef *md=mn->first();
bool found=FALSE;
while (md && !found)
{
NamespaceDef *nd=md->getNamespaceDef();
if (nd && nd->isLinkableInProject() && md->isLinkableInProject())
{
QCString n = mn->memberName();
if (!n.isEmpty()) g_namespaceIndexLetterUsed[((_tolower_tab_ + 1)[(unsigned char)( n.at(0) )]) ]=TRUE;
found=TRUE;
}
else
md=mn->next();
}
if (found) count++;
mn=Doxygen::functionNameList.next();
}
return count;
}
int countFileMembers()
{
int i=0;for (i=0;i<256;i++) g_fileIndexLetterUsed[i]=FALSE;
int count=0;
MemberName *mn=Doxygen::functionNameList.first();
while (mn)
{
MemberDef *md=mn->first();
FileDef *fd;
bool found=FALSE;
while (md && !found)
{
if (md->isLinkableInProject() &&
(fd=md->getFileDef()) &&
fd->isLinkableInProject()
)
{
QCString n = mn->memberName();
if (!n.isEmpty()) g_fileIndexLetterUsed[((_tolower_tab_ + 1)[(unsigned char)( n.at(0) )]) ]=TRUE;
found=TRUE;
}
else
md=mn->next();
}
if (found) count++;
mn=Doxygen::functionNameList.next();
}
return count;
}
void writeFileMemberIndex(OutputList &ol)
{
if (documentedFunctions==0) return;
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
startFile(ol,"globals","File Member Index");
QCString title = theTranslator->trFileMembers();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
startTitle(ol,0);
parseText(ol,title);
endTitle(ol,0,0);
bool quickIndex = documentedMembers>maxItemsBeforeQuickIndex;
if (quickIndex)
{
writeQuickMemberIndex(ol,g_fileIndexLetterUsed);
}
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag;
if (hasHtmlHelp)
{
HtmlHelp *htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(FALSE,htmlHelpTitle,"globals");
}
if (hasFtvHelp)
{
FTVHelp *ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(FALSE,0,"globals",0,ftvHelpTitle);
}
parseText(ol,theTranslator->trFileMembersDescription(Config::extractAllFlag));
writeFileMemberList(ol,quickIndex);
endFile(ol);
ol.popGeneratorState();
}
void writeNamespaceMemberIndex(OutputList &ol)
{
if (documentedNamespaceMembers==0) return;
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
startFile(ol,"namespacemembers","Namespace Member Index");
QCString title = theTranslator->trNamespaceMembers();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
startTitle(ol,0);
parseText(ol,title);
endTitle(ol,0,0);
bool quickIndex = documentedMembers>maxItemsBeforeQuickIndex;
if (quickIndex)
{
writeQuickMemberIndex(ol,g_namespaceIndexLetterUsed);
}
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag;
if (hasHtmlHelp)
{
HtmlHelp *htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(FALSE,htmlHelpTitle,"namespacemembers");
}
if (hasFtvHelp)
{
FTVHelp *ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(FALSE,0,"namespacemembers",0,ftvHelpTitle);
}
parseText(ol,theTranslator->trNamespaceMemberDescription(Config::extractAllFlag));
writeNamespaceMemberList(ol,quickIndex);
endFile(ol);
ol.popGeneratorState();
}
void writeExampleIndex(OutputList &ol)
{
if (Doxygen::exampleSDict->count()==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
startFile(ol,"examples","Example Index");
startTitle(ol,0);
QCString title = theTranslator->trExamples();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
parseText(ol,title);
endTitle(ol,0,0);
ol.startTextBlock();
HtmlHelp *htmlHelp = 0;
FTVHelp *ftvHelp = 0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(TRUE,htmlHelpTitle,"examples");
htmlHelp->incContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(TRUE,0,"examples",0,ftvHelpTitle);
ftvHelp->incContentsDepth();
}
parseText(ol,theTranslator->trExamplesDescription());
ol.endTextBlock();
ol.startIndexList();
PageSDictIterator pdi(*Doxygen::exampleSDict);
PageInfo *pi=0;
for (pdi.toFirst();(pi=pdi.current());++pdi)
{
ol.writeListItem();
QCString n=convertFileName(pi->name)+"-example";
if (!pi->title.isEmpty())
{
ol.writeObjectLink(0,n,0,pi->title);
if (hasHtmlHelp) htmlHelp->addContentsItem(FALSE,pi->title,n);
if (hasFtvHelp) ftvHelp->addContentsItem(FALSE,pi->getReference(),n,0,pi->title);
}
else
{
ol.writeObjectLink(0,n,0,pi->name);
if (hasHtmlHelp) htmlHelp->addContentsItem(FALSE,pi->name,n);
if (hasFtvHelp) ftvHelp->addContentsItem(FALSE,pi->getReference(),n,0,pi->name);
}
ol.writeString("\n");
}
ol.endIndexList();
if (hasHtmlHelp)
{
htmlHelp->decContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp->decContentsDepth();
}
endFile(ol);
ol.popGeneratorState();
}
void countRelatedPages(int &docPages,int &indexPages)
{
docPages=indexPages=0;
PageSDictIterator pdi(*Doxygen::pageSDict);
PageInfo *pi=0;
for (pdi.toFirst();(pi=pdi.current());++pdi)
{
if (!pi->inGroup)
{
indexPages++;
if (!pi->isReference()) docPages++;
}
}
}
int countPackages()
{
int count=0;
PackageSDict::Iterator pdi(Doxygen::packageDict);
PackageDef *pd=0;
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
if (!pd->isReference())
{
count++;
}
}
return count;
}
void writePageIndex(OutputList &ol)
{
if (indexedPages==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
startFile(ol,"pages","Page Index");
startTitle(ol,0);
QCString title = theTranslator->trRelatedPages();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
parseText(ol,title);
endTitle(ol,0,0);
ol.startTextBlock();
HtmlHelp *htmlHelp = 0;
FTVHelp *ftvHelp = 0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag ;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag ;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(TRUE,htmlHelpTitle,"pages");
htmlHelp->incContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(TRUE,0,"pages",0,ftvHelpTitle);
ftvHelp->incContentsDepth();
}
parseText(ol,theTranslator->trRelatedPagesDescription());
ol.endTextBlock();
ol.startIndexList();
PageSDictIterator pdi(*Doxygen::pageSDict);
PageInfo *pi=0;
for (pdi.toFirst();(pi=pdi.current());++pdi)
{
if (!pi->inGroup )
{
QCString pageName,pageTitle;
if (Config::caseSensitiveNames)
pageName=pi->name.copy();
else
pageName=pi->name.lower();
if (pi->title.isEmpty())
pageTitle=pi->name;
else
pageTitle=pi->title;
ol.writeIndexItem(pi->getReference(),pi->getOutputFileBase(),pageTitle);
if (pi->isReference())
{
ol.startTypewriter();
ol.docify(" [external]");
ol.endTypewriter();
}
ol.writeString("\n");
if (hasHtmlHelp) htmlHelp->addContentsItem(FALSE,pageTitle,pageName);
if (hasFtvHelp) ftvHelp->addContentsItem(FALSE,0,pageName,0,pageTitle);
}
}
ol.endIndexList();
if (hasHtmlHelp)
{
htmlHelp->decContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp->decContentsDepth();
}
endFile(ol);
ol.popGeneratorState();
}
int countGroups()
{
int count=0;
GroupListIterator gli(Doxygen::groupList);
GroupDef *gd;
for (;(gd=gli.current());++gli)
{
if (!gd->isReference())
{
gd->visited=FALSE;
count++;
}
}
return count;
}
void writeGraphInfo(OutputList &ol)
{
if (!Config::haveDotFlag || !Config::generateHtml) return;
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
generateGraphLegend(Config::htmlOutputDir);
startFile(ol,"graph_legend","Graph Legend");
startTitle(ol,0);
parseText(ol,theTranslator->trLegendTitle());
endTitle(ol,0,0);
bool oldStripCommentsState = Config::stripCommentsFlag;
Config::stripCommentsFlag = FALSE;
parseDoc(ol,"graph_legend",1,0,0,theTranslator->trLegendDocs());
Config::stripCommentsFlag = oldStripCommentsState;
endFile(ol);
ol.popGeneratorState();
}
void writeGroupTreeNode(OutputList &ol, GroupDef *gd)
{
HtmlHelp *htmlHelp=0;
FTVHelp *ftvHelp = 0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
}
GroupDef *subgd = 0;
GroupListIterator gli(*gd->groupList);
if (!gd->visited)
{
bool hasSubGroups = gd->groupList->count()>0;
bool hasSubPages = gd->pageDict->count()>0;
if(htmlHelp)
{
htmlHelp->addContentsItem(hasSubGroups || hasSubPages,gd->groupTitle(),gd->getOutputFileBase());
htmlHelp->incContentsDepth();
}
if(ftvHelp)
{
ftvHelp->addContentsItem(hasSubGroups || hasSubPages,gd->getReference(),gd->getOutputFileBase(),0,gd->groupTitle());
ftvHelp->incContentsDepth();
}
ol.writeIndexItem(gd->getReference(),gd->getOutputFileBase(),gd->groupTitle());
if (gd->isReference())
{
ol.startTypewriter();
ol.docify(" [external]");
ol.endTypewriter();
}
PageSDictIterator pli(*gd->pageDict);
PageInfo *pi = 0;
for (pli.toFirst();(pi=pli.current());++pli)
{
SectionInfo *si=0;
if (!pi->name.isEmpty()) si=Doxygen::sectionDict[pi->name];
if(htmlHelp) htmlHelp->addContentsItem(FALSE,
convertToHtml(pi->title),
gd->getOutputFileBase(),
si ? si->label.data() : 0
);
if(ftvHelp) ftvHelp->addContentsItem(FALSE,
gd->getReference(),
gd->getOutputFileBase(),
si ? si->label.data() : 0,
convertToHtml(pi->title)
);
}
if (hasSubGroups)
{
ol.startIndexList();
for (gli.toLast();(subgd=gli.current());--gli)
{
writeGroupTreeNode(ol,subgd);
}
ol.endIndexList();
}
if (Config::htmlHelpTocExpandFlag)
{
struct MemInfo
{
MemInfo(MemberList *l,const QCString &n) { list=l; name=n; }
MemberList *list;
QCString name;
};
MemInfo memberLists[] =
{
MemInfo(&gd->defineMembers, theTranslator->trDefines()),
MemInfo(&gd->typedefMembers, theTranslator->trTypedefs()),
MemInfo(&gd->enumMembers, theTranslator->trEnumerations()),
MemInfo(&gd->enumValMembers, theTranslator->trEnumerationValues()),
MemInfo(&gd->funcMembers, theTranslator->trFunctions()),
MemInfo(&gd->varMembers, theTranslator->trVariables()),
MemInfo(&gd->protoMembers, theTranslator->trFuncProtos()),
MemInfo(0,0)
};
MemberList *members;
MemInfo *pMemInfo;
for (pMemInfo=&memberLists[0]; (members=pMemInfo->list) ; pMemInfo++)
{
if (members->count()>0)
{
if(htmlHelp)
{
htmlHelp->addContentsItem(TRUE, convertToHtml(pMemInfo->name), gd->getOutputFileBase(),0);
htmlHelp->incContentsDepth();
}
if(ftvHelp)
{
ftvHelp->addContentsItem(TRUE, gd->getReference(), gd->getOutputFileBase(), 0, pMemInfo->name);
ftvHelp->incContentsDepth();
}
MemberDef *md=members->first();
while (md)
{
GroupDef *gd=md->getGroupDef();
if(htmlHelp)
{
htmlHelp->addContentsItem(FALSE,md->name(),gd->getOutputFileBase(),md->anchor());
}
if(ftvHelp)
{
ftvHelp->addContentsItem(FALSE,gd->getReference(),gd->getOutputFileBase(),md->anchor(),md->name());
}
md=members->next();
}
if(htmlHelp) htmlHelp->decContentsDepth();
if(ftvHelp) ftvHelp->decContentsDepth();
}
}
NamespaceList *namespaceList=gd->namespaceList;
if (namespaceList->count()>0)
{
if(htmlHelp)
{
htmlHelp->addContentsItem(TRUE, convertToHtml(theTranslator->trNamespaces()), gd->getOutputFileBase(), 0);
htmlHelp->incContentsDepth();
}
if(ftvHelp)
{
ftvHelp->addContentsItem(TRUE, gd->getReference(), gd->getOutputFileBase(), 0, theTranslator->trNamespaces());
ftvHelp->incContentsDepth();
}
NamespaceDef *nsd=namespaceList->first();
while (nsd)
{
if(htmlHelp)
{
htmlHelp->addContentsItem(FALSE, convertToHtml(nsd->name()), nsd->getOutputFileBase());
}
if(ftvHelp)
{
ftvHelp->addContentsItem(FALSE, nsd->getReference(), nsd->getOutputFileBase(), 0, convertToHtml(nsd->name()));
}
nsd=namespaceList->next();
}
if (htmlHelp) htmlHelp->decContentsDepth();
if (ftvHelp) ftvHelp->decContentsDepth();
}
if(gd->classList->count()>0)
{
if(htmlHelp)
{
htmlHelp->addContentsItem(TRUE, convertToHtml(theTranslator->trClasses()), gd->getOutputFileBase(), 0);
htmlHelp->incContentsDepth();
}
if(ftvHelp)
{
ftvHelp->addContentsItem(TRUE, gd->getReference(), gd->getOutputFileBase(), 0, theTranslator->trClasses());
ftvHelp->incContentsDepth();
}
writeClassTree(gd->classList);
if(htmlHelp) htmlHelp->decContentsDepth();
if(ftvHelp) ftvHelp->decContentsDepth();
}
FileList *fileList=gd->fileList;
if (fileList->count()>0)
{
if(htmlHelp)
{
htmlHelp->addContentsItem(TRUE, convertToHtml(theTranslator->trFiles()), gd->getOutputFileBase(), 0);
htmlHelp->incContentsDepth();
}
if(ftvHelp)
{
ftvHelp->addContentsItem(TRUE, gd->getReference(), gd->getOutputFileBase(), 0, theTranslator->trFiles());
ftvHelp->incContentsDepth();
}
FileDef *fd=fileList->first();
while (fd)
{
if(htmlHelp)
htmlHelp->addContentsItem(FALSE,convertToHtml(fd->name()),fd->getOutputFileBase());
if(ftvHelp)
ftvHelp->addContentsItem(FALSE, fd->getReference(), fd->getOutputFileBase(), 0, convertToHtml(fd->name()));
fd=fileList->next();
}
if(htmlHelp)
htmlHelp->decContentsDepth();
if(ftvHelp)
ftvHelp->decContentsDepth();
}
if (gd->exampleDict->count()>0)
{
if(htmlHelp)
{
htmlHelp->addContentsItem(TRUE, convertToHtml(theTranslator->trExamples()), gd->getOutputFileBase(), 0);
htmlHelp->incContentsDepth();
}
if(ftvHelp)
{
ftvHelp->addContentsItem(TRUE, gd->getReference(), gd->getOutputFileBase(), 0, theTranslator->trExamples());
ftvHelp->incContentsDepth();
}
PageSDictIterator eli(*(gd->exampleDict));
PageInfo *pi=eli.toFirst();
while (pi)
{
if(htmlHelp)
{
htmlHelp->addContentsItem(FALSE,convertToHtml(pi->name),convertNameToFile(pi->name)+"-example");
}
if(ftvHelp)
{
ftvHelp->addContentsItem(FALSE,pi->getReference(),convertToHtml(pi->name)+"-example",0,convertNameToFile(pi->name));
}
pi=++eli;
}
if (htmlHelp) htmlHelp->decContentsDepth();
if (ftvHelp) ftvHelp->decContentsDepth();
}
}
if (htmlHelp) htmlHelp->decContentsDepth();
if (ftvHelp) ftvHelp->decContentsDepth();
gd->visited=TRUE;
}
}
void writeGroupHierarchy(OutputList &ol)
{
ol.startIndexList();
GroupListIterator gli(Doxygen::groupList);
GroupDef *gd;
for (;(gd=gli.current());++gli)
{
writeGroupTreeNode(ol,gd);
}
ol.endIndexList();
}
# 2465 "index.cpp"
void writeGroupIndex(OutputList &ol)
{
if (documentedGroups==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
startFile(ol,"modules","Module Index");
startTitle(ol,0);
QCString title = theTranslator->trModules();
QCString htmlHelpTitle = title;
QCString ftvHelpTitle = title;
if (!Config::projectName.isEmpty()) title.prepend(Config::projectName+" ");
parseText(ol,title);
endTitle(ol,0,0);
ol.startTextBlock();
HtmlHelp *htmlHelp = 0;
FTVHelp *ftvHelp = 0;
bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag;
bool hasFtvHelp = Config::generateHtml && Config::ftvHelpFlag;
if (hasHtmlHelp)
{
htmlHelp = HtmlHelp::getInstance();
htmlHelp->addContentsItem(TRUE,htmlHelpTitle,"modules");
htmlHelp->incContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp = FTVHelp::getInstance();
ftvHelp->addContentsItem(TRUE,0,"modules",0,ftvHelpTitle);
ftvHelp->incContentsDepth();
}
parseText(ol,theTranslator->trModulesDescription());
ol.endTextBlock();
writeGroupHierarchy(ol);
if (hasHtmlHelp)
{
htmlHelp->decContentsDepth();
}
if (hasFtvHelp)
{
ftvHelp->decContentsDepth();
}
endFile(ol);
ol.popGeneratorState();
}
void writeIndex(OutputList &ol)
{
ol.pushGeneratorState();
QCString projPrefix;
if (!Config::projectName.isEmpty())
{
projPrefix=Config::projectName+" ";
}
ol.disableAllBut(OutputGenerator::Html);
QCString defFileName =
Doxygen::mainPage ? Doxygen::mainPage->defFileName.data() : "<generated>";
int defLine =
Doxygen::mainPage ? Doxygen::mainPage->defLine : 1;
QCString title;
if (!Doxygen::mainPage || Doxygen::mainPage->title.isEmpty())
{
title = theTranslator->trMainPage();
}
else
{
title = substitute(Doxygen::mainPage->title,"%","");
}
QCString indexName="index";
if (Config::ftvHelpFlag) indexName="main";
ol.startFile(indexName,title,FALSE);
if (Config::generateHtml && Config::htmlHelpFlag)
{
HtmlHelp::getInstance()->addContentsItem(FALSE,title,indexName);
}
if (Config::generateHtml && Config::ftvHelpFlag)
{
FTVHelp::getInstance()->addContentsItem(FALSE,0,indexName,0,title);
}
if (!Config::noIndexFlag) writeQuickLinks(ol,TRUE);
ol.startTitleHead(0);
if (Doxygen::mainPage && !Doxygen::mainPage->title.isEmpty())
{
parseDoc(ol,defFileName,defLine,0,0,Doxygen::mainPage->title);
}
else
{
parseText(ol,projPrefix+theTranslator->trDocumentation());
}
ol.endTitleHead(0,0);
ol.newParagraph();
if (!Config::projectNumber.isEmpty())
{
ol.startProjectNumber();
parseDoc(ol,defFileName,defLine,0,0,Config::projectNumber);
ol.endProjectNumber();
}
if (Config::noIndexFlag && Doxygen::mainPage==0) writeQuickLinks(ol,FALSE);
if (Doxygen::mainPage)
{
parseDoc(ol,defFileName,defLine,0,0,Doxygen::mainPage->doc);
}
endFile(ol);
ol.disable(OutputGenerator::Html);
ol.enable(OutputGenerator::Latex);
ol.enable(OutputGenerator::RTF);
ol.startFile("refman",0,FALSE);
ol.startIndexSection(isTitlePageStart);
if (!Config::latexHeaderFile.isEmpty())
{
ol.disable(OutputGenerator::Latex);
}
parseText(ol,projPrefix+theTranslator->trReferenceManual());
if (!Config::projectNumber.isEmpty())
{
ol.startProjectNumber();
parseDoc(ol,defFileName,defLine,0,0,Config::projectNumber);
ol.endProjectNumber();
}
ol.endIndexSection(isTitlePageStart);
ol.startIndexSection(isTitlePageAuthor);
parseText(ol,theTranslator->trGeneratedBy());
ol.endIndexSection(isTitlePageAuthor);
if (Doxygen::mainPage)
{
ol.startIndexSection(isMainPage);
if (!Doxygen::mainPage->title.isEmpty())
{
parseDoc(ol,defFileName,defLine,0,0,Doxygen::mainPage->title);
}
else
{
parseText(ol,projPrefix+theTranslator->trMainPage());
}
ol.endIndexSection(isMainPage);
}
ol.enable(OutputGenerator::Latex);
if (documentedPackages>0)
{
ol.startIndexSection(isPackageIndex);
parseText(ol,projPrefix+theTranslator->trPackageList());
ol.endIndexSection(isPackageIndex);
}
if (documentedGroups>0)
{
ol.startIndexSection(isModuleIndex);
parseText(ol,projPrefix+theTranslator->trModuleIndex());
ol.endIndexSection(isModuleIndex);
}
if (documentedNamespaces>0)
{
ol.startIndexSection(isNamespaceIndex);
parseText(ol,projPrefix+theTranslator->trNamespaceIndex());
ol.endIndexSection(isNamespaceIndex);
}
if (hierarchyClasses>0)
{
ol.startIndexSection(isClassHierarchyIndex);
parseText(ol,projPrefix+theTranslator->trHierarchicalIndex());
ol.endIndexSection(isClassHierarchyIndex);
}
if (annotatedClasses>0)
{
ol.startIndexSection(isCompoundIndex);
parseText(ol,projPrefix+theTranslator->trCompoundIndex());
ol.endIndexSection(isCompoundIndex);
}
if (documentedFiles>0)
{
ol.startIndexSection(isFileIndex);
parseText(ol,projPrefix+theTranslator->trFileIndex());
ol.endIndexSection(isFileIndex);
}
if (indexedPages>0)
{
ol.startIndexSection(isPageIndex);
parseText(ol,projPrefix+theTranslator->trPageIndex());
ol.endIndexSection(isPageIndex);
}
ol.lastIndexPage();
if (documentedPackages>0)
{
ol.startIndexSection(isPackageDocumentation);
parseText(ol,projPrefix+theTranslator->trPackageDocumentation());
ol.endIndexSection(isPackageDocumentation);
}
if (documentedGroups>0)
{
ol.startIndexSection(isModuleDocumentation);
parseText(ol,projPrefix+theTranslator->trModuleDocumentation());
ol.endIndexSection(isModuleDocumentation);
}
if (documentedNamespaces>0)
{
ol.startIndexSection(isNamespaceDocumentation);
parseText(ol,projPrefix+theTranslator->trNamespaceDocumentation());
ol.endIndexSection(isNamespaceDocumentation);
}
if (annotatedClasses>0)
{
ol.startIndexSection(isClassDocumentation);
parseText(ol,projPrefix+theTranslator->trClassDocumentation());
ol.endIndexSection(isClassDocumentation);
}
if (documentedFiles>0)
{
ol.startIndexSection(isFileDocumentation);
parseText(ol,projPrefix+theTranslator->trFileDocumentation());
ol.endIndexSection(isFileDocumentation);
}
if (Doxygen::exampleSDict->count()>0)
{
ol.startIndexSection(isExampleDocumentation);
parseText(ol,projPrefix+theTranslator->trExampleDocumentation());
ol.endIndexSection(isExampleDocumentation);
}
if (documentedPages>0)
{
ol.startIndexSection(isPageDocumentation);
parseText(ol,projPrefix+theTranslator->trPageDocumentation());
ol.endIndexSection(isPageDocumentation);
}
ol.endIndexSection(isEndIndex);
endFile(ol);
if (Doxygen::mainPage)
{
ol.disable(OutputGenerator::Man);
startFile(ol,Doxygen::mainPage->name,Doxygen::mainPage->title);
ol.startTextBlock();
parseDoc(ol,defFileName,defLine,0,0,Doxygen::mainPage->doc);
ol.endTextBlock();
endFile(ol);
ol.enable(OutputGenerator::Man);
}
ol.popGeneratorState();
}