QWidget *wid = 0;

delete wid;

is legal c++ code.
So make sure when freeing we obey c++ but take into
account that free(NULL) is not legal.

1 files changed, 8 insertions, 4 deletions

diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
index 43a9be5..af00f49 100644
--- a/library/qpeapplication.cpp
+++ b/library/qpeapplication.cpp
@@ -1762,557 +1762,561 @@ void QPEApplication::pidMessage( const QCString& msg, const QByteArray& data)
                 raiseAppropriateWindow();
                 if ( !p ) {
                     // Tell the system we're still chugging along...
 #ifndef QT_NO_COP
                     QCopEnvelope e("QPE/System", "appRaised(QString)");
                     e << d->appName;
 #endif
                 }
             }
             if ( p )
                 d->keep_running = p;
     }
 #endif
 }
 
 
 /*!
   Sets widget \a mw as the mainWidget() and shows it. For small windows,
   consider passing TRUE for \a nomaximize rather than the default FALSE.
 
   \sa showMainDocumentWidget()
 */
 void QPEApplication::showMainWidget( QWidget* mw, bool nomaximize )
 {
 //        setMainWidget(mw); this breaks FastLoading because lastWindowClose() would quit
             d->show(mw, nomaximize );
 }
 
 /*!
   Sets widget \a mw as the mainWidget() and shows it. For small windows,
   consider passing TRUE for \a nomaximize rather than the default FALSE.
 
   This calls designates the application as
   a \link docwidget.html document-oriented\endlink application.
 
   The \a mw widget \e must have this slot: setDocument(const QString&).
 
   \sa showMainWidget()
 */
 void QPEApplication::showMainDocumentWidget( QWidget* mw, bool nomaximize )
 {
     if ( mw && argc() == 2 )
         Global::setDocument( mw, QString::fromUtf8(argv()[1]) );
 
 
 //    setMainWidget(mw); see above
     d->show(mw, nomaximize );
 }
 
 
 /*!
   If an application is started via a \link qcop.html QCop\endlink
   message, the application will process the \link qcop.html
   QCop\endlink message and then quit. If the application calls this
   function while processing a \link qcop.html QCop\endlink message,
   after processing its outstanding \link qcop.html QCop\endlink
   messages the application will start 'properly' and show itself.
 
   \sa keepRunning()
 */
 void QPEApplication::setKeepRunning()
 {
     if ( qApp && qApp->inherits( "QPEApplication" ) ) {
         QPEApplication * qpeApp = ( QPEApplication* ) qApp;
         qpeApp->d->keep_running = TRUE;
     }
 }
 
 /*!
   Returns TRUE if the application will quit after processing the
   current list of qcop messages; otherwise returns FALSE.
 
   \sa setKeepRunning()
 */
 bool QPEApplication::keepRunning() const
 {
     return d->keep_running;
 }
 
 /*!
   \internal
 */
 void QPEApplication::internalSetStyle( const QString &style )
 {
 #if QT_VERSION >= 300
     if ( style == "QPE" ) {
         setStyle( new QPEStyle );
     }
     else {
         QStyle *s = QStyleFactory::create( style );
         if ( s )
             setStyle( s );
     }
 #else
     if ( style == "Windows" ) {
         setStyle( new QWindowsStyle );
     }
     else if ( style == "QPE" ) {
         setStyle( new QPEStyle );
     }
     else if ( style == "Light" ) {
         setStyle( new LightStyle );
     }
 #ifndef QT_NO_STYLE_PLATINUM
     else if ( style == "Platinum" ) {
         setStyle( new QPlatinumStyle );
     }
 #endif
 #ifndef QT_NO_STYLE_MOTIF
     else if ( style == "Motif" ) {
         setStyle( new QMotifStyle );
     }
 #endif
 #ifndef QT_NO_STYLE_MOTIFPLUS
     else if ( style == "MotifPlus" ) {
         setStyle( new QMotifPlusStyle );
     }
 #endif
 
     else {
         QStyle *sty = 0;
         QString path = QPEApplication::qpeDir ( ) + "plugins/styles/";
 
 #ifdef Q_OS_MACX
         if ( style. find ( ".dylib" ) > 0 )
             path += style;
         else
             path = path + "lib" + style. lower ( ) + ".dylib"; // compatibility
 #else
         if ( style. find ( ".so" ) > 0 )
             path += style;
         else
             path = path + "lib" + style. lower ( ) + ".so"; // compatibility
 #endif
         static QLibrary *lastlib = 0;
         static StyleInterface *lastiface = 0;
 
         QLibrary *lib = new QLibrary ( path );
         StyleInterface *iface = 0;
 
         if (( lib-> queryInterface ( IID_Style, ( QUnknownInterface ** ) &iface ) == QS_OK ) && iface )
             sty = iface-> style ( );
 
         if ( sty ) {
             setStyle ( sty );
 
             if ( lastiface )
                 lastiface-> release ( );
             lastiface = iface;
 
             if ( lastlib ) {
                 lastlib-> unload ( );
                 delete lastlib;
             }
             lastlib = lib;
         }
         else {
             if ( iface )
                 iface-> release ( );
             delete lib;
 
             setStyle ( new LightStyle ( ));
         }
     }
 #endif
 }
 
 /*!
   \internal
 */
 void QPEApplication::prepareForTermination( bool willrestart )
 {
     if ( willrestart ) {
         QLabel *lblWait = new QLabel( tr( "Please wait..." ), 0, "wait hack", QWidget::WStyle_Customize |
                                       QWidget::WStyle_NoBorder | QWidget::WStyle_Tool );
         lblWait->setAlignment( QWidget::AlignCenter );
         lblWait->show();
         lblWait->showMaximized();
     }
     { QCopEnvelope envelope( "QPE/System", "forceQuit()" );
     }
     processEvents(); // ensure the message goes out.
 }
 
 /*!
   \internal
 */
 void QPEApplication::shutdown()
 {
     // Implement in server's QPEApplication subclass
 }
 
 /*!
   \internal
 */
 void QPEApplication::restart()
 {
     // Implement in server's QPEApplication subclass
 }
 
 static QPtrDict<void>* stylusDict = 0;
 static void createDict()
 {
     if ( !stylusDict )
         stylusDict = new QPtrDict<void>;
 }
 
 /*!
   Returns the current StylusMode for widget \a w.
 
   \sa setStylusOperation() StylusMode
 */
 QPEApplication::StylusMode QPEApplication::stylusOperation( QWidget* w )
 {
     if ( stylusDict )
         return ( StylusMode ) ( int ) stylusDict->find( w );
     return LeftOnly;
 }
 
 /*!
     \enum QPEApplication::StylusMode
 
     \value LeftOnly the stylus only generates LeftButton
                        events (the default).
     \value RightOnHold the stylus generates RightButton events
                        if the user uses the press-and-hold gesture.
 
     \sa setStylusOperation() stylusOperation()
 */
 
 /*!
   Causes widget \a w to receive mouse events according to the stylus
   \a mode.
 
   \sa stylusOperation() StylusMode
 */
 void QPEApplication::setStylusOperation( QWidget * w, StylusMode mode )
 {
     createDict();
     if ( mode == LeftOnly ) {
         stylusDict->remove
         ( w );
         w->removeEventFilter( qApp );
     }
     else {
         stylusDict->insert( w, ( void* ) mode );
         connect( w, SIGNAL( destroyed() ), qApp, SLOT( removeSenderFromStylusDict() ) );
         w->installEventFilter( qApp );
     }
 }
 
 
 /*!
   \reimp
 */
 bool QPEApplication::eventFilter( QObject *o, QEvent *e )
 {
         if ( !o->isWidgetType() )
             return FALSE;
 
     if ( stylusDict && e->type() >= QEvent::MouseButtonPress && e->type() <= QEvent::MouseMove ) {
         QMouseEvent * me = ( QMouseEvent* ) e;
         StylusMode mode = (StylusMode)(int)stylusDict->find(o);
         switch (mode) {
             case RightOnHold:
                 switch ( me->type() ) {
                     case QEvent::MouseButtonPress:
                         if ( me->button() == LeftButton ) {
                             static long Pref = 500; // #### pref.
                             d->presswidget = (QWidget*)o;
                             d->presspos = me->pos();
                             d->rightpressed = FALSE;
 #ifdef OPIE_WITHROHFEEDBACK
                             if( ! d->RoH )
                               d->RoH = new Opie::Internal::RoHFeedback;
 
                             d->RoH->init( me->globalPos(), d->presswidget );
                             Pref = d->RoH->delay();
 
 #endif
                             if (!d->presstimer )
                                 d->presstimer = startTimer( Pref ); // #### pref.
 
                         }
                         break;
                     case QEvent::MouseMove:
                         if (d->presstimer && (me->pos() - d->presspos).manhattanLength() > 8) {
                             killTimer(d->presstimer);
 #ifdef OPIE_WITHROHFEEDBACK
                             d->RoH->stop();
 #endif
                             d->presstimer = 0;
                         }
                         break;
                     case QEvent::MouseButtonRelease:
                         if ( me->button() == LeftButton ) {
                             if ( d->presstimer ) {
                                 killTimer(d->presstimer);
 #ifdef OPIE_WITHROHFEEDBACK
                                 d->RoH->stop( );
 #endif
                                 d->presstimer = 0;
                             }
                             if ( d->rightpressed && d->presswidget ) {
                               printf( "Send ButtonRelease\n" );
                                 // Right released
                                 postEvent( d->presswidget,
                                            new QMouseEvent( QEvent::MouseButtonRelease, me->pos(),
                                                             RightButton, LeftButton + RightButton ) );
                                 // Left released, off-widget
                                 postEvent( d->presswidget,
                                            new QMouseEvent( QEvent::MouseMove, QPoint( -1, -1),
                                                             LeftButton, LeftButton ) );
                                 postEvent( d->presswidget,
                                            new QMouseEvent( QEvent::MouseButtonRelease, QPoint( -1, -1),
                                                             LeftButton, LeftButton ) );
                                 d->rightpressed = FALSE;
                                 return TRUE; // don't send the real Left release
                             }
                         }
                         break;
                     default:
                         break;
                 }
                 break;
             default:
                 ;
         }
     }
     else if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
         QKeyEvent *ke = (QKeyEvent *)e;
         if ( ke->key() == Key_Enter ) {
             if ( o->isA( "QRadioButton" ) || o->isA( "QCheckBox" ) ) {
                 postEvent( o, new QKeyEvent( e->type(), Key_Space, ' ',
                                              ke->state(), " ", ke->isAutoRepeat(), ke->count() ) );
                 return TRUE;
             }
         }
     }
     return FALSE;
 }
 
 /*!
   \reimp
 */
 void QPEApplication::timerEvent( QTimerEvent *e )
 {
     if ( e->timerId() == d->presstimer && d->presswidget ) {
 
           // Right pressed
           postEvent( d->presswidget,
                      new QMouseEvent( QEvent::MouseButtonPress, d->presspos,
                                       RightButton, LeftButton ) );
           killTimer( d->presstimer );
           d->presstimer = 0;
           d->rightpressed = TRUE;
 #ifdef OPIE_WITHROHFEEDBACK
           d->RoH->stop();
 #endif
     }
 }
 
 void QPEApplication::removeSenderFromStylusDict()
 {
     stylusDict->remove
     ( ( void* ) sender() );
     if ( d->presswidget == sender() )
         d->presswidget = 0;
 }
 
 /*!
   \internal
 */
 bool QPEApplication::keyboardGrabbed() const
 {
     return d->kbgrabbed;
 }
 
 
 /*!
   Reverses the effect of grabKeyboard(). This is called automatically
   on program exit.
 */
 void QPEApplication::ungrabKeyboard()
 {
     ((QPEApplication *) qApp )-> d-> kbgrabbed = false;
 }
 
 /*!
   Grabs the physical keyboard keys, e.g. the application's launching
   keys. Instead of launching applications when these keys are pressed
   the signals emitted are sent to this application instead. Some games
   programs take over the launch keys in this way to make interaction
   easier.
 
   \sa ungrabKeyboard()
 */
 void QPEApplication::grabKeyboard()
 {
     ((QPEApplication *) qApp )-> d-> kbgrabbed = true;
 }
 
 /*!
   \reimp
 */
 int QPEApplication::exec()
 {
         d->qcopQok = true;
 #ifndef QT_NO_COP
     d->sendQCopQ();
         if ( !d->keep_running )
             processEvents(); // we may have received QCop messages in the meantime.
 #endif
 
     if ( d->keep_running )
         //|| d->qpe_main_widget && d->qpe_main_widget->isVisible() )
         return QApplication::exec();
 
 #ifndef QT_NO_COP
 
     {
         QCopEnvelope e( "QPE/System", "closing(QString)" );
         e << d->appName;
     }
 #endif
     processEvents();
     return 0;
 }
 
 /*!
   \internal
   External request for application to quit.  Quits if possible without
   loosing state.
 */
 void QPEApplication::tryQuit()
 {
     if ( activeModalWidget() )
         return ; // Inside modal loop or konsole. Too hard to save state.
 #ifndef QT_NO_COP
 
     {
         QCopEnvelope e( "QPE/System", "closing(QString)" );
         e << d->appName;
     }
 #endif
     if ( d->keep_running )
     d->store_widget_rect(d->qpe_main_widget, d->appName);
     processEvents();
 
     quit();
 }
 
 
 /*!
   \internal
   User initiated quit.  Makes the window 'Go Away'.  If preloaded this means
   hiding the window.  If not it means quitting the application.
   As this is user initiated we don't need to check state.
 */
 void QPEApplication::hideOrQuit()
 {
     if ( d->keep_running )
     d->store_widget_rect(d->qpe_main_widget, d->appName);
     processEvents();
 
     // If we are a preloaded application we don't actually quit, so emit
     // a System message indicating we're quasi-closing.
     if ( d->preloaded && d->qpe_main_widget )
 #ifndef QT_NO_COP
 
     {
         QCopEnvelope e("QPE/System", "fastAppHiding(QString)" );
         e << d->appName;
         d->qpe_main_widget->hide();
     }
 #endif
     else
         quit();
 }
 
 #if (__GNUC__ > 2 )
 extern "C" void __cxa_pure_virtual();
 
 void __cxa_pure_virtual()
 {
     fprintf( stderr, "Pure virtual called\n");
     abort();
 
 }
 
 #endif
 
 
 #if defined(OPIE_NEW_MALLOC)
 
 // The libraries with the skiff package (and possibly others) have
 // completely useless implementations of builtin new and delete that
 // use about 50% of your CPU. Here we revert to the simple libc
 // functions.
 
 void* operator new[]( size_t size )
 {
     return malloc( size );
 }
 
 void* operator new( size_t size )
 {
     return malloc( size );
 }
 
 void operator delete[]( void* p )
 {
-    free( p );
+    if ( p )
+        free( p );
 }
 
 void operator delete[]( void* p, size_t /*size*/ )
 {
-    free( p );
+    if ( p )
+        free( p );
 }
 
 
 void operator delete( void* p )
 {
-    free( p );
+    if ( p )
+        free( p );
 }
 
 void operator delete( void* p, size_t /*size*/ )
 {
-    free( p );
+    if ( p )
+        free( p );
 }
 
 #endif
 
 #if ( QT_VERSION <= 230 ) && !defined(SINGLE_APP)
 #include <qwidgetlist.h>
 #ifdef QWS
 #include <qgfx_qws.h>
 extern QRect qt_maxWindowRect;
 void qt_setMaxWindowRect(const QRect& r )
 {
     qt_maxWindowRect = qt_screen->mapFromDevice( r,
                        qt_screen->mapToDevice( QSize( qt_screen->width(), qt_screen->height() ) ) );
     // Re-resize any maximized windows
     QWidgetList* l = QApplication::topLevelWidgets();
     if ( l ) {
         QWidget * w = l->first();
         while ( w ) {
             if ( w->isVisible() && w->isMaximized() ) {
                 w->showMaximized();
             }
             w = l->next();
         }
         delete l;
     }
 }
 #endif
 #endif