Eac one the files in this commit had an instance where a code path is

never traversed because of conditionals operating on values that
never change.

3 files changed, 2 insertions, 16 deletions

diff --git a/noncore/apps/opie-reader/decompress.cpp b/noncore/apps/opie-reader/decompress.cpp
index 9bfec49..6034e01 100644
--- a/noncore/apps/opie-reader/decompress.cpp
+++ b/noncore/apps/opie-reader/decompress.cpp
@@ -1,95 +1,88 @@
 #include <string.h>
 #include "decompress.h"
 #include <zlib.h>
 #include <stdlib.h>
 
 size_t UnZip(UInt8* compressedbuffer, size_t reclen, UInt8* tgtbuffer, size_t bsize)
 {
   z_stream zstream;
   memset(&zstream,sizeof(zstream),0);
   zstream.next_in = compressedbuffer;
   zstream.next_out = tgtbuffer;
   zstream.avail_out = bsize;
   zstream.avail_in = reclen;
 
-  int keylen = 0;
-
   zstream.zalloc = Z_NULL;
   zstream.zfree = Z_NULL;
   zstream.opaque = Z_NULL;
   
   //  printf("Initialising\n");
   
   inflateInit(&zstream);
   int err = 0;
   do {
-    if ( zstream.avail_in == 0 && 0 < keylen ) {
-      zstream.next_in   = compressedbuffer + keylen;
-      zstream.avail_in  = reclen - keylen;
-      keylen      = 0;
-    }
     zstream.next_out  = tgtbuffer;
     zstream.avail_out = bsize;
 
     err = inflate( &zstream, Z_SYNC_FLUSH );
 
     //	//qDebug("err:%d - %u", err, zstream.avail_in);
 
   } while ( err == Z_OK );
 
   inflateEnd(&zstream);
   return zstream.total_out;
 }
 
 #if defined(__STATIC) && defined(USENEF)
 #include "Model.h"
 size_t (*getdecompressor(char* _s))(UInt8*, size_t, UInt8*, size_t)
 {
   if (strcmp(_s, "PluckerDecompress3") == 0)
     {
       return PluckerDecompress3;
     }
   if (strcmp(_s, "PluckerDecompress4") == 0)
     {
       return PluckerDecompress4;
     }
   if (strcmp(_s, "RebDecompress") == 0)
     {
       return RebDecompress;
     }
   return NULL;
 }
 #else
 
 #include "qfileinfo.h"
 
 #include <dlfcn.h>
 
 size_t (*getdecompressor(char* _s))(UInt8*, size_t, UInt8*, size_t)
 {
 #ifdef USEQPE
 #ifdef OPIE
   QString codecpath(getenv("OPIEDIR"));
 #else
   QString codecpath(getenv("QTDIR"));
 #endif
   codecpath += "/plugins/reader/support/libpluckerdecompress.so";
 #else
   QString codecpath(getenv("READERDIR"));
   codecpath += "/support/libpluckerdecompress.so";
 #endif
   qDebug("Codec:%s", (const char*)codecpath);
   if (QFile::exists(codecpath))
     {
       qDebug("Codec:%s", (const char*)codecpath);
       void* handle = dlopen(codecpath, RTLD_LAZY);
       if (handle == 0)
 	{
 	  qDebug("Can't find codec:%s", dlerror());
 	  return NULL;
 	}
       return (size_t (*)(UInt8*, size_t, UInt8*, size_t))dlsym(handle, _s);
     }
   return NULL;
 }
 #endif
diff --git a/noncore/games/solitaire/canvascard.cpp b/noncore/games/solitaire/canvascard.cpp
index cd298ef..3ed9ea0 100644
--- a/noncore/games/solitaire/canvascard.cpp
+++ b/noncore/games/solitaire/canvascard.cpp
@@ -1,303 +1,303 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "canvascard.h"
 
 #include <opie2/oresource.h>
 
 #include <qgfx_qws.h> // Needed to get the device's width
 
 #include <math.h>
 
 #if defined( QT_QWS_CASSIOPEIA )
 #define SLOW_HARDWARE
 #endif
 
 // Seems to be fast enough to me even without Transformations in the library
 //#if defined( QT_NO_TRANSFORMATIONS ) && defined( QT_QWS_IPAQ )
 //#define SLOW_HARDWARE
 //#endif
 
 
 QBitmap *Create180RotatedBitmap(QBitmap *srcBitmap)
 {
 #ifdef QT_NO_TRANSFORMATIONS
     int w = srcBitmap->width();
     int h = srcBitmap->height();
     QBitmap *dstBitmap = new QBitmap( w, h );
     // ### this is very poorly implemented and probably could be much faster
     for (int i = 0; i < w; i++)
 	for (int j = 0; j < h; j++)
 	    bitBlt( dstBitmap, i, j, srcBitmap, w - i - 1, h - j - 1, 1, 1 );
     return dstBitmap;
 #else
     QWMatrix m;
     m.rotate( 180.0 );
     return new QBitmap( srcBitmap->xForm( m ) );
 #endif
 }
 
 
 QPixmap *CreateScaledPixmap(QPixmap *srcPixmap, double scaleX, double scaleY)
 {
 #ifdef QT_NO_TRANSFORMATIONS
     int w = srcPixmap->width();
     int h = srcPixmap->height();
     int newW = (int)(w * scaleX);
     int newH = (int)(h * scaleY);
     QPixmap *dstPixmap = new QPixmap( newW, newH );
     // ### this is very poorly implemented and probably could be much faster
     for (int i = 0; i < newW; i++) {
 	int srcX = w * i / newW;
 	if (newH == h) {
 	    // Optimise for scaleing in the X-axis only
 	    bitBlt( dstPixmap, i, 0, srcPixmap, srcX, 0, 1, h );
 	} else {
 	    for (int j = 0; j < newH; j++) {
 		int srcY = h * j / newH;
 		bitBlt( dstPixmap, i, j, srcPixmap, srcX, srcY, 1, 1 );
 	    }
         }
     }
     return dstPixmap;
 #else
     QWMatrix s;
     s.scale( scaleX, scaleY );
     return new QPixmap( srcPixmap->xForm( s ) );
 #endif
 }
 
 
 // Initialise static member variables to NULL
 QPixmap *CanvasCard::cardsFaces = NULL;
 QPixmap *CanvasCard::cardsBacks = NULL;
 QBitmap *CanvasCard::cardsChars = NULL;
 QBitmap *CanvasCard::cardsSuits = NULL;
 QBitmap *CanvasCard::cardsCharsUpsideDown = NULL;
 QBitmap *CanvasCard::cardsSuitsUpsideDown = NULL;
 
 
 CanvasCard::CanvasCard( eValue v, eSuit s, bool f, QCanvas *canvas ) :
 	Card(v, s, f), QCanvasRectangle( 0, 0, 1, 1, canvas ), cardBack(1), scaleX(1.0), scaleY(1.0)
 {
     if ( !cardsFaces ) {
 	if ( qt_screen->deviceWidth() < 200 ) {
 	    cardsFaces = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_face_small" ) );
 	    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0001_small" ) );
 	    cardsChars = new QBitmap();
         *cardsChars = Opie::Core::OResource::loadPixmap( "cards/card_chars_small" );
 	    cardsSuits = new QBitmap();
         *cardsSuits = Opie::Core::OResource::loadPixmap( "cards/card_suits_small" );
 	} else {
 	    cardsFaces = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_face" ) );
 	    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0001" ) );
 	    cardsChars = new QBitmap();
         *cardsChars = Opie::Core::OResource::loadPixmap( "cards/card_chars" );
 	    cardsSuits = new QBitmap();
         *cardsSuits = Opie::Core::OResource::loadPixmap( "cards/card_suits" );
 	}
 	cardsCharsUpsideDown = Create180RotatedBitmap( cardsChars );
 	cardsSuitsUpsideDown = Create180RotatedBitmap( cardsSuits );
     }
     xOff = cardsFaces->width() / 2;
     yOff = cardsFaces->height() / 2;
     setSize( cardsFaces->width(), cardsFaces->height() );
     setPen( NoPen );
     flipping = FALSE;
 }
 
 
 void CanvasCard::setCardBack(int b)
 {
     if ( cardBack != b ) {
 
 	cardBack = b;
 
 	if ( cardsBacks )
 	    delete cardsBacks;
 
 	if ( qt_screen->deviceWidth() < 200 ) {
 	    switch (cardBack) {
 		case 0:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0001_small" ) ); break;
 		case 1:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0002_small" ) ); break;
 		case 2:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0003_small" ) ); break;
 		case 3:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0004_small" ) ); break;
 		case 4:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0005_small" ) ); break;
 	    }
 	} else {
 	    switch (cardBack) {
 		case 0:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0001" ) ); break;
 		case 1:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0002" ) ); break;
 		case 2:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0003" ) ); break;
 		case 3:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0004" ) ); break;
 		case 4:
 		    cardsBacks = new QPixmap( Opie::Core::OResource::loadPixmap( "cards/card_back0005" ) ); break;
 	    }
 	}
 
         if ( !isFacing() )
 	    redraw();
     }
 }
 
 
 void CanvasCard::draw(QPainter &painter)
 {
     int ix = (int)x(), iy = (int)y();
 
     QPainter *p = &painter;
     QPixmap *unscaledCard = NULL;
 
     if ((scaleX <= 0.98) || (scaleY <= 0.98)) 
     {
 	p = new QPainter();
 	unscaledCard = new QPixmap( cardsFaces->width(), cardsFaces->height() );
 	p->begin(unscaledCard);
 	ix = 0;
 	iy = 0;
     }
 	
     if ( isFacing() ) {
 	
 	int w = cardsFaces->width(), h = cardsFaces->height();
 
 	p->setBrush( QColor( 0xFF, 0xFF, 0xFF ) );
 
 	if ( isRed() == TRUE )
 	    p->setPen( QColor( 0xFF, 0, 0 ) );
 	else
 	    p->setPen( QColor( 0, 0, 0 ) );
 
 	if ( qt_screen->deviceWidth() < 200 ) {
 	    p->drawPixmap( ix +      0, iy +     0, *cardsFaces );
 	    p->drawPixmap( ix +      3, iy +     3, *cardsChars, 5*(getValue()-1), 0, 5, 6 );
 	    p->drawPixmap( ix +     11, iy +     3, *cardsSuits, 5*(getSuit()-1), 0, 5, 6 );
 	    p->drawPixmap( ix +  w-3-5, iy + h-3-6, *cardsCharsUpsideDown, 5*(12-getValue()+1), 0, 5, 6 );
 	    p->drawPixmap( ix + w-11-5, iy + h-3-6, *cardsSuitsUpsideDown, 5*(3-getSuit()+1), 0, 5, 6 );
 	} else {
 	    p->drawPixmap( ix +      0, iy +     0, *cardsFaces );
 	    p->drawPixmap( ix +      4, iy +     4, *cardsChars, 7*(getValue()-1), 0, 7, 7 );
 	    p->drawPixmap( ix +     12, iy +     4, *cardsSuits, 7*(getSuit()-1), 0, 7, 8 );
 	    p->drawPixmap( ix +  w-4-7, iy + h-4-7, *cardsCharsUpsideDown, 7*(12-getValue()+1), 0, 7, 7 );
 	    p->drawPixmap( ix + w-12-7, iy + h-5-7, *cardsSuitsUpsideDown, 7*(3-getSuit()+1), 0, 7, 8 );
 	}
 
     } else {
 	
 	p->drawPixmap( ix, iy, *cardsBacks );
 
     }
 
-    if (p != &painter)
+    if (p != &painter && unscaledCard)
     {
 	p->end();
 	QPixmap *scaledCard = CreateScaledPixmap( unscaledCard, scaleX, scaleY );
 	int xoff = scaledCard->width() / 2;
 	int yoff = scaledCard->height() / 2;
 	painter.drawPixmap( (int)x() + xOff - xoff, (int)y() + yOff - yoff, *scaledCard );
 	delete p;
 	delete unscaledCard;
 	delete scaledCard;
     }
 }
 
 
 static const double flipLift = 1.5;
 
 
 void CanvasCard::flipTo(int x2, int y2, int steps)
 {
     flipSteps = steps;
 
 #ifdef SLOW_HARDWARE
     move(x2,y2);
     Card::flipTo(x2,y2,steps);
 #else
     int x1 = (int)x();
     int y1 = (int)y();
     double dx = x2 - x1;
     double dy = y2 - y1;
 
     flipping = TRUE;
     destX = x2;
     destY = y2;
     animSteps = flipSteps;
     setVelocity(dx/animSteps, dy/animSteps-flipLift);
     setAnimated(TRUE);
 #endif
 }
 
 
 void CanvasCard::advance(int stage)
 {
     if ( stage==1 ) {
 	if ( animSteps-- <= 0 ) {
 	    scaleX = 1.0;
 	    scaleY = 1.0;
 	    flipping = FALSE;
 	    setVelocity(0,0);
 	    setAnimated(FALSE);
 	    move(destX,destY); // exact
 	} else {
 	    if ( flipping ) {
 		if ( animSteps > flipSteps / 2 ) {
 		    // animSteps = flipSteps .. flipSteps/2 (flip up) -> 1..0
 		    scaleX = ((double)animSteps/flipSteps-0.5)*2;
 		} else {
 		    // animSteps = flipSteps/2 .. 0 (flip down) -> 0..1
 		    scaleX = 1-((double)animSteps/flipSteps)*2;
 		}
 		if ( animSteps == flipSteps / 2-1 ) {
 		    setYVelocity(yVelocity()+flipLift*2);
 		    setFace( !isFacing() );
 		}
 	    }
 	}
     }
     QCanvasRectangle::advance(stage);
 }
 
 
 void CanvasCard::animatedMove(int x2, int y2, int steps)
 {
     destX = x2;
     destY = y2;
 
     double x1 = x(), y1 = y(), dx = x2 - x1, dy = y2 - y1;
 
     // Ensure a good speed
     while ( fabs(dx/steps)+fabs(dy/steps) < 5.0 && steps > 4 )
 	steps--;
 
     setAnimated(TRUE);
     setVelocity(dx/steps, dy/steps);
 
     animSteps = steps;
 }
 
diff --git a/noncore/games/tetrix/ohighscoredlg.cpp b/noncore/games/tetrix/ohighscoredlg.cpp
index 66f4917..504385f 100644
--- a/noncore/games/tetrix/ohighscoredlg.cpp
+++ b/noncore/games/tetrix/ohighscoredlg.cpp
@@ -1,206 +1,199 @@
 /***************************************************************************
    begin                    : January 2003
    copyright                : ( C ) 2003 by Carsten Niehaus
    email                    : cniehaus@handhelds.org
  **************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  * This program is free software; you can redistribute it and/or modify    *
  * it under the terms of the GNU General Public License as published by    *
  * the Free Software Foundation; either version 2 of the License, or       *
  * ( at your option ) any later version.                                   *
  *                                                                         *
  **************************************************************************/
 
 #include <qdialog.h>
 #include <qlayout.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 
 #include <qstring.h>
 #include <qlist.h>
 #include <qhbox.h>
 #include <qvbox.h>
 #include <qlabel.h>
 #include <qlistview.h>
 #include <qlineedit.h>
 
 #include "ohighscoredlg.h"
 
 OHighscore::OHighscore( int score , int playerLevel ) : playerData()
 {
 	pLevel = playerLevel;
 	getList();
 	checkIfItIsANewhighscore( score );
 	playerData.setAutoDelete( TRUE );
 }
 
 OHighscore::~OHighscore()
 {
 }
 
 void OHighscore::getList()
 {
 	Config cfg ( "tetrix" );
 	cfg.setGroup( QString::number( 1 ) );
 	lowest = cfg.readNumEntry( "Points" );
 	playerData.clear();
 
 	int rest = 1;	//for the filling up later
 
 	for ( int i = 1 ; i < 11 ; i++ )
 	{
 		if ( cfg.hasGroup( QString::number( i ) ) )
 		{
 			cfg.setGroup( QString::number( i ) );
 			int temp = cfg.readNumEntry( "Points" );
 
 			t_playerData *pPlayerData = new t_playerData;
 			pPlayerData->sName = cfg.readEntry( "Name" );
 			pPlayerData->points = temp;
 			pPlayerData->level = cfg.readNumEntry( "Level" );
 
 			playerData.append( pPlayerData );
 
 			if ( (temp < lowest) ) lowest = temp;
 			rest++;
 		}
 	}
 
 	//now I fill up the rest of the list
 	if ( rest < 11 ) //only go in this loop if there are less than
 					 //10 highscoreentries
 	{
 		lowest = 0;
 		for ( ; rest < 11 ; rest++ )
 		{
 			t_playerData *pPlayerData = new t_playerData;
 			pPlayerData->sName = tr( "empty");
 			pPlayerData->points = 0;
 			pPlayerData->level = 0;
 
 			playerData.append( pPlayerData );
 		}
 	}
 
 }
 
 void OHighscore::checkIfItIsANewhighscore( int points)
 {
 	if ( points > lowest )
 		isNewhighscore = true; 
 	else 
 		isNewhighscore = false;
 }
 
 void OHighscore::insertData( QString name , int punkte , int playerLevel )
 {
 	Config cfg ( "tetrix" );
 	t_playerData * Run;
 	int index = 0;
 	int entryNumber = 1;
 
         for ( Run=playerData.first(); 
               Run != 0; 
               index ++, Run=playerData.next() ) {
 
 		if ( punkte > Run->points )
 		{
 			t_playerData* temp = new t_playerData;
 			temp->sName = name;
 			temp->points = punkte;
 			temp->level = playerLevel;
 
 			playerData.insert( index, temp );
 			
 			//now we have to delete the last entry
 			playerData.remove( playerData.count() );
 			
 		/////////////////////////////////////////
 		//this block just rewrites the highscore
                         for ( t_playerData * Run2=playerData.first(); 
                               Run2 != 0; 
                               Run2=playerData.next() ) {
 				cfg.setGroup( QString::number( entryNumber ) );
 				cfg.writeEntry( "Name" , Run2->sName );
 				cfg.writeEntry( "Points" , Run2->points );
 				cfg.writeEntry( "Level" , Run2->level );
 				entryNumber++;	
 			}
 		////////////////////////////////////////	
 
 			return;
 		}
 	} 
 }
 
 QString OHighscore::getName()
 {
 	QString name;
 	QDialog *d = new QDialog ( this, 0, true );
 	d->setCaption( tr( "Enter your name!" ));
 	QLineEdit *ed = new QLineEdit ( d );
 	( new QVBoxLayout ( d, 3, 3 ))->addWidget ( ed );
 	ed->setFocus ( );
 
     if ( d->exec() == QDialog::Accepted ) {
         name = ed->text();
     }
     //delete d;
 	return name;
 }
 
 OHighscoreDialog::OHighscoreDialog(OHighscore *highscore, QWidget *parent, const char *name, bool modal) : QDialog(parent, name, modal)
 {
 	hs_ = highscore;
 	setCaption( tr( "Highscores" ) );
 	vbox_layout = new QVBoxLayout( this, 4 , 4 );
 	list = new QListView( this );
 	list->setSorting( -1 );
 	list->addColumn( tr( "#" ));
 	list->addColumn( tr( "Name" ));
 	list->addColumn( tr( "Points" ));
 	list->addColumn( tr( "Level" ));
 
 	createHighscoreListView();
 	
 	vbox_layout->addWidget( list );
 	QPEApplication::showDialog( this );
 }
 
 void OHighscoreDialog::createHighscoreListView()
 {
 	int pos = 10;
 	int points_ = 0;
 	int level_ = 0;
-	QListViewItem * Prev = 0;
 
         for ( t_playerData * Run = hs_->playerData.first(); 
               Run != 0; 
               Run=hs_->playerData.next() )
         {
                 QListViewItem *item;
 
-		if( Prev ) {
-                  // after previous
-                  item = new QListViewItem( list, Prev );
-                  Prev = item;
-                } else {
-                  item = new QListViewItem( list );
+                item = new QListViewItem( list );
 
-                }
 		item->setText(  0 , QString::number( pos ) );                   //number
 		item->setText(  1 , Run->sName );                       //name
 		if ( Run->points  == -1 )
 			points_ = 0;
 		else points_ =  Run->points;
 		if ( Run->level  == -1 )
                     level_ = 0;
 		else level_ =  Run->level;
 		item->setText(  2 , QString::number( points_ ) );   //points
 		item->setText(  3 , QString::number( level_ ) );    //level
 		pos--;
 	}
 }