Attachment #114127 for bug #171883

Lines 2240-2246 Link Here

(-)qt-x11-commercial-3.3.8/configure (-1 / +1 lines)
2240		2240
2241	$XFTN -no-xft ............ Do not compile Xft (anti-aliased font) support.	2241	$XFTN -no-xft ............ Do not compile Xft (anti-aliased font) support.
2242	$XFTY -xft ............... Compile Xft support.	2242	$XFTY -xft ............... Compile Xft support.
2243	Requires X11/Xft/XftFreetype.h and libXft.	2243	Requires X11/Xft/Xft.h and libXft.
2244		2244
2245	$XIN -no-tablet ......... Do not compile Tablet support.	2245	$XIN -no-tablet ......... Do not compile Tablet support.
2246	$XIY -tablet ............ Compile Tablet support.	2246	$XIY -tablet ............ Compile Tablet support.

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/include/qglobal.h (-1 / +1 lines)
1	/****************************************************************************	1	/****************************************************************************
2	** $Id: qt/qglobal.h 3.3.8 edited Feb 2 15:00 $	2	** $Id: qt/qglobal.h 3.3.8 edited Mar 23 02:24 $
3	**	3	**
4	** Global type declarations and definitions	4	** Global type declarations and definitions
5	**	5	**

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/qmake/generators/unix/unixmake2.cpp (-1 / +2 lines)
1	/****************************************************************************	1	/****************************************************************************
2	** $Id: qt/unixmake2.cpp 3.3.8 edited Jan 11 14:37 $	2	** $Id: qt/unixmake2.cpp 3.3.8 edited Feb 19 21:45 $
3	**	3	**
4	** Implementation of UnixMakefileGenerator class.	4	** Implementation of UnixMakefileGenerator class.
5	**	5	**
Lines 1587-1590 Link Here
1587	<< project->variables()["PRL_EXPORT_CXXFLAGS"].join(" ")	1587	<< project->variables()["PRL_EXPORT_CXXFLAGS"].join(" ")
1588	// << varGlue("DEFINES","-D"," -D"," ")	1588	// << varGlue("DEFINES","-D"," -D"," ")
1589	<< " -I${includedir}";	1589	<< " -I${includedir}";
		1590	t << endl;
1590	}	1591	}




/****************************************************************************
** $Id: qt/qutfcodec.cpp   3.3.8   edited Mar 21 08:23 $
**
** Implementation of QUtf{8,16}Codec class
**


class QUtf8Decoder : public QTextDecoder {
    uint uc;
    uint min_uc;
    int need;
    bool headerDone;
public:

	result.setLength( len ); // worst case
	QChar *qch = (QChar *)result.unicode();
	uchar ch;
        int error = -1;
	for (int i=0; i<len; i++) {
	    ch = chars[i];
	    if (need) {
		if ( (ch&0xc0) == 0x80 ) {
		    uc = (uc << 6) | (ch & 0x3f);

			    *qch++ = QChar(high);
			    *qch++ = QChar(low);
			    headerDone = TRUE;
			} else if ((uc < min_uc) || (uc >= 0xd800 && uc <= 0xdfff) || (uc >= 0xfffe)) {
                            *qch++ = QChar::replacement;
			} else {
			    if (headerDone || QChar(uc) != QChar::byteOrderMark)
				*qch++ = uc;

		    }
		} else {
		    // error
                    i = error;
		    *qch++ = QChar::replacement;
		    need = 0;
		}

		} else if ((ch & 0xe0) == 0xc0) {
		    uc = ch & 0x1f;
		    need = 1;
                    error = i;
		    min_uc = 0x80;
		} else if ((ch & 0xf0) == 0xe0) {
		    uc = ch & 0x0f;
		    need = 2;
                    error = i;
		    min_uc = 0x800;
		} else if ((ch&0xf8) == 0xf0) {
		    uc = ch & 0x07;
		    need = 3;
                    error = i;
                    min_uc = 0x10000;
                } else {
                    // error
                    *qch++ = QChar::replacement;
                }
	    }
	}
	result.truncate( qch - result.unicode() );

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/src/kernel/qprinter.cpp (-5 / +1 lines)
1	/**********************************************************************	1	/**********************************************************************
2	** $Id: qt/qprinter.cpp 3.3.8 edited Jan 11 14:38 $	2	** $Id: qt/qprinter.cpp 3.3.8 edited Mar 1 14:39 $
3	**	3	**
4	** Implementation of QPrinter class	4	** Implementation of QPrinter class
5	**	5	**
Lines 124-133 Link Here
124	\omit Need a function to setup() without a dialog (i.e. use defaults).	124	\omit Need a function to setup() without a dialog (i.e. use defaults).
125	\endomit	125	\endomit
126		126
127	If your current locale converts "," to ".", you will need to set
128	a locale (via the standard C setlocale() function) that doen't do this
129	before using QPrinter. The "C" locale works well for this.
130
131	The TrueType font embedding for Qt's postscript driver uses code	127	The TrueType font embedding for Qt's postscript driver uses code
132	by David Chappell of Trinity College Computing Center.	128	by David Chappell of Trinity College Computing Center.
133		129

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/src/kernel/qprocess.cpp (-2 / +2 lines)
1	/****************************************************************************	1	/****************************************************************************
2	** $Id: qt/qprocess.cpp 3.3.8 edited Jan 11 14:38 $	2	** $Id: qt/qprocess.cpp 3.3.8 edited Mar 15 17:39 $
3	**	3	**
4	** Implementation of QProcess class	4	** Implementation of QProcess class
5	**	5	**
Lines 727-733 Link Here
727	void QProcess::writeToStdin( const QString& buf )	727	void QProcess::writeToStdin( const QString& buf )
728	{	728	{
729	QByteArray tmp = buf.local8Bit();	729	QByteArray tmp = buf.local8Bit();
730	tmp.resize( tmp.size() - 1 ); // drop the implicit \0	730	tmp.resize( qstrlen( tmp.data() ) );
731	writeToStdin( tmp );	731	writeToStdin( tmp );
732	}	732	}
733		733




/****************************************************************************
** $Id: qt/qscriptengine_x11.cpp   3.3.8   edited Mar 2 14:22 $
**
** Copyright (C) 2003-2007 Trolltech ASA.  All rights reserved.
**

static const unsigned char indicForms[0xe00-0x900] = {
    // Devangari
    Invalid, VowelMark, VowelMark, VowelMark,
    IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,
    IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,
    IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,



    Other, Other, Other, Other,
    Other, Other, Other, Other,
    Other, Other, Other, Consonant,
    Consonant, Consonant /* ??? */, Consonant, Consonant,

    // Bengali
    Invalid, VowelMark, VowelMark, VowelMark,

    Other, Other, Other, Other,

    // Gurmukhi
    Invalid, VowelMark, VowelMark, VowelMark,
    Invalid, IndependentVowel, IndependentVowel, IndependentVowel,
    IndependentVowel, IndependentVowel, IndependentVowel, Invalid,
    Invalid, Invalid, Invalid, IndependentVowel,

    Other, Other, Other, Other,
    Other, Other, Other, Other,

    StressMark, StressMark, Consonant, Consonant,
    Other, Other, Other, Other,
    Other, Other, Other, Other,
    Other, Other, Other, Other,

    Invalid, VowelMark, VowelMark, VowelMark,
    Invalid, IndependentVowel, IndependentVowel, IndependentVowel,
    IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,
    IndependentVowel, IndependentVowel, Invalid, IndependentVowel,

    IndependentVowel, IndependentVowel, Invalid, IndependentVowel,
    IndependentVowel, Consonant, Consonant, Consonant,

    Unknown, Unknown, Unknown, Unknown,
    Unknown, Unknown, Unknown, Unknown,

    IndependentVowel, IndependentVowel, VowelMark, VowelMark,
    Other, Other, Other, Other,
    Other, Other, Other, Other,
    Other, Other, Other, Other,

    Consonant, Consonant, Consonant, Consonant,

    Consonant, Invalid, Consonant, Consonant,
    Invalid, Consonant, Consonant, Consonant,
    Consonant, Consonant, Unknown, Unknown,
    Nukta, Other, Matra, Matra,


    Other, Other, Other, Other,
    Other, Other, Other, Other,

    Other, Consonant, Other, Other,
    Other, Other, Other, Other,
    Other, Other, Other, Other,
    Other, Other, Other, Other,

    Invalid, Invalid, Consonant, Consonant,

    Consonant, Consonant, Consonant, Consonant,
    Consonant, Consonant, Consonant, Consonant,
    Consonant, Consonant, Unknown, Unknown,
    Invalid, Invalid, Matra, Matra,


    Consonant, Consonant, Consonant, Consonant,
    Invalid, Consonant, Consonant, Consonant,
    Consonant, Consonant, Unknown, Unknown,
    Nukta, Other, Matra, Matra,

    Matra, Matra, Matra, Matra,
    Matra, Invalid, Matra, Matra,

    Invalid, Invalid, Invalid, Invalid,
    Invalid, Invalid, Consonant, Invalid,

    IndependentVowel, IndependentVowel, VowelMark, VowelMark,
    Invalid, Invalid, Other, Other,
    Other, Other, Other, Other,
    Other, Other, Other, Other,

    None, None, None, None,

    // Gurmukhi
    None, Above, Above, Post,
    None, None, None, None,
    None, None, None, None,
    None, None, None, None,

    None, None, None, None,
    None, None, None, None,

    None, None, Below, Below,
    None, None, None, None,
    None, None, None, None,
    None, None, None, None,

    None, None, None, None,
    None, None, Above, Post,
    None, None, None, None,
    None, None, None, Post,

    None, None, None, None,
    None, None, None, None,
    None, None, None, None,
    None, None, None, None,

    None, Below, None, None,
    None, None, None, None,
    None, None, None, None,
    None, None, None, None,

    None, None, None, None,
    None, None, Below, None,

    None, None, Below, Below,
    None, None, None, None,
    None, None, None, None,
    None, None, None, None,




  global:
  extern "C++"
  {
    QString::shared_null*;
    TID_QUType_Null*;
    TID_QUType_bool*;
    TID_QUType_charstar*;
    TID_QUType_double*;
    TID_QUType_enum*;
    TID_QUType_idisp*;
    TID_QUType_iface*;
    TID_QUType_int*;
    TID_QUType_ptr*;
    TID_QUType_varptr*;
    bin*;
    bitBlt*;
    copyBlt*;

    qInstallPathSysconf*;
    qInstallPathTranslations*;
    qItemRect*;
    qmemmove*;
    qNetworkProtocolRegister*;
    qObsolete*;
    qRed*;

    qSmartMinSize*;
    qSqlDriverExtDict*;
    qSqlOpenExtDict*;
    qSuppressObsoleteWarnings*;
    qSysInfo*;
    qSystemWarning*;
    qUncompress*;
    qVersion*;
    qWarning*;
    qWinAppCmdShow*;
    qWinAppInst*;
    qWinAppPrevInst*;
    qWinProcessConfigRequests*;
    qmemmove*;
    qstrcmp*;
    qstrcpy*;
    qstrdup*;
    qstricmp*;
    QString::shared_null*;
    qstrlen*;
    qstrncmp*;
    qstrncpy*;
    qstrnicmp*;
    qSuppressObsoleteWarnings*;
    qSysInfo*;
    qSystemWarning*;
    qt_bitblt_bsm*;
    qt_check_pointer*;
    qt_dispatchAccelEvent*;

    qt_qheader_label_return_null_strings*;
    qt_resolve_symlinks*;
    qt_setAccelAutoShortcuts*;
    qt_set_postselect_handler*;
    qt_set_preselect_handler*;
    qt_setSettingsBasePath*;
    qt_setSettingsTryLocal*;
    qt_setSettingsTryUser*;
    qt_set_postselect_handler*;
    qt_set_preselect_handler*;
    qt_set_win_event_filter*;
    qt_set_win_event_filter_ex*;
    qt_set_x11_event_filter*;

    qt_use_native_dialogs*;
    qt_use_xrender*;
    qt_wait_for_window_manager*;
    qt_window_role*;
    qt_win_ignoreNextMouseReleaseEvent*;
    qt_win_use_simple_timers*;
    qt_window_role*;
    qt_wm_delete_window*;
    qt_wm_protocols*;
    qt_wm_state*;

    qt_x11_enforce_cursor*;
    qt_x_time*;
    qt_x_user_time*;
    qUncompress*;
    qVersion*;
    qWarning*;
    qWinAppCmdShow*;
    qWinAppInst*;
    qWinAppPrevInst*;
    qWinProcessConfigRequests*;
    reset*;
    static_QUType_Null*;
    static_QUType_QString*;
    static_QUType_QVariant*;
    static_QUType_bool*;
    static_QUType_charstar*;
    static_QUType_double*;

    static_QUType_idisp*;
    static_QUType_iface*;
    static_QUType_int*;
    static_QUType_Null*;
    static_QUType_ptr*;
    static_QUType_QString*;
    static_QUType_QVariant*;
    static_QUType_varptr*;
    TID_QUType_bool*;
    TID_QUType_charstar*;
    TID_QUType_double*;
    TID_QUType_enum*;
    TID_QUType_idisp*;
    TID_QUType_iface*;
    TID_QUType_int*;
    TID_QUType_Null*;
    TID_QUType_ptr*;
    TID_QUType_varptr*;
    warning*;
    ws*;
    operator*;

    vtable?for?QBitArray;
    typeinfo?for?QBitArray;
    non-virtual?thunk?to?QBitArray::*;
    QBitVal::*;
    QBitVal?virtual?table;
    QBitVal?type_info?node;
    QBitVal?type_info?function;
    vtable?for?QBitVal;
    typeinfo?for?QBitVal;
    non-virtual?thunk?to?QBitVal::*;
    QBitmap::*;
    QBitmap?virtual?table;
    QBitmap?type_info?node;

    vtable?for?QBitmap;
    typeinfo?for?QBitmap;
    non-virtual?thunk?to?QBitmap::*;
    QBitVal::*;
    QBitVal?virtual?table;
    QBitVal?type_info?node;
    QBitVal?type_info?function;
    vtable?for?QBitVal;
    typeinfo?for?QBitVal;
    non-virtual?thunk?to?QBitVal::*;
    QBoxLayout::*;
    QBoxLayout?virtual?table;
    QBoxLayout?type_info?node;

    vtable?for?QCDEStyle;
    typeinfo?for?QCDEStyle;
    non-virtual?thunk?to?QCDEStyle::*;
    QCString::*;
    QCString?virtual?table;
    QCString?type_info?node;
    QCString?type_info?function;
    vtable?for?QCString;
    typeinfo?for?QCString;
    non-virtual?thunk?to?QCString::*;
    QChar::*;
    QChar?virtual?table;
    QChar?type_info?node;

    vtable?for?QColorGroup;
    typeinfo?for?QColorGroup;
    non-virtual?thunk?to?QColorGroup::*;
    QComLibrary::*;
    QComLibrary?virtual?table;
    QComLibrary?type_info?node;
    QComLibrary?type_info?function;
    vtable?for?QComLibrary;
    typeinfo?for?QComLibrary;
    non-virtual?thunk?to?QComLibrary::*;
    QComboBox::*;
    QComboBox?virtual?table;
    QComboBox?type_info?node;

    vtable?for?QComboBox;
    typeinfo?for?QComboBox;
    non-virtual?thunk?to?QComboBox::*;
    QComLibrary::*;
    QComLibrary?virtual?table;
    QComLibrary?type_info?node;
    QComLibrary?type_info?function;
    vtable?for?QComLibrary;
    typeinfo?for?QComLibrary;
    non-virtual?thunk?to?QComLibrary::*;
    QCommonStyle::*;
    QCommonStyle?virtual?table;
    QCommonStyle?type_info?node;

    vtable?for?QContextMenuEvent;
    typeinfo?for?QContextMenuEvent;
    non-virtual?thunk?to?QContextMenuEvent::*;
    QCString::*;
    QCString?virtual?table;
    QCString?type_info?node;
    QCString?type_info?function;
    vtable?for?QCString;
    typeinfo?for?QCString;
    non-virtual?thunk?to?QCString::*;
    QCursor::*;
    QCursor?virtual?table;
    QCursor?type_info?node;

    vtable?for?QCustomMenuItem;
    typeinfo?for?QCustomMenuItem;
    non-virtual?thunk?to?QCustomMenuItem::*;
    QDB2Driver::*;
    QDB2Driver?virtual?table;
    QDB2Driver?type_info?node;
    QDB2Driver?type_info?function;
    vtable?for?QDB2Driver;
    typeinfo?for?QDB2Driver;
    non-virtual?thunk?to?QDB2Driver::*;
    QDataBrowser::*;
    QDataBrowser?virtual?table;
    QDataBrowser?type_info?node;

    vtable?for?QDateTimeEditBase;
    typeinfo?for?QDateTimeEditBase;
    non-virtual?thunk?to?QDateTimeEditBase::*;
    QDB2Driver::*;
    QDB2Driver?virtual?table;
    QDB2Driver?type_info?node;
    QDB2Driver?type_info?function;
    vtable?for?QDB2Driver;
    typeinfo?for?QDB2Driver;
    non-virtual?thunk?to?QDB2Driver::*;
    QDesktopWidget::*;
    QDesktopWidget?virtual?table;
    QDesktopWidget?type_info?node;

    vtable?for?QGArray;
    typeinfo?for?QGArray;
    non-virtual?thunk?to?QGArray::*;
    QGb18030Codec::*;
    QGb18030Codec?virtual?table;
    QGb18030Codec?type_info?node;
    QGb18030Codec?type_info?function;
    vtable?for?QGb18030Codec;
    typeinfo?for?QGb18030Codec;
    non-virtual?thunk?to?QGb18030Codec::*;
    QGb2312Codec::*;
    QGb2312Codec?virtual?table;
    QGb2312Codec?type_info?node;
    QGb2312Codec?type_info?function;
    vtable?for?QGb2312Codec;
    typeinfo?for?QGb2312Codec;
    non-virtual?thunk?to?QGb2312Codec::*;
    QGbkCodec::*;
    QGbkCodec?virtual?table;
    QGbkCodec?type_info?node;
    QGbkCodec?type_info?function;
    vtable?for?QGbkCodec;
    typeinfo?for?QGbkCodec;
    non-virtual?thunk?to?QGbkCodec::*;
    QGCache::*;
    QGCache?virtual?table;
    QGCache?type_info?node;

    vtable?for?QGDictIterator;
    typeinfo?for?QGDictIterator;
    non-virtual?thunk?to?QGDictIterator::*;
    QGfx::*;
    QGfx?virtual?table;
    QGfx?type_info?node;
    QGfx?type_info?function;
    vtable?for?QGfx;
    typeinfo?for?QGfx;
    non-virtual?thunk?to?QGfx::*;
    QGfxDriverFactory::*;
    QGfxDriverFactory?virtual?table;
    QGfxDriverFactory?type_info?node;
    QGfxDriverFactory?type_info?function;
    vtable?for?QGfxDriverFactory;
    typeinfo?for?QGfxDriverFactory;
    non-virtual?thunk?to?QGfxDriverFactory::*;
    QGfxDriverInterface::*;
    QGfxDriverInterface?virtual?table;
    QGfxDriverInterface?type_info?node;
    QGfxDriverInterface?type_info?function;
    vtable?for?QGfxDriverInterface;
    typeinfo?for?QGfxDriverInterface;
    non-virtual?thunk?to?QGfxDriverInterface::*;
    QGfxDriverPlugin::*;
    QGfxDriverPlugin?virtual?table;
    QGfxDriverPlugin?type_info?node;
    QGfxDriverPlugin?type_info?function;
    vtable?for?QGfxDriverPlugin;
    typeinfo?for?QGfxDriverPlugin;
    non-virtual?thunk?to?QGfxDriverPlugin::*;
    QGLayoutIterator::*;
    QGLayoutIterator?virtual?table;
    QGLayoutIterator?type_info?node;

    vtable?for?QGPluginManager;
    typeinfo?for?QGPluginManager;
    non-virtual?thunk?to?QGPluginManager::*;
    QGVector::*;
    QGVector?virtual?table;
    QGVector?type_info?node;
    QGVector?type_info?function;
    vtable?for?QGVector;
    typeinfo?for?QGVector;
    non-virtual?thunk?to?QGVector::*;
    QGb18030Codec::*;
    QGb18030Codec?virtual?table;
    QGb18030Codec?type_info?node;
    QGb18030Codec?type_info?function;
    vtable?for?QGb18030Codec;
    typeinfo?for?QGb18030Codec;
    non-virtual?thunk?to?QGb18030Codec::*;
    QGb2312Codec::*;
    QGb2312Codec?virtual?table;
    QGb2312Codec?type_info?node;
    QGb2312Codec?type_info?function;
    vtable?for?QGb2312Codec;
    typeinfo?for?QGb2312Codec;
    non-virtual?thunk?to?QGb2312Codec::*;
    QGbkCodec::*;
    QGbkCodec?virtual?table;
    QGbkCodec?type_info?node;
    QGbkCodec?type_info?function;
    vtable?for?QGbkCodec;
    typeinfo?for?QGbkCodec;
    non-virtual?thunk?to?QGbkCodec::*;
    QGfx::*;
    QGfx?virtual?table;
    QGfx?type_info?node;
    QGfx?type_info?function;
    vtable?for?QGfx;
    typeinfo?for?QGfx;
    non-virtual?thunk?to?QGfx::*;
    QGfxDriverFactory::*;
    QGfxDriverFactory?virtual?table;
    QGfxDriverFactory?type_info?node;
    QGfxDriverFactory?type_info?function;
    vtable?for?QGfxDriverFactory;
    typeinfo?for?QGfxDriverFactory;
    non-virtual?thunk?to?QGfxDriverFactory::*;
    QGfxDriverInterface::*;
    QGfxDriverInterface?virtual?table;
    QGfxDriverInterface?type_info?node;
    QGfxDriverInterface?type_info?function;
    vtable?for?QGfxDriverInterface;
    typeinfo?for?QGfxDriverInterface;
    non-virtual?thunk?to?QGfxDriverInterface::*;
    QGfxDriverPlugin::*;
    QGfxDriverPlugin?virtual?table;
    QGfxDriverPlugin?type_info?node;
    QGfxDriverPlugin?type_info?function;
    vtable?for?QGfxDriverPlugin;
    typeinfo?for?QGfxDriverPlugin;
    non-virtual?thunk?to?QGfxDriverPlugin::*;
    QGrid::*;
    QGrid?virtual?table;
    QGrid?type_info?node;

    vtable?for?QGuardedPtrPrivate;
    typeinfo?for?QGuardedPtrPrivate;
    non-virtual?thunk?to?QGuardedPtrPrivate::*;
    QGVector::*;
    QGVector?virtual?table;
    QGVector?type_info?node;
    QGVector?type_info?function;
    vtable?for?QGVector;
    typeinfo?for?QGVector;
    non-virtual?thunk?to?QGVector::*;
    QHBox::*;
    QHBox?virtual?table;
    QHBox?type_info?node;

    vtable?for?QHButtonGroup;
    typeinfo?for?QHButtonGroup;
    non-virtual?thunk?to?QHButtonGroup::*;
    QHGroupBox::*;
    QHGroupBox?virtual?table;
    QHGroupBox?type_info?node;
    QHGroupBox?type_info?function;
    vtable?for?QHGroupBox;
    typeinfo?for?QHGroupBox;
    non-virtual?thunk?to?QHGroupBox::*;
    QHeader::*;
    QHeader?virtual?table;
    QHeader?type_info?node;

    vtable?for?QHebrewCodec;
    typeinfo?for?QHebrewCodec;
    non-virtual?thunk?to?QHebrewCodec::*;
    QHGroupBox::*;
    QHGroupBox?virtual?table;
    QHGroupBox?type_info?node;
    QHGroupBox?type_info?function;
    vtable?for?QHGroupBox;
    typeinfo?for?QHGroupBox;
    non-virtual?thunk?to?QHGroupBox::*;
    QHideEvent::*;
    QHideEvent?virtual?table;
    QHideEvent?type_info?node;

    vtable?for?QHideEvent;
    typeinfo?for?QHideEvent;
    non-virtual?thunk?to?QHideEvent::*;
    QIMComposeEvent::*;
    QIMComposeEvent?virtual?table;
    QIMComposeEvent?type_info?node;
    QIMComposeEvent?type_info?function;
    vtable?for?QIMComposeEvent;
    typeinfo?for?QIMComposeEvent;
    non-virtual?thunk?to?QIMComposeEvent::*;
    QIMEvent::*;
    QIMEvent?virtual?table;
    QIMEvent?type_info?node;
    QIMEvent?type_info?function;
    vtable?for?QIMEvent;
    typeinfo?for?QIMEvent;
    non-virtual?thunk?to?QIMEvent::*;
    QIODevice::*;
    QIODevice?virtual?table;
    QIODevice?type_info?node;
    QIODevice?type_info?function;
    vtable?for?QIODevice;
    typeinfo?for?QIODevice;
    non-virtual?thunk?to?QIODevice::*;
    QIODeviceSource::*;
    QIODeviceSource?virtual?table;
    QIODeviceSource?type_info?node;
    QIODeviceSource?type_info?function;
    vtable?for?QIODeviceSource;
    typeinfo?for?QIODeviceSource;
    non-virtual?thunk?to?QIODeviceSource::*;
    QIconDragEvent::*;
    QIconDragEvent?virtual?table;
    QIconDragEvent?type_info?node;

    vtable?for?QImageTextKeyLang;
    typeinfo?for?QImageTextKeyLang;
    non-virtual?thunk?to?QImageTextKeyLang::*;
    QIMComposeEvent::*;
    QIMComposeEvent?virtual?table;
    QIMComposeEvent?type_info?node;
    QIMComposeEvent?type_info?function;
    vtable?for?QIMComposeEvent;
    typeinfo?for?QIMComposeEvent;
    non-virtual?thunk?to?QIMComposeEvent::*;
    QIMEvent::*;
    QIMEvent?virtual?table;
    QIMEvent?type_info?node;
    QIMEvent?type_info?function;
    vtable?for?QIMEvent;
    typeinfo?for?QIMEvent;
    non-virtual?thunk?to?QIMEvent::*;
    QInputDialog::*;
    QInputDialog?virtual?table;
    QInputDialog?type_info?node;

    vtable?for?QInputDialog;
    typeinfo?for?QInputDialog;
    non-virtual?thunk?to?QInputDialog::*;
    QIntValidator::*;
    QIntValidator?virtual?table;
    QIntValidator?type_info?node;
    QIntValidator?type_info?function;
    vtable?for?QIntValidator;
    typeinfo?for?QIntValidator;
    non-virtual?thunk?to?QIntValidator::*;
    QInternal::*;
    QInternal?virtual?table;
    QInternal?type_info?node;

    vtable?for?QInternal;
    typeinfo?for?QInternal;
    non-virtual?thunk?to?QInternal::*;
    QIntValidator::*;
    QIntValidator?virtual?table;
    QIntValidator?type_info?node;
    QIntValidator?type_info?function;
    vtable?for?QIntValidator;
    typeinfo?for?QIntValidator;
    non-virtual?thunk?to?QIntValidator::*;
    QIODevice::*;
    QIODevice?virtual?table;
    QIODevice?type_info?node;
    QIODevice?type_info?function;
    vtable?for?QIODevice;
    typeinfo?for?QIODevice;
    non-virtual?thunk?to?QIODevice::*;
    QIODeviceSource::*;
    QIODeviceSource?virtual?table;
    QIODeviceSource?type_info?node;
    QIODeviceSource?type_info?function;
    vtable?for?QIODeviceSource;
    typeinfo?for?QIODeviceSource;
    non-virtual?thunk?to?QIODeviceSource::*;
    QJisCodec::*;
    QJisCodec?virtual?table;
    QJisCodec?type_info?node;

    vtable?for?QKeySequence;
    typeinfo?for?QKeySequence;
    non-virtual?thunk?to?QKeySequence::*;
    QLCDNumber::*;
    QLCDNumber?virtual?table;
    QLCDNumber?type_info?node;
    QLCDNumber?type_info?function;
    vtable?for?QLCDNumber;
    typeinfo?for?QLCDNumber;
    non-virtual?thunk?to?QLCDNumber::*;
    QLNode::*;
    QLNode?virtual?table;
    QLNode?type_info?node;
    QLNode?type_info?function;
    vtable?for?QLNode;
    typeinfo?for?QLNode;
    non-virtual?thunk?to?QLNode::*;
    QLabel::*;
    QLabel?virtual?table;
    QLabel?type_info?node;

    vtable?for?QLayoutIterator;
    typeinfo?for?QLayoutIterator;
    non-virtual?thunk?to?QLayoutIterator::*;
    QLCDNumber::*;
    QLCDNumber?virtual?table;
    QLCDNumber?type_info?node;
    QLCDNumber?type_info?function;
    vtable?for?QLCDNumber;
    typeinfo?for?QLCDNumber;
    non-virtual?thunk?to?QLCDNumber::*;
    QLibrary::*;
    QLibrary?virtual?table;
    QLibrary?type_info?node;

    vtable?for?QListViewItemIterator;
    typeinfo?for?QListViewItemIterator;
    non-virtual?thunk?to?QListViewItemIterator::*;
    QLNode::*;
    QLNode?virtual?table;
    QLNode?type_info?node;
    QLNode?type_info?function;
    vtable?for?QLNode;
    typeinfo?for?QLNode;
    non-virtual?thunk?to?QLNode::*;
    QLocale::*;
    QLocale?virtual?table;
    QLocale?type_info?node;

    vtable?for?QLocale;
    typeinfo?for?QLocale;
    non-virtual?thunk?to?QLocale::*;
    QLocalFs::*;
    QLocalFs?virtual?table;
    QLocalFs?type_info?node;
    QLocalFs?type_info?function;
    vtable?for?QLocalFs;
    typeinfo?for?QLocalFs;
    non-virtual?thunk?to?QLocalFs::*;
    QMainWindow::*;
    QMainWindow?virtual?table;
    QMainWindow?type_info?node;

    vtable?for?QMultiLineEdit;
    typeinfo?for?QMultiLineEdit;
    non-virtual?thunk?to?QMultiLineEdit::*;
    QMYSQLDriver::*;
    QMYSQLDriver?virtual?table;
    QMYSQLDriver?type_info?node;
    QMYSQLDriver?type_info?function;
    vtable?for?QMYSQLDriver;
    typeinfo?for?QMYSQLDriver;
    non-virtual?thunk?to?QMYSQLDriver::*;
    QNetworkOperation::*;
    QNetworkOperation?virtual?table;
    QNetworkOperation?type_info?node;

    vtable?for?QNumberSection;
    typeinfo?for?QNumberSection;
    non-virtual?thunk?to?QNumberSection::*;
    QOCIDriver::*;
    QOCIDriver?virtual?table;
    QOCIDriver?type_info?node;
    QOCIDriver?type_info?function;
    vtable?for?QOCIDriver;
    typeinfo?for?QOCIDriver;
    non-virtual?thunk?to?QOCIDriver::*;
    QODBCDriver::*;
    QODBCDriver?virtual?table;
    QODBCDriver?type_info?node;
    QODBCDriver?type_info?function;
    vtable?for?QODBCDriver;
    typeinfo?for?QODBCDriver;
    non-virtual?thunk?to?QODBCDriver::*;
    QObject::*;
    QObject?virtual?table;
    QObject?type_info?node;

    vtable?for?QObjectUserData;
    typeinfo?for?QObjectUserData;
    non-virtual?thunk?to?QObjectUserData::*;
    QOCIDriver::*;
    QOCIDriver?virtual?table;
    QOCIDriver?type_info?node;
    QOCIDriver?type_info?function;
    vtable?for?QOCIDriver;
    typeinfo?for?QOCIDriver;
    non-virtual?thunk?to?QOCIDriver::*;
    QODBCDriver::*;
    QODBCDriver?virtual?table;
    QODBCDriver?type_info?node;
    QODBCDriver?type_info?function;
    vtable?for?QODBCDriver;
    typeinfo?for?QODBCDriver;
    non-virtual?thunk?to?QODBCDriver::*;
    QPSPrinter::*;
    QPSPrinter?virtual?table;
    QPSPrinter?type_info?node;
    QPSPrinter?type_info?function;
    vtable?for?QPSPrinter;
    typeinfo?for?QPSPrinter;
    non-virtual?thunk?to?QPSPrinter::*;
    QPSQLDriver::*;
    QPSQLDriver?virtual?table;
    QPSQLDriver?type_info?node;
    QPSQLDriver?type_info?function;
    vtable?for?QPSQLDriver;
    typeinfo?for?QPSQLDriver;
    non-virtual?thunk?to?QPSQLDriver::*;
    QPaintDevice::*;
    QPaintDevice?virtual?table;
    QPaintDevice?type_info?node;

    vtable?for?QPaintDeviceMetrics;
    typeinfo?for?QPaintDeviceMetrics;
    non-virtual?thunk?to?QPaintDeviceMetrics::*;
    QPaintEvent::*;
    QPaintEvent?virtual?table;
    QPaintEvent?type_info?node;
    QPaintEvent?type_info?function;
    vtable?for?QPaintEvent;
    typeinfo?for?QPaintEvent;
    non-virtual?thunk?to?QPaintEvent::*;
    QPainter::*;
    QPainter?virtual?table;
    QPainter?type_info?node;

    vtable?for?QPainter;
    typeinfo?for?QPainter;
    non-virtual?thunk?to?QPainter::*;
    QPaintEvent::*;
    QPaintEvent?virtual?table;
    QPaintEvent?type_info?node;
    QPaintEvent?type_info?function;
    vtable?for?QPaintEvent;
    typeinfo?for?QPaintEvent;
    non-virtual?thunk?to?QPaintEvent::*;
    QPalette::*;
    QPalette?virtual?table;
    QPalette?type_info?node;

    vtable?for?QPlatinumStyle;
    typeinfo?for?QPlatinumStyle;
    non-virtual?thunk?to?QPlatinumStyle::*;
    QPNGImagePacker::*;
    QPNGImagePacker?virtual?table;
    QPNGImagePacker?type_info?node;
    QPNGImagePacker?type_info?function;
    vtable?for?QPNGImagePacker;
    typeinfo?for?QPNGImagePacker;
    non-virtual?thunk?to?QPNGImagePacker::*;
    QPNGImageWriter::*;
    QPNGImageWriter?virtual?table;
    QPNGImageWriter?type_info?node;
    QPNGImageWriter?type_info?function;
    vtable?for?QPNGImageWriter;
    typeinfo?for?QPNGImageWriter;
    non-virtual?thunk?to?QPNGImageWriter::*;
    QPocketPCStyle::*;
    QPocketPCStyle?virtual?table;
    QPocketPCStyle?type_info?node;

    vtable?for?QProgressDialog;
    typeinfo?for?QProgressDialog;
    non-virtual?thunk?to?QProgressDialog::*;
    QPSPrinter::*;
    QPSPrinter?virtual?table;
    QPSPrinter?type_info?node;
    QPSPrinter?type_info?function;
    vtable?for?QPSPrinter;
    typeinfo?for?QPSPrinter;
    non-virtual?thunk?to?QPSPrinter::*;
    QPSQLDriver::*;
    QPSQLDriver?virtual?table;
    QPSQLDriver?type_info?node;
    QPSQLDriver?type_info?function;
    vtable?for?QPSQLDriver;
    typeinfo?for?QPSQLDriver;
    non-virtual?thunk?to?QPSQLDriver::*;
    QPtrCollection::*;
    QPtrCollection?virtual?table;
    QPtrCollection?type_info?node;

    vtable?for?QResizeEvent;
    typeinfo?for?QResizeEvent;
    non-virtual?thunk?to?QResizeEvent::*;
    QSGIStyle::*;
    QSGIStyle?virtual?table;
    QSGIStyle?type_info?node;
    QSGIStyle?type_info?function;
    vtable?for?QSGIStyle;
    typeinfo?for?QSGIStyle;
    non-virtual?thunk?to?QSGIStyle::*;
    QScrollBar::*;
    QScrollBar?virtual?table;
    QScrollBar?type_info?node;

    vtable?for?QSettings;
    typeinfo?for?QSettings;
    non-virtual?thunk?to?QSettings::*;
    QSGIStyle::*;
    QSGIStyle?virtual?table;
    QSGIStyle?type_info?node;
    QSGIStyle?type_info?function;
    vtable?for?QSGIStyle;
    typeinfo?for?QSGIStyle;
    non-virtual?thunk?to?QSGIStyle::*;
    QShared::*;
    QShared?virtual?table;
    QShared?type_info?node;

    vtable?for?QStrIList;
    typeinfo?for?QStrIList;
    non-virtual?thunk?to?QStrIList::*;
    QStrIVec::*;
    QStrIVec?virtual?table;
    QStrIVec?type_info?node;
    QStrIVec?type_info?function;
    vtable?for?QStrIVec;
    typeinfo?for?QStrIVec;
    non-virtual?thunk?to?QStrIVec::*;
    QStrList::*;
    QStrList?virtual?table;
    QStrList?type_info?node;
    QStrList?type_info?function;
    vtable?for?QStrList;
    typeinfo?for?QStrList;
    non-virtual?thunk?to?QStrList::*;
    QStrVec::*;
    QStrVec?virtual?table;
    QStrVec?type_info?node;
    QStrVec?type_info?function;
    vtable?for?QStrVec;
    typeinfo?for?QStrVec;
    non-virtual?thunk?to?QStrVec::*;
    QString::*;
    QString?virtual?table;
    QString?type_info?node;

    vtable?for?QStringList;
    typeinfo?for?QStringList;
    non-virtual?thunk?to?QStringList::*;
    QStrIVec::*;
    QStrIVec?virtual?table;
    QStrIVec?type_info?node;
    QStrIVec?type_info?function;
    vtable?for?QStrIVec;
    typeinfo?for?QStrIVec;
    non-virtual?thunk?to?QStrIVec::*;
    QStrList::*;
    QStrList?virtual?table;
    QStrList?type_info?node;
    QStrList?type_info?function;
    vtable?for?QStrList;
    typeinfo?for?QStrList;
    non-virtual?thunk?to?QStrList::*;
    QStrVec::*;
    QStrVec?virtual?table;
    QStrVec?type_info?node;
    QStrVec?type_info?function;
    vtable?for?QStrVec;
    typeinfo?for?QStrVec;
    non-virtual?thunk?to?QStrVec::*;
    QStyle::*;
    QStyle?virtual?table;
    QStyle?type_info?node;
    QStyle?type_info?function;
    vtable?for?QStyle;
    typeinfo?for?QStyle;
    non-virtual?thunk?to?QStyle::*;
    QStyleFactory::*;
    QStyleFactory?virtual?table;
    QStyleFactory?type_info?node;
    QStyleFactory?type_info?function;
    vtable?for?QStyleFactory;
    typeinfo?for?QStyleFactory;
    non-virtual?thunk?to?QStyleFactory::*;
    QStyleFactoryInterface::*;
    QStyleFactoryInterface?virtual?table;
    QStyleFactoryInterface?type_info?node;
    QStyleFactoryInterface?type_info?function;

    vtable?for?QSyntaxHighlighter;
    typeinfo?for?QSyntaxHighlighter;
    non-virtual?thunk?to?QSyntaxHighlighter::*;
    Qt::*;
    Qt?virtual?table;
    Qt?type_info?node;
    Qt?type_info?function;
    vtable?for?Qt;
    typeinfo?for?Qt;
    non-virtual?thunk?to?Qt::*;
    QTLWExtra::*;
    QTLWExtra?virtual?table;
    QTLWExtra?type_info?node;
    QTLWExtra?type_info?function;
    vtable?for?QTLWExtra;
    typeinfo?for?QTLWExtra;
    non-virtual?thunk?to?QTLWExtra::*;
    QTSManip::*;
    QTSManip?virtual?table;
    QTSManip?type_info?node;
    QTSManip?type_info?function;
    vtable?for?QTSManip;
    typeinfo?for?QTSManip;
    non-virtual?thunk?to?QTSManip::*;
    QTab::*;
    QTab?virtual?table;
    QTab?type_info?node;

    vtable?for?QTabDialog;
    typeinfo?for?QTabDialog;
    non-virtual?thunk?to?QTabDialog::*;
    QTabWidget::*;
    QTabWidget?virtual?table;
    QTabWidget?type_info?node;
    QTabWidget?type_info?function;
    vtable?for?QTabWidget;
    typeinfo?for?QTabWidget;
    non-virtual?thunk?to?QTabWidget::*;
    QTabletEvent::*;
    QTabletEvent?virtual?table;
    QTabletEvent?type_info?node;

    vtable?for?QTabletEvent;
    typeinfo?for?QTabletEvent;
    non-virtual?thunk?to?QTabletEvent::*;
    QTabWidget::*;
    QTabWidget?virtual?table;
    QTabWidget?type_info?node;
    QTabWidget?type_info?function;
    vtable?for?QTabWidget;
    typeinfo?for?QTabWidget;
    non-virtual?thunk?to?QTabWidget::*;
    QTDSDriver::*;
    QTDSDriver?virtual?table;
    QTDSDriver?type_info?node;
    QTDSDriver?type_info?function;
    vtable?for?QTDSDriver;
    typeinfo?for?QTDSDriver;
    non-virtual?thunk?to?QTDSDriver::*;
    QTextBrowser::*;
    QTextBrowser?virtual?table;
    QTextBrowser?type_info?node;

    vtable?for?QTextHorizontalLine;
    typeinfo?for?QTextHorizontalLine;
    non-virtual?thunk?to?QTextHorizontalLine::*;
    QTextIStream::*;
    QTextIStream?virtual?table;
    QTextIStream?type_info?node;
    QTextIStream?type_info?function;
    vtable?for?QTextIStream;
    typeinfo?for?QTextIStream;
    non-virtual?thunk?to?QTextIStream::*;
    QTextImage::*;
    QTextImage?virtual?table;
    QTextImage?type_info?node;

    vtable?for?QTextInsertCommand;
    typeinfo?for?QTextInsertCommand;
    non-virtual?thunk?to?QTextInsertCommand::*;
    QTextIStream::*;
    QTextIStream?virtual?table;
    QTextIStream?type_info?node;
    QTextIStream?type_info?function;
    vtable?for?QTextIStream;
    typeinfo?for?QTextIStream;
    non-virtual?thunk?to?QTextIStream::*;
    QTextItem::*;
    QTextItem?virtual?table;
    QTextItem?type_info?node;

    vtable?for?QTitleBar;
    typeinfo?for?QTitleBar;
    non-virtual?thunk?to?QTitleBar::*;
    QTLWExtra::*;
    QTLWExtra?virtual?table;
    QTLWExtra?type_info?node;
    QTLWExtra?type_info?function;
    vtable?for?QTLWExtra;
    typeinfo?for?QTLWExtra;
    non-virtual?thunk?to?QTLWExtra::*;
    QToolBar::*;
    QToolBar?virtual?table;
    QToolBar?type_info?node;

    vtable?for?QTsciiCodec;
    typeinfo?for?QTsciiCodec;
    non-virtual?thunk?to?QTsciiCodec::*;
    QTSManip::*;
    QTSManip?virtual?table;
    QTSManip?type_info?node;
    QTSManip?type_info?function;
    vtable?for?QTSManip;
    typeinfo?for?QTSManip;
    non-virtual?thunk?to?QTSManip::*;
    QtULong::*;
    QtULong?virtual?table;
    QtULong?type_info?node;
    QtULong?type_info?function;
    vtable?for?QtULong;
    typeinfo?for?QtULong;
    non-virtual?thunk?to?QtULong::*;
    QUBuffer::*;
    QUBuffer?virtual?table;
    QUBuffer?type_info?node;

    vtable?for?QUMethod;
    typeinfo?for?QUMethod;
    non-virtual?thunk?to?QUMethod::*;
    QUnknownInterface::*;
    QUnknownInterface?virtual?table;
    QUnknownInterface?type_info?node;
    QUnknownInterface?type_info?function;
    vtable?for?QUnknownInterface;
    typeinfo?for?QUnknownInterface;
    non-virtual?thunk?to?QUnknownInterface::*;
    QUObject::*;
    QUObject?virtual?table;
    QUObject?type_info?node;

    vtable?for?QUProperty;
    typeinfo?for?QUProperty;
    non-virtual?thunk?to?QUProperty::*;
    QUriDrag::*;
    QUriDrag?virtual?table;
    QUriDrag?type_info?node;
    QUriDrag?type_info?function;
    vtable?for?QUriDrag;
    typeinfo?for?QUriDrag;
    non-virtual?thunk?to?QUriDrag::*;
    QUrl::*;
    QUrl?virtual?table;
    QUrl?type_info?node;
    QUrl?type_info?function;
    vtable?for?QUrl;
    typeinfo?for?QUrl;
    non-virtual?thunk?to?QUrl::*;
    QUrlInfo::*;
    QUrlInfo?virtual?table;
    QUrlInfo?type_info?node;
    QUrlInfo?type_info?function;
    vtable?for?QUrlInfo;
    typeinfo?for?QUrlInfo;
    non-virtual?thunk?to?QUrlInfo::*;
    QUrlOperator::*;
    QUrlOperator?virtual?table;
    QUrlOperator?type_info?node;
    QUrlOperator?type_info?function;
    vtable?for?QUrlOperator;
    typeinfo?for?QUrlOperator;
    non-virtual?thunk?to?QUrlOperator::*;
    QUtf16Codec::*;
    QUtf16Codec?virtual?table;
    QUtf16Codec?type_info?node;
    QUtf16Codec?type_info?function;
    vtable?for?QUtf16Codec;
    typeinfo?for?QUtf16Codec;
    non-virtual?thunk?to?QUtf16Codec::*;
    QUtf8Codec::*;
    QUtf8Codec?virtual?table;
    QUtf8Codec?type_info?node;
    QUtf8Codec?type_info?function;
    vtable?for?QUtf8Codec;
    typeinfo?for?QUtf8Codec;
    non-virtual?thunk?to?QUtf8Codec::*;
    QUType::*;
    QUType?virtual?table;
    QUType?type_info?node;

    vtable?for?QUType;
    typeinfo?for?QUType;
    non-virtual?thunk?to?QUType::*;
    QUType_Null::*;
    QUType_Null?virtual?table;
    QUType_Null?type_info?node;
    QUType_Null?type_info?function;
    vtable?for?QUType_Null;
    typeinfo?for?QUType_Null;
    non-virtual?thunk?to?QUType_Null::*;
    QUType_QString::*;
    QUType_QString?virtual?table;
    QUType_QString?type_info?node;
    QUType_QString?type_info?function;
    vtable?for?QUType_QString;
    typeinfo?for?QUType_QString;
    non-virtual?thunk?to?QUType_QString::*;
    QUType_QVariant::*;
    QUType_QVariant?virtual?table;
    QUType_QVariant?type_info?node;
    QUType_QVariant?type_info?function;
    vtable?for?QUType_QVariant;
    typeinfo?for?QUType_QVariant;
    non-virtual?thunk?to?QUType_QVariant::*;
    QUType_bool::*;
    QUType_bool?virtual?table;
    QUType_bool?type_info?node;

    vtable?for?QUType_int;
    typeinfo?for?QUType_int;
    non-virtual?thunk?to?QUType_int::*;
    QUType_Null::*;
    QUType_Null?virtual?table;
    QUType_Null?type_info?node;
    QUType_Null?type_info?function;
    vtable?for?QUType_Null;
    typeinfo?for?QUType_Null;
    non-virtual?thunk?to?QUType_Null::*;
    QUType_ptr::*;
    QUType_ptr?virtual?table;
    QUType_ptr?type_info?node;

    vtable?for?QUType_ptr;
    typeinfo?for?QUType_ptr;
    non-virtual?thunk?to?QUType_ptr::*;
    QUType_QString::*;
    QUType_QString?virtual?table;
    QUType_QString?type_info?node;
    QUType_QString?type_info?function;
    vtable?for?QUType_QString;
    typeinfo?for?QUType_QString;
    non-virtual?thunk?to?QUType_QString::*;
    QUType_QVariant::*;
    QUType_QVariant?virtual?table;
    QUType_QVariant?type_info?node;
    QUType_QVariant?type_info?function;
    vtable?for?QUType_QVariant;
    typeinfo?for?QUType_QVariant;
    non-virtual?thunk?to?QUType_QVariant::*;
    QUType_varptr::*;
    QUType_varptr?virtual?table;
    QUType_varptr?type_info?node;

    vtable?for?QUType_varptr;
    typeinfo?for?QUType_varptr;
    non-virtual?thunk?to?QUType_varptr::*;
    QUnknownInterface::*;
    QUnknownInterface?virtual?table;
    QUnknownInterface?type_info?node;
    QUnknownInterface?type_info?function;
    vtable?for?QUnknownInterface;
    typeinfo?for?QUnknownInterface;
    non-virtual?thunk?to?QUnknownInterface::*;
    QUriDrag::*;
    QUriDrag?virtual?table;
    QUriDrag?type_info?node;
    QUriDrag?type_info?function;
    vtable?for?QUriDrag;
    typeinfo?for?QUriDrag;
    non-virtual?thunk?to?QUriDrag::*;
    QUrl::*;
    QUrl?virtual?table;
    QUrl?type_info?node;
    QUrl?type_info?function;
    vtable?for?QUrl;
    typeinfo?for?QUrl;
    non-virtual?thunk?to?QUrl::*;
    QUrlInfo::*;
    QUrlInfo?virtual?table;
    QUrlInfo?type_info?node;
    QUrlInfo?type_info?function;
    vtable?for?QUrlInfo;
    typeinfo?for?QUrlInfo;
    non-virtual?thunk?to?QUrlInfo::*;
    QUrlOperator::*;
    QUrlOperator?virtual?table;
    QUrlOperator?type_info?node;
    QUrlOperator?type_info?function;
    vtable?for?QUrlOperator;
    typeinfo?for?QUrlOperator;
    non-virtual?thunk?to?QUrlOperator::*;
    QUtf16Codec::*;
    QUtf16Codec?virtual?table;
    QUtf16Codec?type_info?node;
    QUtf16Codec?type_info?function;
    vtable?for?QUtf16Codec;
    typeinfo?for?QUtf16Codec;
    non-virtual?thunk?to?QUtf16Codec::*;
    QUtf8Codec::*;
    QUtf8Codec?virtual?table;
    QUtf8Codec?type_info?node;
    QUtf8Codec?type_info?function;
    vtable?for?QUtf8Codec;
    typeinfo?for?QUtf8Codec;
    non-virtual?thunk?to?QUtf8Codec::*;
    QUuid::*;
    QUuid?virtual?table;
    QUuid?type_info?node;

    vtable?for?QUuid;
    typeinfo?for?QUuid;
    non-virtual?thunk?to?QUuid::*;
    QValidator::*;
    QValidator?virtual?table;
    QValidator?type_info?node;
    QValidator?type_info?function;
    vtable?for?QValidator;
    typeinfo?for?QValidator;
    non-virtual?thunk?to?QValidator::*;
    QVariant::*;
    QVariant?virtual?table;
    QVariant?type_info?node;
    QVariant?type_info?function;
    vtable?for?QVariant;
    typeinfo?for?QVariant;
    non-virtual?thunk?to?QVariant::*;
    QVBox::*;
    QVBox?virtual?table;
    QVBox?type_info?node;

    vtable?for?QVGroupBox;
    typeinfo?for?QVGroupBox;
    non-virtual?thunk?to?QVGroupBox::*;
    QValidator::*;
    QValidator?virtual?table;
    QValidator?type_info?node;
    QValidator?type_info?function;
    vtable?for?QValidator;
    typeinfo?for?QValidator;
    non-virtual?thunk?to?QValidator::*;
    QVariant::*;
    QVariant?virtual?table;
    QVariant?type_info?node;
    QVariant?type_info?function;
    vtable?for?QVariant;
    typeinfo?for?QVariant;
    non-virtual?thunk?to?QVariant::*;
    QWExtra::*;
    QWExtra?virtual?table;
    QWExtra?type_info?node;

    vtable?for?QWExtra;
    typeinfo?for?QWExtra;
    non-virtual?thunk?to?QWExtra::*;
    QWMatrix::*;
    QWMatrix?virtual?table;
    QWMatrix?type_info?node;
    QWMatrix?type_info?function;
    vtable?for?QWMatrix;
    typeinfo?for?QWMatrix;
    non-virtual?thunk?to?QWMatrix::*;
    QWhatsThis::*;
    QWhatsThis?virtual?table;
    QWhatsThis?type_info?node;

    vtable?for?QWizard;
    typeinfo?for?QWizard;
    non-virtual?thunk?to?QWizard::*;
    QWMatrix::*;
    QWMatrix?virtual?table;
    QWMatrix?type_info?node;
    QWMatrix?type_info?function;
    vtable?for?QWMatrix;
    typeinfo?for?QWMatrix;
    non-virtual?thunk?to?QWMatrix::*;
    QtULong::*;
    QtULong?virtual?table;
    QtULong?type_info?node;
    QtULong?type_info?function;
    vtable?for?QtULong;
    typeinfo?for?QtULong;
    non-virtual?thunk?to?QtULong::*;
    UndoRedoInfo::*;
    UndoRedoInfo?virtual?table;
    UndoRedoInfo?type_info?node;





#line 3 "lex.yy.c"

#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

/* Scanner skeleton version:
 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
 */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5
#define YY_FLEX_SUBMINOR_VERSION 31
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */

#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
#include <inttypes.h>
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;
#endif /* ! C99 */

/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
#ifdef c_plusplus
#ifndef __cplusplus
#define __cplusplus
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#endif /* ! FLEXINT_H */

#ifdef __cplusplus

#include <stdlib.h>

/* Use prototypes in function declarations. */
#define YY_USE_PROTOS

/* The "const" storage-class-modifier is valid. */
#define YY_USE_CONST



#if __STDC__

#define YY_USE_PROTOS
#define YY_USE_CONST

#endif	/* __STDC__ */
#endif	/* ! __cplusplus */

#ifdef __TURBOC__
 #pragma warn -rch
 #pragma warn -use
#include <io.h>
#include <stdlib.h>
#define YY_USE_CONST
#define YY_USE_PROTOS
#endif

#ifdef YY_USE_CONST
#define yyconst const
#else
#define yyconst
#endif


#ifdef YY_USE_PROTOS
#define YY_PROTO(proto) proto
#else
#define YY_PROTO(proto) ()
#endif

/* Returned upon end-of-file. */
#define YY_NULL 0


 * but we do it the disgusting crufty way forced on us by the ()-less
 * definition of BEGIN.
 */
#define BEGIN yy_start = 1 + 2 *

/* Translate the current start state into a value that can be later handed
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 * compatibility.
 */
#define YY_START ((yy_start - 1) / 2)
#define YYSTATE YY_START

/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart( yyin )

#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#define YY_BUF_SIZE 16384
#endif

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

extern int yyleng;

extern FILE *yyin, *yyout;

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2

/* The funky do-while in the following #define is used to turn the definition
 * int a single C statement (which needs a semi-colon terminator).  This
 * avoids problems with code like:
 *
 * 	if ( condition_holds )
 *		yyless( 5 );
 *	else
 *		do_something_else();
 *
 * Prior to using the do-while the compiler would get upset at the
 * "else" because it interpreted the "if" statement as being all
 * done when it reached the ';' after the yyless() call.
 */

/* Return all but the first 'n' matched characters back to the input stream. */

#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
		*yy_cp = yy_hold_char; \
        YY_LESS_LINENO(yyless_macro_arg);\
		*yy_cp = (yy_hold_char); \
		YY_RESTORE_YY_MORE_OFFSET \
		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		} \
	while ( 0 )

#define unput(c) yyunput( c, yytext_ptr )

/* The following is because we cannot portably get our hands on size_t
 * (without autoconf's help, which isn't available because we want
 * flex-generated scanners to compile on their own).
 */

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef unsigned int yy_size_t;
#endif


#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */
    
	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
	/* When an EOF's been seen but there's still some text to process

	 * just pointing yyin at a new input file.
	 */
#define YY_BUFFER_EOF_PENDING 2

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

static YY_BUFFER_STATE yy_current_buffer = 0;
static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */

/* We provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state".
 *
 * Returns the top of the stack, or NULL.
 */
#define YY_CURRENT_BUFFER yy_current_buffer
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

/* Same as previous macro, but useful when we know that the buffer stack is not
 * NULL or when we need an lvalue. For internal use only.
 */
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]

/* yy_hold_char holds the character lost when yytext is formed. */
static char yy_hold_char;

static int yy_n_chars;		/* number of characters read into yy_ch_buf */


int yyleng;

/* Points to current character in buffer. */

 */
static int yy_did_buffer_switch_on_eof;

void yyrestart YY_PROTO(( FILE *input_file ));

void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
void yy_load_buffer_state YY_PROTO(( void ));
YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )

YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));

static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
static void yy_flex_free YY_PROTO(( void * ));

void *yyalloc (yy_size_t  );
void *yyrealloc (void *,yy_size_t  );
void yyfree (void *  );

#define yy_new_buffer yy_create_buffer

#define yy_set_interactive(is_interactive) \
	{ \
	if ( ! yy_current_buffer ) \
		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
	yy_current_buffer->yy_is_interactive = is_interactive; \
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
	}

#define yy_set_bol(at_bol) \
	{ \
	if ( ! yy_current_buffer ) \
		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
	yy_current_buffer->yy_at_bol = at_bol; \
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
	}

#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)

/* Begin user sect3 */

typedef unsigned char YY_CHAR;

FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;

typedef int yy_state_type;

extern int yylineno;

int yylineno = 1;

extern char *yytext;
#define yytext_ptr yytext

static yy_state_type yy_get_previous_state YY_PROTO(( void ));
static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
static int yy_get_next_buffer YY_PROTO(( void ));
static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));

/* Done after the current pattern has been matched and before the
 * corresponding action - sets up yytext.
 */
#define YY_DO_BEFORE_ACTION \
	yytext_ptr = yy_bp; \
	yyleng = (int) (yy_cp - yy_bp); \
	yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yy_c_buf_p = yy_cp;

#define YY_NUM_RULES 151
#define YY_END_OF_BUFFER 152
static yyconst short int yy_accept[615] =
   but its presence is necessary. */
struct yy_trans_info
	{
	flex_int32_t yy_verify;
	flex_int32_t yy_nxt;
	};
static yyconst flex_int16_t yy_accept[615] =
    {   0,
        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

       41,    8,   22,    0
    } ;

static yyconst int yy_ec[256] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    2,    3,    4,
        1,    2,    2,    1,    1,    1,    1,    1,    1,    1,

        1,    1,    1,    1,    1
    } ;

static yyconst int yy_meta[72] =
    {   0,
        1,    1,    1,    2,    3,    1,    4,    1,    1,    1,
        1,    1,    1,    5,    5,    5,    1,    1,    1,    1,

        1
    } ;

static yyconst short int yy_base[642] =
    {   0,
        0,    3,   16,    5,   87,    9,  158,  229,  300,  176,
      370,  440,  207,  510,  382,  555,  184,  399,  600,  645,

      958
    } ;

static yyconst short int yy_def[642] =
    {   0,
      615,  615,  614,    3,  614,    5,  616,  616,  614,    9,
      617,  617,  618,  618,  619,  619,  620,  620,  621,  621,

      614
    } ;

static yyconst short int yy_nxt[1262] =
    {   0,
      614,   31,   31,   32,   31,   34,   32,   45,   35,  614,
       46,   74,   33,  614,   75,   33,   36,   37,   37,   32,

      614
    } ;

static yyconst short int yy_chk[1262] =
    {   0,
        0,    1,    1,    1,    2,    2,    2,    4,    2,    0,
        4,    6,    1,    0,    6,    2,    3,    3,    3,    3,

static yy_state_type yy_last_accepting_state;
static char *yy_last_accepting_cpos;

extern int yy_flex_debug;
int yy_flex_debug = 0;

/* The intent behind this definition is that it'll catch
 * any uses of REJECT which flex missed.
 */

#define YY_RESTORE_YY_MORE_OFFSET
char *yytext;
#line 1 "moc.l"
#define INITIAL 0
/****************************************************************************
** $Id: qt/moc_lex.cpp   3.3.8   edited Mar 23 02:24 $
**
** Lexical analyzer for meta object compiler
**

extern void addExpressionChar( const char );
extern void addExpressionString( const char * );
extern void moc_warn( const char *msg );

#line 1033 "lex.yy.c"

#define INITIAL 0
#define OUTSIDE 1
#define QT_DEF 2
#define IN_CLASS 3

#define IN_PROPERTY 12
#define IN_CLASSINFO 13

#line 968 "lex.yy.c"
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include <unistd.h>
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

/* Macros after this point can all be overridden by user definitions in
 * section 1.


#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap YY_PROTO(( void ));
#else
extern int yywrap YY_PROTO(( void ));
#endif
#endif

#ifndef YY_NO_UNPUT
static void yyunput YY_PROTO(( int c, char *buf_ptr ));
#endif

    static void yyunput (int c,char *buf_ptr  );
    
#ifndef yytext_ptr
static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen YY_PROTO(( yyconst char * ));
#endif

#ifndef YY_NO_INPUT

#ifdef __cplusplus
static int yyinput YY_PROTO(( void ));
#else
static int input YY_PROTO(( void ));
#endif
#endif

#if YY_STACK_USED
static int yy_start_stack_ptr = 0;
static int yy_start_stack_depth = 0;
static int *yy_start_stack = 0;
#ifndef YY_NO_PUSH_STATE
static void yy_push_state YY_PROTO(( int new_state ));
#endif
#ifndef YY_NO_POP_STATE
static void yy_pop_state YY_PROTO(( void ));
#endif
#ifndef YY_NO_TOP_STATE
static int yy_top_state YY_PROTO(( void ));
#endif

#else
#define YY_NO_PUSH_STATE 1
#define YY_NO_POP_STATE 1
#define YY_NO_TOP_STATE 1
#endif

#ifdef YY_MALLOC_DECL
YY_MALLOC_DECL
#else
#if __STDC__
#ifndef __cplusplus
#include <stdlib.h>
#endif
#else
/* Just try to get by without declaring the routines.  This will fail
 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 * or sizeof(void*) != sizeof(int).
 */
#endif
#endif

/* Amount of stuff to slurp up with each read. */

#endif

/* Copy whatever the last rule matched to the standard output. */

#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().

 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( yy_current_buffer->yy_is_interactive ) \
		{ \
		int c = '*', n; \
		size_t n; \
		for ( n = 0; n < max_size && \
			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \

			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
		  && ferror( yyin ) ) \
		YY_FATAL_ERROR( "input in flex scanner failed" );
		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
			{ \
			if( errno != EINTR) \
				{ \
				YY_FATAL_ERROR( "input in flex scanner failed" ); \
				break; \
				} \
			errno=0; \
			clearerr(yyin); \
			} \
		}\
\

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -

#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
#endif

/* end tables serialization structures and prototypes */

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL int yylex YY_PROTO(( void ))
#endif
extern int yylex (void);

#define YY_DECL int yylex (void)
#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.


#define YY_RULE_SETUP \
	if ( yyleng > 0 ) \
		yy_current_buffer->yy_at_bol = \
				(yytext[yyleng - 1] == '\n'); \
	YY_USER_ACTION

/** The main scanner function which does all the work.
 */
YY_DECL
	{
	register yy_state_type yy_current_state;
	register char *yy_cp = NULL, *yy_bp = NULL;
	register int yy_act;

#line 110 "moc.l"


#line 1125 "lex.yy.c"

	if ( yy_init )
		{
		yy_init = 0;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

		if ( ! yy_start )
			yy_start = 1;	/* first start state */

		if ( ! yyin )
			yyin = stdin;

		if ( ! yyout )
			yyout = stdout;

		if ( ! yy_current_buffer )
			yy_current_buffer =
				yy_create_buffer( yyin, YY_BUF_SIZE );
				yy_create_buffer(yyin,YY_BUF_SIZE );
		}

		yy_load_buffer_state();
		}

	while ( 1 )		/* loops until end-of-file is reached */
		{
		yy_cp = yy_c_buf_p;

		/* Support of yytext. */
		*yy_cp = yy_hold_char;

		/* yy_bp points to the position in yy_ch_buf of the start of
		 * the current run.
		 */
		yy_bp = yy_cp;

		yy_current_state = yy_start;
		yy_current_state += YY_AT_BOL();
yy_match:
		do

			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
			if ( yy_accept[yy_current_state] )
				{
				yy_last_accepting_state = yy_current_state;
				yy_last_accepting_cpos = yy_cp;
				}
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{

		yy_act = yy_accept[yy_current_state];
		if ( yy_act == 0 )
			{ /* have to back up */
			yy_cp = yy_last_accepting_cpos;
			yy_current_state = yy_last_accepting_state;
			yy_act = yy_accept[yy_current_state];
			}

		YY_DO_BEFORE_ACTION;


do_action:	/* This label is used only to access EOF actions. */


		switch ( yy_act )
	{ /* beginning of action switch */
			case 0: /* must back up */
			/* undo the effects of YY_DO_BEFORE_ACTION */
			*yy_cp = yy_hold_char;
			yy_cp = yy_last_accepting_cpos;
			yy_current_state = yy_last_accepting_state;
			goto yy_find_action;

case 1:

{ X; return ','; }
	YY_BREAK
case 104:
/* rule 104 can match eol */
YY_RULE_SETUP
#line 278 "moc.l"
{

;
	YY_BREAK
case 108:
/* rule 108 can match eol */
YY_RULE_SETUP
#line 289 "moc.l"
{				/* discard strings */

			}
	YY_BREAK
case 109:
/* rule 109 can match eol */
YY_RULE_SETUP
#line 293 "moc.l"
{				/* discard strings */

			}
	YY_BREAK
case 110:
/* rule 110 can match eol */
YY_RULE_SETUP
#line 297 "moc.l"
{			/* discard strings */

			}
	YY_BREAK
case 111:
/* rule 111 can match eol */
YY_RULE_SETUP
#line 301 "moc.l"
{			/* discard strings */

			}
	YY_BREAK
case 112:
/* rule 112 can match eol */
YY_RULE_SETUP
#line 308 "moc.l"
{

			}
	YY_BREAK
case 113:
/* rule 113 can match eol */
YY_RULE_SETUP
#line 315 "moc.l"
{

			}
	YY_BREAK
case 133:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
#line 420 "moc.l"

			}
	YY_BREAK
case 150:
/* rule 150 can match eol */
YY_RULE_SETUP
#line 488 "moc.l"
{

#line 493 "moc.l"
ECHO;
	YY_BREAK
#line 2155 "lex.yy.c"
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(OUTSIDE):
case YY_STATE_EOF(QT_DEF):

	case YY_END_OF_BUFFER:
		{
		/* Amount of text matched not including the EOB char. */
		int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;

		/* Undo the effects of YY_DO_BEFORE_ACTION. */
		*yy_cp = yy_hold_char;
		YY_RESTORE_YY_MORE_OFFSET

		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
			{
			/* We're scanning a new file or input source.  It's
			 * possible that this happened because the user
			 * just pointed yyin at a new source and called
			 * yylex().  If so, then we have to assure
			 * consistency between yy_current_buffer and our
			 * globals.  Here is the right place to do so, because
			 * this is the first action (other than possibly a
			 * back-up) that will match for the new input source.
			 */
			yy_n_chars = yy_current_buffer->yy_n_chars;
			yy_current_buffer->yy_input_file = yyin;
			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
			}

		/* Note that here we test for yy_c_buf_p "<=" to the position

		 * end-of-buffer state).  Contrast this with the test
		 * in input().
		 */
		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
			{ /* This was really a NUL. */
			yy_state_type yy_next_state;

			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;

			yy_current_state = yy_get_previous_state();

			/* Okay, we're now positioned to make the NUL
			 * transition.  We couldn't have


			yy_next_state = yy_try_NUL_trans( yy_current_state );

			yy_bp = yytext_ptr + YY_MORE_ADJ;

			if ( yy_next_state )
				{
				/* Consume the NUL. */
				yy_cp = ++yy_c_buf_p;
				yy_current_state = yy_next_state;
				goto yy_match;
				}

			else
				{
				yy_cp = yy_c_buf_p;
				goto yy_find_action;
				}
			}

		else switch ( yy_get_next_buffer() )
			{
			case EOB_ACT_END_OF_FILE:
				{
				yy_did_buffer_switch_on_eof = 0;

				if ( yywrap() )
					{
					/* Note: because we've taken care in
					 * yy_get_next_buffer() to have set up

					 * YY_NULL, it'll still work - another
					 * YY_NULL will get returned.
					 */
					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;

					yy_act = YY_STATE_EOF(YY_START);
					goto do_action;


				else
					{
					if ( ! yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
					}
				break;
				}

			case EOB_ACT_CONTINUE_SCAN:
				yy_c_buf_p =
					yytext_ptr + yy_amount_of_matched_text;

				yy_current_state = yy_get_previous_state();

				yy_cp = yy_c_buf_p;
				yy_bp = yytext_ptr + YY_MORE_ADJ;
				goto yy_match;

			case EOB_ACT_LAST_MATCH:
				yy_c_buf_p =
				&yy_current_buffer->yy_ch_buf[yy_n_chars];

				yy_current_state = yy_get_previous_state();

				yy_cp = yy_c_buf_p;
				yy_bp = yytext_ptr + YY_MORE_ADJ;
				goto yy_find_action;
			}
		break;

			"fatal flex scanner internal error--no action found" );
	} /* end of action switch */
		} /* end of scanning one token */
	} /* end of yylex */


/* yy_get_next_buffer - try to read in a new buffer
 *

 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *	EOB_ACT_END_OF_FILE - end of file
 */

static int yy_get_next_buffer()
	{
	register char *dest = yy_current_buffer->yy_ch_buf;
	register char *source = yytext_ptr;
	register int number_to_move, i;
	int ret_val;

	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
		YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

	if ( yy_current_buffer->yy_fill_buffer == 0 )
		{ /* Don't try to fill the buffer, so this is an EOF. */
		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
			{
			/* We matched a single character, the EOB, so
			 * treat this as a final EOF.

	/* Try to read more data. */

	/* First move last chars to start of buffer. */
	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;

	for ( i = 0; i < number_to_move; ++i )
		*(dest++) = *(source++);

	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
		/* don't do the read, it's not guaranteed to return an EOF,
		 * just force an EOF
		 */
		yy_current_buffer->yy_n_chars = yy_n_chars = 0;

	else
		{
		int num_to_read =
			yy_current_buffer->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 )
			{ /* Not enough room in the buffer - grow it. */
#ifdef YY_USES_REJECT
			YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
#else

			/* just a shorter name for the current buffer */
			YY_BUFFER_STATE b = yy_current_buffer;

			int yy_c_buf_p_offset =
				(int) (yy_c_buf_p - b->yy_ch_buf);

			if ( b->yy_is_our_buffer )
				{


				b->yy_ch_buf = (char *)
					/* Include room in for 2 EOB chars. */
					yy_flex_realloc( (void *) b->yy_ch_buf,
							 b->yy_buf_size + 2 );
				}
			else
				/* Can't grow it, we don't own it. */

				YY_FATAL_ERROR(
				"fatal error - scanner input buffer overflow" );

			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

			num_to_read = yy_current_buffer->yy_buf_size -
						number_to_move - 1;
#endif
			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;

		/* Read in more data. */
		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
			yy_n_chars, num_to_read );

		yy_current_buffer->yy_n_chars = yy_n_chars;
		}

	if ( yy_n_chars == 0 )
		{
		if ( number_to_move == YY_MORE_ADJ )
			{
			ret_val = EOB_ACT_END_OF_FILE;
			yyrestart( yyin );
			}

		else
			{
			ret_val = EOB_ACT_LAST_MATCH;
			yy_current_buffer->yy_buffer_status =
				YY_BUFFER_EOF_PENDING;
			}
		}

	else
		ret_val = EOB_ACT_CONTINUE_SCAN;

	yy_n_chars += number_to_move;
	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];

	return ret_val;
	}


/* yy_get_previous_state - get the state just before the EOB char was reached */

static yy_state_type yy_get_previous_state()
	{
	register yy_state_type yy_current_state;
	register char *yy_cp;

	yy_current_state = yy_start;
	yy_current_state += YY_AT_BOL();

	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
		{
		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
		if ( yy_accept[yy_current_state] )
			{
			yy_last_accepting_state = yy_current_state;
			yy_last_accepting_cpos = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{

		}

	return yy_current_state;
	}


/* yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *	next_state = yy_try_NUL_trans( current_state );
 */

#ifdef YY_USE_PROTOS
static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
#else
static yy_state_type yy_try_NUL_trans( yy_current_state )
yy_state_type yy_current_state;
#endif
	{
	register int yy_is_jam;
	register char *yy_cp = yy_c_buf_p;

	register YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		yy_last_accepting_state = yy_current_state;
		yy_last_accepting_cpos = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{

	yy_is_jam = (yy_current_state == 614);

	return yy_is_jam ? 0 : yy_current_state;
	}


#ifndef YY_NO_UNPUT
#ifdef YY_USE_PROTOS
static void yyunput( int c, register char *yy_bp )
#else
static void yyunput( c, yy_bp )
int c;
register char *yy_bp;
#endif
	{
	register char *yy_cp = yy_c_buf_p;

	/* undo effects of setting up yytext */
	*yy_cp = yy_hold_char;

	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
		{ /* need to shift things up to make room */
		/* +2 for EOB chars. */
		register int number_to_move = yy_n_chars + 2;
		register char *dest = &yy_current_buffer->yy_ch_buf[
					yy_current_buffer->yy_buf_size + 2];
		register char *source =
				&yy_current_buffer->yy_ch_buf[number_to_move];

		while ( source > yy_current_buffer->yy_ch_buf )
			*--dest = *--source;

		yy_cp += (int) (dest - source);
		yy_bp += (int) (dest - source);
		yy_current_buffer->yy_n_chars =
			yy_n_chars = yy_current_buffer->yy_buf_size;

		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
			YY_FATAL_ERROR( "flex scanner push-back overflow" );
		}

	*--yy_cp = (char) c;


	yytext_ptr = yy_bp;
	yy_hold_char = *yy_cp;
	yy_c_buf_p = yy_cp;
	}
#endif	/* ifndef YY_NO_UNPUT */


#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput()
#else
static int input()
#endif
	{
{
	int c;
    
	*(yy_c_buf_p) = (yy_hold_char);

	*yy_c_buf_p = yy_hold_char;

	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
			/* This was really a NUL. */
			*yy_c_buf_p = '\0';

		else
			{ /* need more input */
			int offset = yy_c_buf_p - yytext_ptr;
			++yy_c_buf_p;

			switch ( yy_get_next_buffer() )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because yy_g_n_b()

					 */

					/* Reset buffer status. */
					yyrestart( yyin );

					/* fall through */

				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap() )
						return EOF;

					if ( ! yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput();

					}

				case EOB_ACT_CONTINUE_SCAN:
					yy_c_buf_p = yytext_ptr + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */
	*yy_c_buf_p = '\0';	/* preserve yytext */
	yy_hold_char = *++yy_c_buf_p;

	yy_current_buffer->yy_at_bol = (c == '\n');

	return c;
	}
#endif /* YY_NO_INPUT */

#ifdef YY_USE_PROTOS
void yyrestart( FILE *input_file )
#else
void yyrestart( input_file )
FILE *input_file;
#endif
	{
	if ( ! yy_current_buffer )
		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );

	yy_init_buffer( yy_current_buffer, input_file );
	yy_load_buffer_state();
	}


#ifdef YY_USE_PROTOS
void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
#else
void yy_switch_to_buffer( new_buffer )
YY_BUFFER_STATE new_buffer;
#endif
	{
	if ( yy_current_buffer == new_buffer )
{
    
	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
     */
	yyensure_buffer_stack ();
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( yy_current_buffer )
		{
		/* Flush out information for old buffer. */
		*yy_c_buf_p = yy_hold_char;
		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
		yy_current_buffer->yy_n_chars = yy_n_chars;
		}

	yy_current_buffer = new_buffer;
	yy_load_buffer_state();

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	yy_did_buffer_switch_on_eof = 1;
	}


#ifdef YY_USE_PROTOS
void yy_load_buffer_state( void )
#else
void yy_load_buffer_state()
#endif
	{
	yy_n_chars = yy_current_buffer->yy_n_chars;
	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
	yyin = yy_current_buffer->yy_input_file;
	yy_hold_char = *yy_c_buf_p;
	}


#ifdef YY_USE_PROTOS
YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
#else
YY_BUFFER_STATE yy_create_buffer( file, size )
FILE *file;
int size;
#endif
	{
	YY_BUFFER_STATE b;

	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );


	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file );

	return b;
	}


#ifdef YY_USE_PROTOS
void yy_delete_buffer( YY_BUFFER_STATE b )
#else
void yy_delete_buffer( b )
YY_BUFFER_STATE b;
#endif
	{
	if ( ! b )
		return;

	if ( b == yy_current_buffer )
		yy_current_buffer = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yy_flex_free( (void *) b->yy_ch_buf );

	yy_flex_free( (void *) b );
	}

#ifndef __cplusplus
extern int isatty (int );
#endif /* __cplusplus */
    
/* Initializes or reinitializes a buffer.
 * This function is sometimes called more than once on the same buffer,
 * such as during a yyrestart() or at EOF.
 */
    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )


#ifdef YY_USE_PROTOS
void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
#else
void yy_init_buffer( b, file )
YY_BUFFER_STATE b;
FILE *file;
#endif


	{
	yy_flush_buffer( b );

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

#if YY_ALWAYS_INTERACTIVE
	b->yy_is_interactive = 1;
#else
#if YY_NEVER_INTERACTIVE
	b->yy_is_interactive = 0;
#else
	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
#endif
#endif
	}


#ifdef YY_USE_PROTOS
void yy_flush_buffer( YY_BUFFER_STATE b )
#else
void yy_flush_buffer( b )
YY_BUFFER_STATE b;
#endif

	{
	if ( ! b )
		return;

	b->yy_n_chars = 0;

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == yy_current_buffer )
		yy_load_buffer_state();
}

/** Pushes the new state onto the stack. The new state becomes
 *  the current state. This function will allocate the stack
 *  if necessary.
 *  @param new_buffer The new state.
 *  
 */
void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
{
    	if (new_buffer == NULL)
		return;

	yyensure_buffer_stack();

	/* This block is copied from yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*(yy_c_buf_p) = (yy_hold_char);
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		(yy_buffer_stack_top)++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state( );
	(yy_did_buffer_switch_on_eof) = 1;
}

/** Removes and deletes the top of the stack, if present.
 *  The next element becomes the new top.
 *  
 */
void yypop_buffer_state (void)
{
    	if (!YY_CURRENT_BUFFER)
		return;

	yy_delete_buffer(YY_CURRENT_BUFFER );
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if ((yy_buffer_stack_top) > 0)
		--(yy_buffer_stack_top);

	if (YY_CURRENT_BUFFER) {
		yy_load_buffer_state( );
		(yy_did_buffer_switch_on_eof) = 1;
	}
}

/* Allocates the stack if it does not exist.
 *  Guarantees space for at least one push.
 */
static void yyensure_buffer_stack (void)
{
	int num_to_alloc;
    
	if (!(yy_buffer_stack)) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
		num_to_alloc = 1;
		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		
		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
				
		(yy_buffer_stack_max) = num_to_alloc;
		(yy_buffer_stack_top) = 0;
		return;
	}

	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

		/* Increase the buffer to prepare for a possible push. */
		int grow_size = 8 /* arbitrary grow size */;

#ifndef YY_NO_SCAN_BUFFER
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
#else
YY_BUFFER_STATE yy_scan_buffer( base, size )
char *base;
yy_size_t size;
#endif
	{
	}
}

/** Setup the input buffer state to scan directly from a user-specified character buffer.
 * @param base the character buffer
 * @param size the size in bytes of the character buffer
 * 
 * @return the newly allocated buffer state object. 
 */
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
{
	YY_BUFFER_STATE b;

	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return 0;

	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );


	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer( b );

	return b;
	}
#endif


#ifndef YY_NO_SCAN_STRING
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
#else
YY_BUFFER_STATE yy_scan_string( yy_str )
yyconst char *yy_str;
#endif
	{
	int len;
	for ( len = 0; yy_str[len]; ++len )
		;

	return yy_scan_bytes( yy_str, len );
	}
#endif


#ifndef YY_NO_SCAN_BYTES
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
#else
YY_BUFFER_STATE yy_scan_bytes( bytes, len )
yyconst char *bytes;
int len;
#endif
	{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;

	/* Get memory for full buffer, including space for trailing EOB's. */
	n = len + 2;
	buf = (char *) yy_flex_alloc( n );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );



	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer( buf, n );
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );


	b->yy_is_our_buffer = 1;

	return b;
	}

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

static void yy_fatal_error (yyconst char* msg )
{
    	(void) fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
}

#ifndef YY_NO_PUSH_STATE
#ifdef YY_USE_PROTOS
static void yy_push_state( int new_state )
#else
static void yy_push_state( new_state )
int new_state;
#endif
	{
	if ( yy_start_stack_ptr >= yy_start_stack_depth )
		{
		yy_size_t new_size;

		yy_start_stack_depth += YY_START_STACK_INCR;
		new_size = yy_start_stack_depth * sizeof( int );
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		yytext[yyleng] = (yy_hold_char); \
		(yy_c_buf_p) = yytext + yyless_macro_arg; \
		(yy_hold_char) = *(yy_c_buf_p); \
		*(yy_c_buf_p) = '\0'; \
		yyleng = yyless_macro_arg; \
		} \
	while ( 0 )

		if ( ! yy_start_stack )
			yy_start_stack = (int *) yy_flex_alloc( new_size );

		else
			yy_start_stack = (int *) yy_flex_realloc(
					(void *) yy_start_stack, new_size );
int yyget_lineno  (void)
{
        
    return yylineno;
}

		if ( ! yy_start_stack )
			YY_FATAL_ERROR(
			"out of memory expanding start-condition stack" );
		}
{
        return yyin;
}

	yy_start_stack[yy_start_stack_ptr++] = YY_START;
 * 
 */
FILE *yyget_out  (void)
{
        return yyout;
}

	BEGIN(new_state);
	}
#endif
int yyget_leng  (void)
{
        return yyleng;
}

/** Get the current token.
 * 
 */

#ifndef YY_NO_POP_STATE
static void yy_pop_state()
	{
	if ( --yy_start_stack_ptr < 0 )
		YY_FATAL_ERROR( "start-condition stack underflow" );

	BEGIN(yy_start_stack[yy_start_stack_ptr]);
	}
#endif
 */
void yyset_lineno (int  line_number )
{
    
    yylineno = line_number;
}

/** Set the input stream. This does not discard the current
 * input buffer.
 * @param in_str A readable stream.
 * 
 * @see yy_switch_to_buffer
 */
void yyset_in (FILE *  in_str )
{
        yyin = in_str ;
}

void yyset_out (FILE *  out_str )
{
        yyout = out_str ;
}

#ifndef YY_NO_TOP_STATE
static int yy_top_state()
	{
	return yy_start_stack[yy_start_stack_ptr - 1];
	}
#endif

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif
}

#ifdef YY_USE_PROTOS
static void yy_fatal_error( yyconst char msg[] )
#else
static void yy_fatal_error( msg )
char msg[];
#endif
	{
	(void) fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
	}

	/* Destroy the stack itself. */
	yyfree((yy_buffer_stack) );
	(yy_buffer_stack) = NULL;

    return 0;
}

/* Redefine yyless() so it works in section 3 code. */

#undef yyless
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
		yytext[yyleng] = yy_hold_char; \
		yy_c_buf_p = yytext + n; \
		yy_hold_char = *yy_c_buf_p; \
		*yy_c_buf_p = '\0'; \
		yyleng = n; \
		} \
	while ( 0 )


/* Internal utility routines. */

#ifndef yytext_ptr
#ifdef YY_USE_PROTOS
static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
#else
static void yy_flex_strncpy( s1, s2, n )
char *s1;
yyconst char *s2;
int n;
#endif
	{
	register int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
	}
#endif

#ifdef YY_NEED_STRLEN
#ifdef YY_USE_PROTOS
static int yy_flex_strlen( yyconst char *s )
#else
static int yy_flex_strlen( s )
yyconst char *s;
#endif
	{
	register int n;
	for ( n = 0; s[n]; ++n )
		;

	return n;
	}
#endif


#ifdef YY_USE_PROTOS
static void *yy_flex_alloc( yy_size_t size )
#else
static void *yy_flex_alloc( size )
yy_size_t size;
#endif
	{
	return (void *) malloc( size );
	}

#ifdef YY_USE_PROTOS
static void *yy_flex_realloc( void *ptr, yy_size_t size )
#else
static void *yy_flex_realloc( ptr, size )
void *ptr;
yy_size_t size;
#endif
	{
	/* The cast to (char *) in the following accommodates both
	 * implementations that use char* generic pointers, and those
	 * that use void* generic pointers.  It works with the latter

	 * as though doing an assignment.
	 */
	return (void *) realloc( (char *) ptr, size );
	}

void yyfree (void * ptr )
{
	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
}

#ifdef YY_USE_PROTOS
static void yy_flex_free( void *ptr )
#else
static void yy_flex_free( ptr )
void *ptr;
#endif
	{
	free( ptr );
	}

#if YY_MAIN
int main()
	{
	yylex();
	return 0;
	}
#undef YY_DO_BEFORE_ACTION

#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif
#line 493 "moc.l"



#endif // MOC_YACC_CODE





#ifndef lint
static char const 
yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28 2000/01/17 02:04:06 bde Exp $";
#endif
#include <stdlib.h>
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYLEX yylex()
#define YYEMPTY -1
#define yyclearin (yychar=(YYEMPTY))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING() (yyerrflag!=0)
static int yygrowstack();
#define YYPREFIX "yy"
#line 55 "moc.y"
#define MOC_YACC_CODE

    ArgList    *arg_list;
    Argument   *arg;
} YYSTYPE;
#line 658 "y.tab.c"
#define YYERRCODE 256
#define CHAR_VAL 257
#define INT_VAL 258
#define DOUBLE_VAL 259

#define DESIGNABLE 308
#define SCRIPTABLE 309
#define RESET 310
const short yylhs[] = {                                        -1,
short yylhs[] = {                                        -1,
    0,    0,   40,   40,   40,   40,   40,   42,   42,   48,
   50,   46,   51,   52,   47,   49,   43,   45,   44,   44,
   54,   41,    1,    1,    2,   55,   56,   57,   58,   30,

  134,  134,  135,  136,  135,  138,   97,  137,  137,  137,
  137,  137,  137,  137,  105,  105,  108,  108,
};
const short yylen[] = {                                         2,
    0,    2,    1,    1,    1,    1,    1,    1,    1,    0,
    0,    7,    0,    0,    6,    1,    5,    2,    2,    2,
    0,    3,    1,    1,    4,    0,    0,    0,    0,    1,

    1,    3,    1,    0,    4,    0,    4,    0,    3,    3,
    3,    3,    3,    3,    0,    2,    0,    2,
};
const short yydefred[] = {                                      1,
    0,    0,    0,    2,    3,    4,    5,    6,    7,    8,
    9,    0,    0,    0,   19,   20,   18,    0,    0,    0,
    0,    0,    0,    0,    0,    0,   14,   26,  140,   40,

   28,   96,  102,   27,  156,   79,    0,  131,    0,  128,
  105,  129,   89,    0,  151,    0,    0,  158,  132,  130,
};
const short yydgoto[] = {                                      93,
   53,   54,  162,   64,   65,   85,   86,   87,   88,  163,
  164,  165,  166,  167,  168,   69,  169,   48,  318,  319,
  320,  365,  366,  321,  477,  302,  303,  304,  322,  170,

  180,  181,  245,  376,  182,  315,  402,  377,  441,  416,
  324,  199,  344,  270,  271,  395,  385,  329,
};
const short yysindex[] = {                                      0,
   70, -206, -111,    0,    0,    0,    0,    0,    0,    0,
    0, -220,   41,   10,    0,    0,    0,   67,  912,  -96,
  152,  124,   91,  559,  -81,   98,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,  991,    0,  799,    0,
    0,    0,    0, 1015,    0,  936, 1004,    0,    0,    0,
};
const short yyrindex[] = {                                      0,
  330,  941,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  199,  943,    0,    0,    0,    0,    0,  373,    0,
    0,    0,    0,    5,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
};
const short yygindex[] = {                                   1152,
  347,    0, 1150,  930,    0,    0,  435, 1056,  449,  283,
 -135,    0,   57,  -11,  -25,  122,    0,    0,    0,    0,
    0,  765,  810, -294,    0, -159,    0,  892,    0,  -10,

    0,    0,  931, 1005,  974,    0,  856,    0,
};
#define YYTABLESIZE 1510
const short yytable[] = {                                      68,
   20,  226,  218,   77,   63,  225,   90,  228,  123,   90,
  123,  123,  123,   90,  123,  149,   90,   84,  372,  122,
   84,  122,  122,  122,   87,  122,   90,   87,  123,  123,

  154,  155,   30,   31,   32,   33,   34,   35,   36,   37,
    0,   38,   39,   40,   41,   42,   43,   44,   45,   46,
};
const short yycheck[] = {                                      25,
   12,   38,  159,   41,   58,   42,   41,  164,   38,   44,
   40,   41,   42,   41,   44,   58,   44,   41,   40,   38,
   44,   40,   41,   42,   41,   44,   61,   44,   58,   59,

#endif
#define YYMAXTOKEN 310
#if YYDEBUG
const char * const yyname[] = {
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
"'!'",0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,
0,0,0,0,0,"':'","';'","'<'","'='","'>'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

"Q_OBJECT","Q_PROPERTY","Q_OVERRIDE","Q_CLASSINFO","Q_ENUMS","Q_SETS","READ",
"WRITE","STORED","DESIGNABLE","SCRIPTABLE","RESET",
};
const char * const yyrule[] = {
"$accept : declaration_seq",
"declaration_seq :",
"declaration_seq : declaration_seq declaration",

"qt_sets : IDENTIFIER qt_sets",
};
#endif
#if YYDEBUG
#include <stdio.h>
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE

#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 10000
#define YYMAXDEPTH 10000
#endif
#endif
#define YYINITSTACKSIZE 200
int yydebug;
int yynerrs;
int yyerrflag;

YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short *yyss;
short *yysslim;
YYSTYPE *yyvs;
int yystacksize;
#line 1606 "moc.y"

#ifndef YYBISON

    const char *hdr1 = "/****************************************************************************\n"
		 "** %s meta object code from reading C++ file '%s'\n**\n";
    const char *hdr2 = "** Created: %s\n"
		 "**      by: The Qt MOC ($Id: qt/moc_yacc.cpp   3.3.8   edited Mar 23 02:24 $)\n**\n";
    const char *hdr3 = "** WARNING! All changes made in this file will be lost!\n";
    const char *hdr4 = "*****************************************************************************/\n\n";
    int   i;

	return;
    }
}
#line 3659 "y.tab.c"
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack()
{
    int newsize, i;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = yystacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;
    i = yyssp - yyss;
    newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
      (short *)malloc(newsize * sizeof *newss);
    if (newss == NULL)
        return -1;
    yyss = newss;
    yyssp = newss + i;
    newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
      (YYSTYPE *)malloc(newsize * sizeof *newvs);
    if (newvs == NULL)
        return -1;
    yyvs = newvs;
    yyvsp = newvs + i;
    yystacksize = newsize;
    yysslim = yyss + newsize - 1;
    return 0;
}

#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab

#ifndef YYPARSE_PARAM
#if defined(__cplusplus) || __STDC__
#define YYPARSE_PARAM_ARG void
#define YYPARSE_PARAM_DECL
#else	/* ! ANSI-C/C++ */
#define YYPARSE_PARAM_ARG
#define YYPARSE_PARAM_DECL
#endif	/* ANSI-C/C++ */
#else	/* YYPARSE_PARAM */
#ifndef YYPARSE_PARAM_TYPE
#define YYPARSE_PARAM_TYPE void *
#endif
#if defined(__cplusplus) || __STDC__
#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#else	/* ! ANSI-C/C++ */
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
#endif	/* ANSI-C/C++ */
#endif	/* ! YYPARSE_PARAM */

int
yyparse (YYPARSE_PARAM_ARG)
    YYPARSE_PARAM_DECL
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register const char *yys;
    extern char *getenv();

    if ((yys = getenv("YYDEBUG")))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')

    yyerrflag = 0;
    yychar = (-1);

    if (yyss == NULL && yygrowstack()) goto yyoverflow;
    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if ((yyn = yydefred[yystate])) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;

            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yysslim && yygrowstack())
        {
            goto yyoverflow;
        }

        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#if defined(lint) || defined(__GNUC__)
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#if defined(lint) || defined(__GNUC__)
    goto yyerrlab;
#endif
yyerrlab:

                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= yysslim && yygrowstack())
                {
                    goto yyoverflow;
                }

#line 1602 "moc.y"
{ g->qtSets.append( yyvsp[-1].string ); }
break;
#line 4823 "y.tab.c"
    }
    yyssp -= yym;
    yystate = *yyssp;

        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
    if (yyssp >= yysslim && yygrowstack())
    {
        goto yyoverflow;
    }

Lines 1-3 Link Here

(-)qt-x11-commercial-3.3.8/src/moc/moc_yacc.h (+4 lines)
		1	#ifndef YYERRCODE
		2	#define YYERRCODE 256
		3	#endif
		4
1	#define CHAR_VAL 257	5	#define CHAR_VAL 257
2	#define INT_VAL 258	6	#define INT_VAL 258
3	#define DOUBLE_VAL 259	7	#define DOUBLE_VAL 259

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/src/opengl/qgl.cpp (-3 / +7 lines)
1	/****************************************************************************	1	/****************************************************************************
2	** $Id: qt/qgl.cpp 3.3.8 edited Jan 11 14:38 $	2	** $Id: qt/qgl.cpp 3.3.8 edited Mar 22 11:48 $
3	**	3	**
4	** Implementation of OpenGL classes for Qt	4	** Implementation of OpenGL classes for Qt
5	**	5	**
Lines 2201-2206 Link Here
2201		2201
2202	void QGLWidget::renderText( int x, int y, const QString & str, const QFont & fnt, int listBase )	2202	void QGLWidget::renderText( int x, int y, const QString & str, const QFont & fnt, int listBase )
2203	{	2203	{
		2204	if (str.isEmpty())
		2205	return;
2204	makeCurrent();	2206	makeCurrent();
2205	glPushAttrib( GL_TRANSFORM_BIT \| GL_VIEWPORT_BIT \| GL_LIST_BIT \| GL_CURRENT_BIT );	2207	glPushAttrib( GL_TRANSFORM_BIT \| GL_VIEWPORT_BIT \| GL_LIST_BIT \| GL_CURRENT_BIT );
2206	glMatrixMode( GL_PROJECTION );	2208	glMatrixMode( GL_PROJECTION );
Lines 2215-2221 Link Here
2215	glBitmap(0, 0, 0, 0, x, -y, NULL);	2217	glBitmap(0, 0, 0, 0, x, -y, NULL);
2216	glListBase( displayListBase( fnt, listBase ) );	2218	glListBase( displayListBase( fnt, listBase ) );
2217	const char *cstr = str.latin1();	2219	const char *cstr = str.latin1();
2218	glCallLists( strlen(cstr), GL_UNSIGNED_BYTE, cstr );	2220	glCallLists( qstrlen(cstr), GL_UNSIGNED_BYTE, cstr );
2219		2221
2220	// restore the matrix stacks and GL state	2222	// restore the matrix stacks and GL state
2221	glPopMatrix();	2223	glPopMatrix();
Lines 2234-2245 Link Here
2234	void QGLWidget::renderText( double x, double y, double z, const QString & str, const QFont & fnt,	2236	void QGLWidget::renderText( double x, double y, double z, const QString & str, const QFont & fnt,
2235	int listBase )	2237	int listBase )
2236	{	2238	{
		2239	if (str.isEmpty())
		2240	return;
2237	makeCurrent();	2241	makeCurrent();
2238	glRasterPos3d( x, y, z );	2242	glRasterPos3d( x, y, z );
2239	glPushAttrib( GL_LIST_BIT );	2243	glPushAttrib( GL_LIST_BIT );
2240	glListBase( displayListBase( fnt, listBase ) );	2244	glListBase( displayListBase( fnt, listBase ) );
2241	const char *cstr = str.latin1();	2245	const char *cstr = str.latin1();
2242	glCallLists( strlen(cstr), GL_UNSIGNED_BYTE, cstr );	2246	glCallLists( qstrlen(cstr), GL_UNSIGNED_BYTE, cstr );
2243	glPopAttrib();	2247	glPopAttrib();
2244	}	2248	}
2245		2249

Lines 56-61 Link Here

(-)qt-x11-commercial-3.3.8/src/sql/drivers/psql/qsql_psql.cpp (+3 lines)
56	#define errno qt_psql_errno	56	#define errno qt_psql_errno
57	#include <catalog/pg_type.h>	57	#include <catalog/pg_type.h>
58	#undef errno	58	#undef errno
		59	#ifdef open
		60	# undef open
		61	#endif
59		62
60	QPtrDict<QSqlDriverExtension> *qSqlDriverExtDict();	63	QPtrDict<QSqlDriverExtension> *qSqlDriverExtDict();
61	QPtrDict<QSqlOpenExtension> *qSqlOpenExtDict();	64	QPtrDict<QSqlOpenExtension> *qSqlOpenExtDict();

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/src/tools/qdatetime.cpp (-2 / +2 lines)
1	/****************************************************************************	1	/****************************************************************************
2	** $Id: qt/qdatetime.cpp 3.3.8 edited Jan 11 14:38 $	2	** $Id: qt/qdatetime.cpp 3.3.8 edited Mar 21 22:57 $
3	**	3	**
4	** Implementation of date and time classes	4	** Implementation of date and time classes
5	**	5	**
Lines 2485-2491 Link Here
2485	return dt;	2485	return dt;
2486	}	2486	}
2487	#endif	2487	#endif
2488	int day = s.mid( firstSpace + 4, 2 ).simplifyWhiteSpace().toInt();	2488	int day = s.mid( firstSpace + 5, 2 ).simplifyWhiteSpace().toInt();
2489	int year = s.right( 4 ).toInt();	2489	int year = s.right( 4 ).toInt();
2490	QDate date( year, month, day );	2490	QDate date( year, month, day );
2491	QTime time;	2491	QTime time;

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/src/tools/qglobal.h (-1 / +1 lines)
1	/****************************************************************************	1	/****************************************************************************
2	** $Id: qt/qglobal.h 3.3.8 edited Feb 2 15:00 $	2	** $Id: qt/qglobal.h 3.3.8 edited Mar 23 02:24 $
3	**	3	**
4	** Global type declarations and definitions	4	** Global type declarations and definitions
5	**	5	**

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/src/tools/qstring.cpp (-7 / +17 lines)
1	/****************************************************************************	1	/****************************************************************************
2	** $Id: qt/qstring.cpp 3.3.8 edited Jan 11 16:03 $	2	** $Id: qt/qstring.cpp 3.3.8 edited Mar 20 15:39 $
3	**	3	**
4	** Implementation of the QString class and related Unicode functions	4	** Implementation of the QString class and related Unicode functions
5	**	5	**
Lines 5805-5810 Link Here
5805	result.setLength( len ); // worst case	5805	result.setLength( len ); // worst case
5806	QChar qch = (QChar )result.unicode();	5806	QChar qch = (QChar )result.unicode();
5807	uint uc = 0;	5807	uint uc = 0;
		5808	uint min_uc = 0;
5808	int need = 0;	5809	int need = 0;
5809	int error = -1;	5810	int error = -1;
5810	uchar ch;	5811	uchar ch;
Lines 5822-5828 Link Here
5822	unsigned short low = uc%0x400 + 0xdc00;	5823	unsigned short low = uc%0x400 + 0xdc00;
5823	*qch++ = QChar(high);	5824	*qch++ = QChar(high);
5824	*qch++ = QChar(low);	5825	*qch++ = QChar(low);
5825	} else {	5826	} else if (uc < min_uc \|\| (uc >= 0xd800 && uc <= 0xdfff) \|\| (uc >= 0xfffe)) {
		5827	// overlong seqence, UTF16 surrogate or BOM
		5828	i = error;
		5829	qch = addOne(qch, result);
		5830	*qch++ = QChar(0xdbff);
		5831	*qch++ = QChar(0xde00+((uchar)utf8[i]));
		5832	} else {
5826	*qch++ = uc;	5833	*qch++ = uc;
5827	}	5834	}
5828	}	5835	}
Lines 5844-5857 Link Here
5844	uc = ch & 0x1f;	5851	uc = ch & 0x1f;
5845	need = 1;	5852	need = 1;
5846	error = i;	5853	error = i;
		5854	min_uc = 0x80;
5847	} else if ((ch & 0xf0) == 0xe0) {	5855	} else if ((ch & 0xf0) == 0xe0) {
5848	uc = ch & 0x0f;	5856	uc = ch & 0x0f;
5849	need = 2;	5857	need = 2;
5850	error = i;	5858	error = i;
		5859	min_uc = 0x800;
5851	} else if ((ch&0xf8) == 0xf0) {	5860	} else if ((ch&0xf8) == 0xf0) {
5852	uc = ch & 0x07;	5861	uc = ch & 0x07;
5853	need = 3;	5862	need = 3;
5854	error = i;	5863	error = i;
		5864	min_uc = 0x10000;
5855	} else {	5865	} else {
5856	// Error	5866	// Error
5857	qch = addOne(qch, result);	5867	qch = addOne(qch, result);
Lines 6038-6048 Link Here
6038	/*!	6048	/*!
6039	\fn QString::operator std::string() const	6049	\fn QString::operator std::string() const
6040		6050
6041	Returns ascii() as a std::string.	6051	Returns ascii() as a std::string.
6042		6052
6043	\warning The function may cause an application to crash if a static C run-time is in use.	6053	\warning The function may cause an application to crash if a static C run-time is in use.
6044	This can happen in Microsoft Visual C++ if Qt is configured as single-threaded. A safe	6054	This can happen in Microsoft Visual C++ if Qt is configured as single-threaded. A safe
6045	alternative is to call ascii() directly and construct a std::string manually.	6055	alternative is to call ascii() directly and construct a std::string manually.
6046	*/	6056	*/
6047		6057
6048	/*!	6058	/*!

Return to bug 171883

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/src/codecs/qutfcodec.cpp (-3 / +17 lines)
1	/****************************************************************************	1	/****************************************************************************
2	** $Id: qt/qutfcodec.cpp 3.3.8 edited Jan 11 14:46 $	2	** $Id: qt/qutfcodec.cpp 3.3.8 edited Mar 21 08:23 $
3	**	3	**
4	** Implementation of QUtf{8,16}Codec class	4	** Implementation of QUtf{8,16}Codec class
5	**	5	**
Lines 154-159 Link Here
154		154
155	class QUtf8Decoder : public QTextDecoder {	155	class QUtf8Decoder : public QTextDecoder {
156	uint uc;	156	uint uc;
		157	uint min_uc;
157	int need;	158	int need;
158	bool headerDone;	159	bool headerDone;
159	public:	160	public:
Lines 167-174 Link Here
167	result.setLength( len ); // worst case	168	result.setLength( len ); // worst case
168	QChar qch = (QChar )result.unicode();	169	QChar qch = (QChar )result.unicode();
169	uchar ch;	170	uchar ch;
		171	int error = -1;
170	for (int i=0; i<len; i++) {	172	for (int i=0; i<len; i++) {
171	ch = *chars++;	173	ch = chars[i];
172	if (need) {	174	if (need) {
173	if ( (ch&0xc0) == 0x80 ) {	175	if ( (ch&0xc0) == 0x80 ) {
174	uc = (uc << 6) \| (ch & 0x3f);	176	uc = (uc << 6) \| (ch & 0x3f);
Lines 182-187 Link Here
182	*qch++ = QChar(high);	184	*qch++ = QChar(high);
183	*qch++ = QChar(low);	185	*qch++ = QChar(low);
184	headerDone = TRUE;	186	headerDone = TRUE;
		187	} else if ((uc < min_uc) \|\| (uc >= 0xd800 && uc <= 0xdfff) \|\| (uc >= 0xfffe)) {
		188	*qch++ = QChar::replacement;
185	} else {	189	} else {
186	if (headerDone \|\| QChar(uc) != QChar::byteOrderMark)	190	if (headerDone \|\| QChar(uc) != QChar::byteOrderMark)
187	*qch++ = uc;	191	*qch++ = uc;
Lines 190-195 Link Here
190	}	194	}
191	} else {	195	} else {
192	// error	196	// error
		197	i = error;
193	*qch++ = QChar::replacement;	198	*qch++ = QChar::replacement;
194	need = 0;	199	need = 0;
195	}	200	}
Lines 200-212 Link Here
200	} else if ((ch & 0xe0) == 0xc0) {	205	} else if ((ch & 0xe0) == 0xc0) {
201	uc = ch & 0x1f;	206	uc = ch & 0x1f;
202	need = 1;	207	need = 1;
		208	error = i;
		209	min_uc = 0x80;
203	} else if ((ch & 0xf0) == 0xe0) {	210	} else if ((ch & 0xf0) == 0xe0) {
204	uc = ch & 0x0f;	211	uc = ch & 0x0f;
205	need = 2;	212	need = 2;
		213	error = i;
		214	min_uc = 0x800;
206	} else if ((ch&0xf8) == 0xf0) {	215	} else if ((ch&0xf8) == 0xf0) {
207	uc = ch & 0x07;	216	uc = ch & 0x07;
208	need = 3;	217	need = 3;
209	}	218	error = i;
		219	min_uc = 0x10000;
		220	} else {
		221	// error
		222	*qch++ = QChar::replacement;
		223	}
210	}	224	}
211	}	225	}
212	result.truncate( qch - result.unicode() );	226	result.truncate( qch - result.unicode() );

Lines 1-5 Link Here

(-)qt-x11-commercial-3.3.8/src/kernel/qscriptengine_x11.cpp (-18 / +18 lines)
1	/****************************************************************************	1	/****************************************************************************
2	** $Id: qt/qscriptengine_x11.cpp 3.3.8 edited Jan 11 14:46 $	2	** $Id: qt/qscriptengine_x11.cpp 3.3.8 edited Mar 2 14:22 $
3	**	3	**
4	** Copyright (C) 2003-2007 Trolltech ASA. All rights reserved.	4	** Copyright (C) 2003-2007 Trolltech ASA. All rights reserved.
5	**	5	**
Lines 101-107 Link Here
101	static const unsigned char indicForms[0xe00-0x900] = {	101	static const unsigned char indicForms[0xe00-0x900] = {
102	// Devangari	102	// Devangari
103	Invalid, VowelMark, VowelMark, VowelMark,	103	Invalid, VowelMark, VowelMark, VowelMark,
104	Invalid, IndependentVowel, IndependentVowel, IndependentVowel,	104	IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,
105	IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,	105	IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,
106	IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,	106	IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,
107		107
Lines 137-144 Link Here
137		137
138	Other, Other, Other, Other,	138	Other, Other, Other, Other,
139	Other, Other, Other, Other,	139	Other, Other, Other, Other,
140	Other, Other, Other, Other,	140	Other, Other, Other, Consonant,
141	Other, Other, Other, Other,	141	Consonant, Consonant /* ??? */, Consonant, Consonant,
142		142
143	// Bengali	143	// Bengali
144	Invalid, VowelMark, VowelMark, VowelMark,	144	Invalid, VowelMark, VowelMark, VowelMark,
Lines 182-188 Link Here
182	Other, Other, Other, Other,	182	Other, Other, Other, Other,
183		183
184	// Gurmukhi	184	// Gurmukhi
185	Invalid, Invalid, VowelMark, Invalid,	185	Invalid, VowelMark, VowelMark, VowelMark,
186	Invalid, IndependentVowel, IndependentVowel, IndependentVowel,	186	Invalid, IndependentVowel, IndependentVowel, IndependentVowel,
187	IndependentVowel, IndependentVowel, IndependentVowel, Invalid,	187	IndependentVowel, IndependentVowel, IndependentVowel, Invalid,
188	Invalid, Invalid, Invalid, IndependentVowel,	188	Invalid, Invalid, Invalid, IndependentVowel,
Lines 217-223 Link Here
217	Other, Other, Other, Other,	217	Other, Other, Other, Other,
218	Other, Other, Other, Other,	218	Other, Other, Other, Other,
219		219
220	StressMark, StressMark, Other, Other,	220	StressMark, StressMark, Consonant, Consonant,
221	Other, Other, Other, Other,	221	Other, Other, Other, Other,
222	Other, Other, Other, Other,	222	Other, Other, Other, Other,
223	Other, Other, Other, Other,	223	Other, Other, Other, Other,
Lines 226-232 Link Here
226	Invalid, VowelMark, VowelMark, VowelMark,	226	Invalid, VowelMark, VowelMark, VowelMark,
227	Invalid, IndependentVowel, IndependentVowel, IndependentVowel,	227	Invalid, IndependentVowel, IndependentVowel, IndependentVowel,
228	IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,	228	IndependentVowel, IndependentVowel, IndependentVowel, IndependentVowel,
229	Invalid, IndependentVowel, Invalid, IndependentVowel,	229	IndependentVowel, IndependentVowel, Invalid, IndependentVowel,
230		230
231	IndependentVowel, IndependentVowel, Invalid, IndependentVowel,	231	IndependentVowel, IndependentVowel, Invalid, IndependentVowel,
232	IndependentVowel, Consonant, Consonant, Consonant,	232	IndependentVowel, Consonant, Consonant, Consonant,
Lines 253-259 Link Here
253	Unknown, Unknown, Unknown, Unknown,	253	Unknown, Unknown, Unknown, Unknown,
254	Unknown, Unknown, Unknown, Unknown,	254	Unknown, Unknown, Unknown, Unknown,
255		255
256	Other, Other, Other, Other,	256	IndependentVowel, IndependentVowel, VowelMark, VowelMark,
257	Other, Other, Other, Other,	257	Other, Other, Other, Other,
258	Other, Other, Other, Other,	258	Other, Other, Other, Other,
259	Other, Other, Other, Other,	259	Other, Other, Other, Other,
Lines 280-286 Link Here
280	Consonant, Consonant, Consonant, Consonant,	280	Consonant, Consonant, Consonant, Consonant,
281		281
282	Consonant, Invalid, Consonant, Consonant,	282	Consonant, Invalid, Consonant, Consonant,
283	Invalid, Invalid, Consonant, Consonant,	283	Invalid, Consonant, Consonant, Consonant,
284	Consonant, Consonant, Unknown, Unknown,	284	Consonant, Consonant, Unknown, Unknown,
285	Nukta, Other, Matra, Matra,	285	Nukta, Other, Matra, Matra,
286		286
Lines 299-305 Link Here
299	Other, Other, Other, Other,	299	Other, Other, Other, Other,
300	Other, Other, Other, Other,	300	Other, Other, Other, Other,
301		301
302	Other, Other, Other, Other,	302	Other, Consonant, Other, Other,
303	Other, Other, Other, Other,	303	Other, Other, Other, Other,
304	Other, Other, Other, Other,	304	Other, Other, Other, Other,
305	Other, Other, Other, Other,	305	Other, Other, Other, Other,
Lines 321-327 Link Here
321	Invalid, Invalid, Consonant, Consonant,	321	Invalid, Invalid, Consonant, Consonant,
322		322
323	Consonant, Consonant, Consonant, Consonant,	323	Consonant, Consonant, Consonant, Consonant,
324	Consonant, Consonant, Invalid, Consonant,	324	Consonant, Consonant, Consonant, Consonant,
325	Consonant, Consonant, Unknown, Unknown,	325	Consonant, Consonant, Unknown, Unknown,
326	Invalid, Invalid, Matra, Matra,	326	Invalid, Invalid, Matra, Matra,
327		327
Lines 405-411 Link Here
405	Consonant, Consonant, Consonant, Consonant,	405	Consonant, Consonant, Consonant, Consonant,
406	Invalid, Consonant, Consonant, Consonant,	406	Invalid, Consonant, Consonant, Consonant,
407	Consonant, Consonant, Unknown, Unknown,	407	Consonant, Consonant, Unknown, Unknown,
408	Invalid, Invalid, Matra, Matra,	408	Nukta, Other, Matra, Matra,
409		409
410	Matra, Matra, Matra, Matra,	410	Matra, Matra, Matra, Matra,
411	Matra, Invalid, Matra, Matra,	411	Matra, Invalid, Matra, Matra,
Lines 417-423 Link Here
417	Invalid, Invalid, Invalid, Invalid,	417	Invalid, Invalid, Invalid, Invalid,
418	Invalid, Invalid, Consonant, Invalid,	418	Invalid, Invalid, Consonant, Invalid,
419		419
420	IndependentVowel, IndependentVowel, Invalid, Invalid,	420	IndependentVowel, IndependentVowel, VowelMark, VowelMark,
421	Invalid, Invalid, Other, Other,	421	Invalid, Invalid, Other, Other,
422	Other, Other, Other, Other,	422	Other, Other, Other, Other,
423	Other, Other, Other, Other,	423	Other, Other, Other, Other,
Lines 607-613 Link Here
607	None, None, None, None,	607	None, None, None, None,
608		608
609	// Gurmukhi	609	// Gurmukhi
610	None, None, Above, None,	610	None, Above, Above, Post,
611	None, None, None, None,	611	None, None, None, None,
612	None, None, None, None,	612	None, None, None, None,
613	None, None, None, None,	613	None, None, None, None,
Lines 678-684 Link Here
678	None, None, None, None,	678	None, None, None, None,
679	None, None, None, None,	679	None, None, None, None,
680		680
681	None, None, None, None,	681	None, None, Below, Below,
682	None, None, None, None,	682	None, None, None, None,
683	None, None, None, None,	683	None, None, None, None,
684	None, None, None, None,	684	None, None, None, None,
Lines 717-730 Link Here
717	None, None, None, None,	717	None, None, None, None,
718	None, None, Above, Post,	718	None, None, Above, Post,
719	None, None, None, None,	719	None, None, None, None,
720	None, None, None, None,	720	None, None, None, Post,
721		721
722	None, None, None, None,	722	None, None, None, None,
723	None, None, None, None,	723	None, None, None, None,
724	None, None, None, None,	724	None, None, None, None,
725	None, None, None, None,	725	None, None, None, None,
726		726
727	None, None, None, None,	727	None, Below, None, None,
728	None, None, None, None,	728	None, None, None, None,
729	None, None, None, None,	729	None, None, None, None,
730	None, None, None, None,	730	None, None, None, None,
Lines 842-848 Link Here
842	None, None, None, None,	842	None, None, None, None,
843	None, None, Below, None,	843	None, None, Below, None,
844		844
845	None, None, None, None,	845	None, None, Below, Below,
846	None, None, None, None,	846	None, None, None, None,
847	None, None, None, None,	847	None, None, None, None,
848	None, None, None, None,	848	None, None, None, None,

Lines 1-12 Link Here

(-)qt-x11-commercial-3.3.8/src/moc/moc_yacc.cpp (-34 / +98 lines)
1	#ifndef lint	1	#ifndef lint
2	static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";	2	static char const
		3	yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28 2000/01/17 02:04:06 bde Exp $";
3	#endif	4	#endif
		5	#include <stdlib.h>
4	#define YYBYACC 1	6	#define YYBYACC 1
5	#define YYMAJOR 1	7	#define YYMAJOR 1
6	#define YYMINOR 9	8	#define YYMINOR 9
7	#define yyclearin (yychar=(-1))	9	#define YYLEX yylex()
		10	#define YYEMPTY -1
		11	#define yyclearin (yychar=(YYEMPTY))
8	#define yyerrok (yyerrflag=0)	12	#define yyerrok (yyerrflag=0)
9	#define YYRECOVERING (yyerrflag!=0)	13	#define YYRECOVERING() (yyerrflag!=0)
		14	static int yygrowstack();
10	#define YYPREFIX "yy"	15	#define YYPREFIX "yy"
11	#line 55 "moc.y"	16	#line 55 "moc.y"
12	#define MOC_YACC_CODE	17	#define MOC_YACC_CODE
Lines 649-655 Link Here
649	ArgList *arg_list;	654	ArgList *arg_list;
650	Argument *arg;	655	Argument *arg;
651	} YYSTYPE;	656	} YYSTYPE;
652	#line 653 "y.tab.c"	657	#line 658 "y.tab.c"
		658	#define YYERRCODE 256
653	#define CHAR_VAL 257	659	#define CHAR_VAL 257
654	#define INT_VAL 258	660	#define INT_VAL 258
655	#define DOUBLE_VAL 259	661	#define DOUBLE_VAL 259
Lines 704-711 Link Here
704	#define DESIGNABLE 308	710	#define DESIGNABLE 308
705	#define SCRIPTABLE 309	711	#define SCRIPTABLE 309
706	#define RESET 310	712	#define RESET 310
707	#define YYERRCODE 256	713	const short yylhs[] = { -1,
708	short yylhs[] = { -1,
709	0, 0, 40, 40, 40, 40, 40, 42, 42, 48,	714	0, 0, 40, 40, 40, 40, 40, 42, 42, 48,
710	50, 46, 51, 52, 47, 49, 43, 45, 44, 44,	715	50, 46, 51, 52, 47, 49, 43, 45, 44, 44,
711	54, 41, 1, 1, 2, 55, 56, 57, 58, 30,	716	54, 41, 1, 1, 2, 55, 56, 57, 58, 30,
Lines 740-746 Link Here
740	134, 134, 135, 136, 135, 138, 97, 137, 137, 137,	745	134, 134, 135, 136, 135, 138, 97, 137, 137, 137,
741	137, 137, 137, 137, 105, 105, 108, 108,	746	137, 137, 137, 137, 105, 105, 108, 108,
742	};	747	};
743	short yylen[] = { 2,	748	const short yylen[] = { 2,
744	0, 2, 1, 1, 1, 1, 1, 1, 1, 0,	749	0, 2, 1, 1, 1, 1, 1, 1, 1, 0,
745	0, 7, 0, 0, 6, 1, 5, 2, 2, 2,	750	0, 7, 0, 0, 6, 1, 5, 2, 2, 2,
746	0, 3, 1, 1, 4, 0, 0, 0, 0, 1,	751	0, 3, 1, 1, 4, 0, 0, 0, 0, 1,
Lines 775-781 Link Here
775	1, 3, 1, 0, 4, 0, 4, 0, 3, 3,	780	1, 3, 1, 0, 4, 0, 4, 0, 3, 3,
776	3, 3, 3, 3, 0, 2, 0, 2,	781	3, 3, 3, 3, 0, 2, 0, 2,
777	};	782	};
778	short yydefred[] = { 1,	783	const short yydefred[] = { 1,
779	0, 0, 0, 2, 3, 4, 5, 6, 7, 8,	784	0, 0, 0, 2, 3, 4, 5, 6, 7, 8,
780	9, 0, 0, 0, 19, 20, 18, 0, 0, 0,	785	9, 0, 0, 0, 19, 20, 18, 0, 0, 0,
781	0, 0, 0, 0, 0, 0, 14, 26, 140, 40,	786	0, 0, 0, 0, 0, 0, 14, 26, 140, 40,
Lines 826-832 Link Here
826	28, 96, 102, 27, 156, 79, 0, 131, 0, 128,	831	28, 96, 102, 27, 156, 79, 0, 131, 0, 128,
827	105, 129, 89, 0, 151, 0, 0, 158, 132, 130,	832	105, 129, 89, 0, 151, 0, 0, 158, 132, 130,
828	};	833	};
829	short yydgoto[] = { 93,	834	const short yydgoto[] = { 93,
830	53, 54, 162, 64, 65, 85, 86, 87, 88, 163,	835	53, 54, 162, 64, 65, 85, 86, 87, 88, 163,
831	164, 165, 166, 167, 168, 69, 169, 48, 318, 319,	836	164, 165, 166, 167, 168, 69, 169, 48, 318, 319,
832	320, 365, 366, 321, 477, 302, 303, 304, 322, 170,	837	320, 365, 366, 321, 477, 302, 303, 304, 322, 170,
Lines 842-848 Link Here
842	180, 181, 245, 376, 182, 315, 402, 377, 441, 416,	847	180, 181, 245, 376, 182, 315, 402, 377, 441, 416,
843	324, 199, 344, 270, 271, 395, 385, 329,	848	324, 199, 344, 270, 271, 395, 385, 329,
844	};	849	};
845	short yysindex[] = { 0,	850	const short yysindex[] = { 0,
846	70, -206, -111, 0, 0, 0, 0, 0, 0, 0,	851	70, -206, -111, 0, 0, 0, 0, 0, 0, 0,
847	0, -220, 41, 10, 0, 0, 0, 67, 912, -96,	852	0, -220, 41, 10, 0, 0, 0, 67, 912, -96,
848	152, 124, 91, 559, -81, 98, 0, 0, 0, 0,	853	152, 124, 91, 559, -81, 98, 0, 0, 0, 0,
Lines 893-899 Link Here
893	0, 0, 0, 0, 0, 0, 991, 0, 799, 0,	898	0, 0, 0, 0, 0, 0, 991, 0, 799, 0,
894	0, 0, 0, 1015, 0, 936, 1004, 0, 0, 0,	899	0, 0, 0, 1015, 0, 936, 1004, 0, 0, 0,
895	};	900	};
896	short yyrindex[] = { 0,	901	const short yyrindex[] = { 0,
897	330, 941, 0, 0, 0, 0, 0, 0, 0, 0,	902	330, 941, 0, 0, 0, 0, 0, 0, 0, 0,
898	0, 199, 943, 0, 0, 0, 0, 0, 373, 0,	903	0, 199, 943, 0, 0, 0, 0, 0, 373, 0,
899	0, 0, 0, 5, 0, 0, 0, 0, 0, 0,	904	0, 0, 0, 5, 0, 0, 0, 0, 0, 0,
Lines 944-950 Link Here
944	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	949	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
945	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	950	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
946	};	951	};
947	short yygindex[] = { 1152,	952	const short yygindex[] = { 1152,
948	347, 0, 1150, 930, 0, 0, 435, 1056, 449, 283,	953	347, 0, 1150, 930, 0, 0, 435, 1056, 449, 283,
949	-135, 0, 57, -11, -25, 122, 0, 0, 0, 0,	954	-135, 0, 57, -11, -25, 122, 0, 0, 0, 0,
950	0, 765, 810, -294, 0, -159, 0, 892, 0, -10,	955	0, 765, 810, -294, 0, -159, 0, 892, 0, -10,
Lines 961-967 Link Here
961	0, 0, 931, 1005, 974, 0, 856, 0,	966	0, 0, 931, 1005, 974, 0, 856, 0,
962	};	967	};
963	#define YYTABLESIZE 1510	968	#define YYTABLESIZE 1510
964	short yytable[] = { 68,	969	const short yytable[] = { 68,
965	20, 226, 218, 77, 63, 225, 90, 228, 123, 90,	970	20, 226, 218, 77, 63, 225, 90, 228, 123, 90,
966	123, 123, 123, 90, 123, 149, 90, 84, 372, 122,	971	123, 123, 123, 90, 123, 149, 90, 84, 372, 122,
967	84, 122, 122, 122, 87, 122, 90, 87, 123, 123,	972	84, 122, 122, 122, 87, 122, 90, 87, 123, 123,
Lines 1114-1120 Link Here
1114	154, 155, 30, 31, 32, 33, 34, 35, 36, 37,	1119	154, 155, 30, 31, 32, 33, 34, 35, 36, 37,
1115	0, 38, 39, 40, 41, 42, 43, 44, 45, 46,	1120	0, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1116	};	1121	};
1117	short yycheck[] = { 25,	1122	const short yycheck[] = { 25,
1118	12, 38, 159, 41, 58, 42, 41, 164, 38, 44,	1123	12, 38, 159, 41, 58, 42, 41, 164, 38, 44,
1119	40, 41, 42, 41, 44, 58, 44, 41, 40, 38,	1124	40, 41, 42, 41, 44, 58, 44, 41, 40, 38,
1120	44, 40, 41, 42, 41, 44, 61, 44, 58, 59,	1125	44, 40, 41, 42, 41, 44, 61, 44, 58, 59,
Lines 1273-1279 Link Here
1273	#endif	1278	#endif
1274	#define YYMAXTOKEN 310	1279	#define YYMAXTOKEN 310
1275	#if YYDEBUG	1280	#if YYDEBUG
1276	char *yyname[] = {	1281	const char * const yyname[] = {
1277	"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	1282	"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1278	"'!'",0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,	1283	"'!'",0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,
1279	0,0,0,0,0,"':'","';'","'<'","'='","'>'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	1284	0,0,0,0,0,"':'","';'","'<'","'='","'>'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
Lines 1290-1296 Link Here
1290	"Q_OBJECT","Q_PROPERTY","Q_OVERRIDE","Q_CLASSINFO","Q_ENUMS","Q_SETS","READ",	1295	"Q_OBJECT","Q_PROPERTY","Q_OVERRIDE","Q_CLASSINFO","Q_ENUMS","Q_SETS","READ",
1291	"WRITE","STORED","DESIGNABLE","SCRIPTABLE","RESET",	1296	"WRITE","STORED","DESIGNABLE","SCRIPTABLE","RESET",
1292	};	1297	};
1293	char *yyrule[] = {	1298	const char * const yyrule[] = {
1294	"$accept : declaration_seq",	1299	"$accept : declaration_seq",
1295	"declaration_seq :",	1300	"declaration_seq :",
1296	"declaration_seq : declaration_seq declaration",	1301	"declaration_seq : declaration_seq declaration",
Lines 1622-1627 Link Here
1622	"qt_sets : IDENTIFIER qt_sets",	1627	"qt_sets : IDENTIFIER qt_sets",
1623	};	1628	};
1624	#endif	1629	#endif
		1630	#if YYDEBUG
		1631	#include <stdio.h>
		1632	#endif
1625	#ifdef YYSTACKSIZE	1633	#ifdef YYSTACKSIZE
1626	#undef YYMAXDEPTH	1634	#undef YYMAXDEPTH
1627	#define YYMAXDEPTH YYSTACKSIZE	1635	#define YYMAXDEPTH YYSTACKSIZE
Lines 1629-1638 Link Here
1629	#ifdef YYMAXDEPTH	1637	#ifdef YYMAXDEPTH
1630	#define YYSTACKSIZE YYMAXDEPTH	1638	#define YYSTACKSIZE YYMAXDEPTH
1631	#else	1639	#else
1632	#define YYSTACKSIZE 500	1640	#define YYSTACKSIZE 10000
1633	#define YYMAXDEPTH 500	1641	#define YYMAXDEPTH 10000
1634	#endif	1642	#endif
1635	#endif	1643	#endif
		1644	#define YYINITSTACKSIZE 200
1636	int yydebug;	1645	int yydebug;
1637	int yynerrs;	1646	int yynerrs;
1638	int yyerrflag;	1647	int yyerrflag;
Lines 1641-1649 Link Here
1641	YYSTYPE *yyvsp;	1650	YYSTYPE *yyvsp;
1642	YYSTYPE yyval;	1651	YYSTYPE yyval;
1643	YYSTYPE yylval;	1652	YYSTYPE yylval;
1644	short yyss[YYSTACKSIZE];	1653	short *yyss;
1645	YYSTYPE yyvs[YYSTACKSIZE];	1654	short *yysslim;
1646	#define yystacksize YYSTACKSIZE	1655	YYSTYPE *yyvs;
		1656	int yystacksize;
1647	#line 1606 "moc.y"	1657	#line 1606 "moc.y"
1648		1658
1649	#ifndef YYBISON	1659	#ifndef YYBISON
Lines 2873-2879 Link Here
2873	const char hdr1 = "/***************************************************************************\n"	2883	const char hdr1 = "/***************************************************************************\n"
2874	" %s meta object code from reading C++ file '%s'\n\n";	2884	" %s meta object code from reading C++ file '%s'\n\n";
2875	const char hdr2 = "* Created: %s\n"	2885	const char hdr2 = "* Created: %s\n"
2876	" by: The Qt MOC ($Id: qt/moc_yacc.cpp 3.3.8 edited Feb 2 14:59 $)\n\n";	2886	" by: The Qt MOC ($Id: qt/moc_yacc.cpp 3.3.8 edited Mar 23 02:24 $)\n\n";
2877	const char hdr3 = "* WARNING! All changes made in this file will be lost!\n";	2887	const char hdr3 = "* WARNING! All changes made in this file will be lost!\n";
2878	const char hdr4 = "****************************************************************************/\n\n";	2888	const char hdr4 = "****************************************************************************/\n\n";
2879	int i;	2889	int i;
Lines 3645-3664 Link Here
3645	return;	3655	return;
3646	}	3656	}
3647	}	3657	}
3648	#line 3649 "y.tab.c"	3658	#line 3659 "y.tab.c"
		3659	/* allocate initial stack or double stack size, up to YYMAXDEPTH */
		3660	static int yygrowstack()
		3661	{
		3662	int newsize, i;
		3663	short *newss;
		3664	YYSTYPE *newvs;
		3665
		3666	if ((newsize = yystacksize) == 0)
		3667	newsize = YYINITSTACKSIZE;
		3668	else if (newsize >= YYMAXDEPTH)
		3669	return -1;
		3670	else if ((newsize *= 2) > YYMAXDEPTH)
		3671	newsize = YYMAXDEPTH;
		3672	i = yyssp - yyss;
		3673	newss = yyss ? (short )realloc(yyss, newsize sizeof *newss) :
		3674	(short )malloc(newsize sizeof *newss);
		3675	if (newss == NULL)
		3676	return -1;
		3677	yyss = newss;
		3678	yyssp = newss + i;
		3679	newvs = yyvs ? (YYSTYPE )realloc(yyvs, newsize sizeof *newvs) :
		3680	(YYSTYPE )malloc(newsize sizeof *newvs);
		3681	if (newvs == NULL)
		3682	return -1;
		3683	yyvs = newvs;
		3684	yyvsp = newvs + i;
		3685	yystacksize = newsize;
		3686	yysslim = yyss + newsize - 1;
		3687	return 0;
		3688	}
		3689
3649	#define YYABORT goto yyabort	3690	#define YYABORT goto yyabort
3650	#define YYREJECT goto yyabort	3691	#define YYREJECT goto yyabort
3651	#define YYACCEPT goto yyaccept	3692	#define YYACCEPT goto yyaccept
3652	#define YYERROR goto yyerrlab	3693	#define YYERROR goto yyerrlab
		3694
		3695	#ifndef YYPARSE_PARAM
		3696	#if defined(__cplusplus) \|\| __STDC__
		3697	#define YYPARSE_PARAM_ARG void
		3698	#define YYPARSE_PARAM_DECL
		3699	#else /* ! ANSI-C/C++ */
		3700	#define YYPARSE_PARAM_ARG
		3701	#define YYPARSE_PARAM_DECL
		3702	#endif /* ANSI-C/C++ */
		3703	#else /* YYPARSE_PARAM */
		3704	#ifndef YYPARSE_PARAM_TYPE
		3705	#define YYPARSE_PARAM_TYPE void *
		3706	#endif
		3707	#if defined(__cplusplus) \|\| __STDC__
		3708	#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
		3709	#define YYPARSE_PARAM_DECL
		3710	#else /* ! ANSI-C/C++ */
		3711	#define YYPARSE_PARAM_ARG YYPARSE_PARAM
		3712	#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
		3713	#endif /* ANSI-C/C++ */
		3714	#endif /* ! YYPARSE_PARAM */
		3715
3653	int	3716	int
3654	yyparse()	3717	yyparse (YYPARSE_PARAM_ARG)
		3718	YYPARSE_PARAM_DECL
3655	{	3719	{
3656	register int yym, yyn, yystate;	3720	register int yym, yyn, yystate;
3657	#if YYDEBUG	3721	#if YYDEBUG
3658	register char *yys;	3722	register const char *yys;
3659	extern char *getenv();
3660		3723
3661	if (yys = getenv("YYDEBUG"))	3724	if ((yys = getenv("YYDEBUG")))
3662	{	3725	{
3663	yyn = *yys;	3726	yyn = *yys;
3664	if (yyn >= '0' && yyn <= '9')	3727	if (yyn >= '0' && yyn <= '9')
Lines 3670-3681 Link Here
3670	yyerrflag = 0;	3733	yyerrflag = 0;
3671	yychar = (-1);	3734	yychar = (-1);
3672		3735
		3736	if (yyss == NULL && yygrowstack()) goto yyoverflow;
3673	yyssp = yyss;	3737	yyssp = yyss;
3674	yyvsp = yyvs;	3738	yyvsp = yyvs;
3675	*yyssp = yystate = 0;	3739	*yyssp = yystate = 0;
3676		3740
3677	yyloop:	3741	yyloop:
3678	if (yyn = yydefred[yystate]) goto yyreduce;	3742	if ((yyn = yydefred[yystate])) goto yyreduce;
3679	if (yychar < 0)	3743	if (yychar < 0)
3680	{	3744	{
3681	if ((yychar = yylex()) < 0) yychar = 0;	3745	if ((yychar = yylex()) < 0) yychar = 0;
Lines 3698-3704 Link Here
3698	printf("%sdebug: state %d, shifting to state %d\n",	3762	printf("%sdebug: state %d, shifting to state %d\n",
3699	YYPREFIX, yystate, yytable[yyn]);	3763	YYPREFIX, yystate, yytable[yyn]);
3700	#endif	3764	#endif
3701	if (yyssp >= yyss + yystacksize - 1)	3765	if (yyssp >= yysslim && yygrowstack())
3702	{	3766	{
3703	goto yyoverflow;	3767	goto yyoverflow;
3704	}	3768	}
Lines 3715-3726 Link Here
3715	goto yyreduce;	3779	goto yyreduce;
3716	}	3780	}
3717	if (yyerrflag) goto yyinrecovery;	3781	if (yyerrflag) goto yyinrecovery;
3718	#ifdef lint	3782	#if defined(lint) \|\| defined(__GNUC__)
3719	goto yynewerror;	3783	goto yynewerror;
3720	#endif	3784	#endif
3721	yynewerror:	3785	yynewerror:
3722	yyerror("syntax error");	3786	yyerror("syntax error");
3723	#ifdef lint	3787	#if defined(lint) \|\| defined(__GNUC__)
3724	goto yyerrlab;	3788	goto yyerrlab;
3725	#endif	3789	#endif
3726	yyerrlab:	3790	yyerrlab:
Lines 3739-3745 Link Here
3739	printf("%sdebug: state %d, error recovery shifting\	3803	printf("%sdebug: state %d, error recovery shifting\
3740	to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);	3804	to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
3741	#endif	3805	#endif
3742	if (yyssp >= yyss + yystacksize - 1)	3806	if (yyssp >= yysslim && yygrowstack())
3743	{	3807	{
3744	goto yyoverflow;	3808	goto yyoverflow;
3745	}	3809	}
Lines 4755-4761 Link Here
4755	#line 1602 "moc.y"	4819	#line 1602 "moc.y"
4756	{ g->qtSets.append( yyvsp[-1].string ); }	4820	{ g->qtSets.append( yyvsp[-1].string ); }
4757	break;	4821	break;
4758	#line 4759 "y.tab.c"	4822	#line 4823 "y.tab.c"
4759	}	4823	}
4760	yyssp -= yym;	4824	yyssp -= yym;
4761	yystate = *yyssp;	4825	yystate = *yyssp;
Lines 4798-4804 Link Here
4798	printf("%sdebug: after reduction, shifting from state %d \	4862	printf("%sdebug: after reduction, shifting from state %d \
4799	to state %d\n", YYPREFIX, *yyssp, yystate);	4863	to state %d\n", YYPREFIX, *yyssp, yystate);
4800	#endif	4864	#endif
4801	if (yyssp >= yyss + yystacksize - 1)	4865	if (yyssp >= yysslim && yygrowstack())
4802	{	4866	{
4803	goto yyoverflow;	4867	goto yyoverflow;
4804	}	4868	}