Each file in this commit had a problem where a function might return

a null value for a pointer and that null value was not checked.

1 files changed, 3 insertions, 1 deletions

diff --git a/noncore/games/minesweep/minefield.cpp b/noncore/games/minesweep/minefield.cpp
index 72c05b0..1987ea5 100644
--- a/noncore/games/minesweep/minefield.cpp
+++ b/noncore/games/minesweep/minefield.cpp
@@ -515,233 +515,235 @@ void MineField::held()
     updateMine( currRow, currCol );
     ignoreClick = TRUE;
 }
 
 
 
 
 void MineField::keyPressEvent( QKeyEvent* e )
 {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
     flagAction = ( e->key() == Key_Up ) ? FlagOn : NoAction;
 #else
     flagAction = ( ( e->state() & ShiftButton ) ==  ShiftButton ) ? FlagOn : NoAction;
 #endif
 }
 
 void MineField::keyReleaseEvent( QKeyEvent* )
 {
     flagAction = NoAction;
 }
 
 int MineField::getHint( int row, int col )
 {
     int hint = 0;
     for ( int c = col-1; c <= col+1; c++ )
         for ( int r = row-1; r <= row+1; r++ ) {
             Mine* m = mine( r, c );
             if ( m && m->isMined() )
                 hint++;
         }
 
     return hint;
 }
 
 void MineField::setHint( int row, int col )
 {
     Mine *m = mine( row, col );
     if ( !m )
         return;
 
     int hint = getHint( row, col );
 
     if ( !hint ) {
         for ( int c = col-1; c <= col+1; c++ )
             for ( int r = row-1; r <= row+1; r++ ) {
                 Mine* m = mine( r, c );
                 if ( m && m->state() == Mine::Hidden ) {
                     m->activate( TRUE );
                     nonminecount--;
                     setHint( r, c );
                     updateCell( r, c );
                 }
             }
     }
 
     m->setHint( hint );
     updateCell( row, col );
 }
 
 /*
   Only place mines after first click, since it is pointless to
   kill the player before the game has started.
 */
 
 void MineField::cellClicked( int row, int col )
 {
     if ( state() == GameOver )
         return;
     if ( state() == Waiting ) {
         Mine* m = mine( row, col );
         if ( !m )
             return;
         m->setState( Mine::Empty );
         nonminecount--;
         placeMines();
         setState( Playing );
         emit gameStarted();
         updateMine( row, col );
     } else { // state() == Playing
         holdTimer->stop();
         if ( ignoreClick )
             ignoreClick = FALSE;
         else
             updateMine( row, col );
     }
 }
 
 void MineField::updateMine( int row, int col )
 {
     Mine* m = mine( row, col );
     if ( !m )
         return;
 
     bool wasFlagged = m->state() == Mine::Flagged;
     bool wasEmpty =  m->state() == Mine::Empty;
     
     m->activate( flagAction == NoAction );
 
     if ( m->state() == Mine::Exploded ) {
         emit gameOver( FALSE );
         setState( GameOver );
         return;
     } else if ( m->state() == Mine::Empty ) {
         setHint( row, col );
         if ( !wasEmpty )
             nonminecount--;
     }
 
     if ( flagAction != NoAction ) {
         if ( m->state() == Mine::Flagged ) {
             if (mineguess > 0) {
                 --mineguess;
                 emit mineCount( mineguess );
                 if ( m->isMined() )
                     --minecount;
             } else {
                 m->setState(Mine::Hidden);
             }
         } else if ( wasFlagged ) {
             ++mineguess;
             emit mineCount( mineguess );
             if ( m->isMined() )
                 ++minecount;
         }
     }
 
     updateCell( row, col );
 
     if ( !minecount && !mineguess || !nonminecount ) {
         emit gameOver( TRUE );
         setState( GameOver );
     }
 }
 
 void MineField::showMines()
 {
     for ( int c = 0; c < numCols; c++ )
         for ( int r = 0; r < numRows; r++ ) {
             Mine* m = mine( r, c );
             if ( !m )
                 continue;
             if ( m->isMined() && m->state() == Mine::Hidden )
                 m->setState( Mine::Mined );
             if ( !m->isMined() && m->state() == Mine::Flagged )
                 m->setState( Mine::Wrong );
 
             updateCell( r, c );
         }
 }
 
 void MineField::paletteChange( const QPalette &o )
 {
     Mine::paletteChange();
     QScrollView::paletteChange( o );
 }
 
 void MineField::writeConfig(Config& cfg) const
 {
     cfg.setGroup("Field");
     cfg.writeEntry("Level",lev);
     QString grid="";
     if ( stat == Playing ) {
         for ( int x = 0; x < numCols; x++ )
             for ( int y = 0; y < numRows; y++ ) {
                 char code='A'+(x*17+y*101)%21; // Reduce the urge to cheat
                 const Mine* m = mine( y, x );
                 int st = (int)m->state(); if ( m->isMined() ) st+=5;
                 grid += code + st;
             }
     }
     cfg.writeEntry("Grid",grid);
 }
 
 void MineField::readConfig(Config& cfg)
 {
     cfg.setGroup("Field");
     lev = cfg.readNumEntry("Level",1);
     setup(lev);
     flagAction = NoAction;
     ignoreClick = FALSE;
     currRow = currCol = 0;
     QString grid = cfg.readEntry("Grid");
     int x;
     if ( !grid.isEmpty() ) {
         int i=0;
         minecount=0;
         mineguess=0;
         for ( x = 0; x < numCols; x++ ) {
             for ( int y = 0; y < numRows; y++ ) {
                 char code='A'+(x*17+y*101)%21; // Reduce the urge to cheat
                 int st = (char)(QChar)grid[i++]-code;
                 Mine* m = mine( y, x );
+                if (!m)
+                    continue;
                 if ( st >= 5 ) {
                     st-=5;
                     m->setMined(TRUE);
                     minecount++;
                     mineguess++;
                 }
                 m->setState((Mine::MineState)st);
                 switch ( m->state() ) {
                   case Mine::Flagged:
                     if (m->isMined())
                         minecount--;
                     mineguess--;
                     break;
                   case Mine::Empty:
                     --nonminecount;
                     break;
                 default:
                     break;
                 }
             }
         }
         for ( x = 0; x < numCols; x++ ) {
             for ( int y = 0; y < numRows; y++ ) {
                 Mine* m = mine( y, x );
-                if ( m->state() == Mine::Empty )
+                if ( m && m->state() == Mine::Empty )
                     m->setHint(getHint(y,x));
             }
         }
     }
     setState( Playing );
     emit mineCount( mineguess );
 }
 
 QSize MineField::sizeHint() const
 {
     if ( qApp->desktop()->width() >= 240 )
         return QSize(200,200);
     else
         return QSize(160, 160);
 }