Each file in this commit has a problem where it is possible to dereference

a pointer without that pointer being valid. This commit fixes each instance
of that.

6 files changed, 62 insertions, 29 deletions

diff --git a/core/multimedia/opieplayer/modplug/sndfile.cpp b/core/multimedia/opieplayer/modplug/sndfile.cpp
index 1d0d610..799555c 100644
--- a/core/multimedia/opieplayer/modplug/sndfile.cpp
+++ b/core/multimedia/opieplayer/modplug/sndfile.cpp
@@ -1646,193 +1646,196 @@ DWORD CSoundFile::TransposeToFrequency(int transp, int ftune)
 	fscale
 	fstp st(1)
 	fmul st(1), st(0)
 	faddp st(1), st(0)
 	fistp freq
 	}
 	UINT derr = freq % 11025;
 	if (derr <= 8) freq -= derr;
 	if (derr >= 11015) freq += 11025-derr;
 	derr = freq % 1000;
 	if (derr <= 5) freq -= derr;
 	if (derr >= 995) freq += 1000-derr;
 	return freq;
 #endif
 }
 
 
 // returns 12*128*log2(freq/8363)
 int CSoundFile::FrequencyToTranspose(DWORD freq)
 //----------------------------------------------
 {
 	//---GCCFIX:  Removed assembly.
 	return int(1536*(log(freq/8363)/log(2)));
 	
 #ifdef WIN32
 	const float _f1_8363 = 1.0f / 8363.0f;
 	const float _factor = 128 * 12;
 	LONG result;
 	
 	if (!freq) return 0;
 	_asm {
 	fld _factor
 	fild freq
 	fld _f1_8363
 	fmulp st(1), st(0)
 	fyl2x
 	fistp result
 	}
 	return result;
 #endif
 }
 
 
 void CSoundFile::FrequencyToTranspose(MODINSTRUMENT *psmp)
 //--------------------------------------------------------
 {
 	int f2t = FrequencyToTranspose(psmp->nC4Speed);
 	int transp = f2t >> 7;
 	int ftune = f2t & 0x7F;
 	if (ftune > 80)
 	{
 		transp++;
 		ftune -= 128;
 	}
 	if (transp > 127) transp = 127;
 	if (transp < -127) transp = -127;
 	psmp->RelativeTone = transp;
 	psmp->nFineTune = ftune;
 }
 
 
 void CSoundFile::CheckCPUUsage(UINT nCPU)
 //---------------------------------------
 {
 	if (nCPU > 100) nCPU = 100;
 	gnCPUUsage = nCPU;
 	if (nCPU < 90)
 	{
 		m_dwSongFlags &= ~SONG_CPUVERYHIGH;
 	} else
 	if ((m_dwSongFlags & SONG_CPUVERYHIGH) && (nCPU >= 94))
 	{
 		UINT i=MAX_CHANNELS;
 		while (i >= 8)
 		{
 			i--;
 			if (Chn[i].nLength)
 			{
 				Chn[i].nLength = Chn[i].nPos = 0;
 				nCPU -= 2;
 				if (nCPU < 94) break;
 			}
 		}
 	} else
 	if (nCPU > 90)
 	{
 		m_dwSongFlags |= SONG_CPUVERYHIGH;
 	}
 }
 
 
 BOOL CSoundFile::SetPatternName(UINT nPat, LPCSTR lpszName)
 //---------------------------------------------------------
 {
         char szName[MAX_PATTERNNAME] = "";   // changed from CHAR
 	if (nPat >= MAX_PATTERNS) return FALSE;
-	if (lpszName) lstrcpyn(szName, lpszName, MAX_PATTERNNAME);
+	if (lpszName)
+		lstrcpyn(szName, lpszName, MAX_PATTERNNAME);
+	else
+		return FALSE;
 	szName[MAX_PATTERNNAME-1] = 0;
 	if (!m_lpszPatternNames) m_nPatternNames = 0;
 	if (nPat >= m_nPatternNames)
 	{
 		if (!lpszName[0]) return TRUE;
 		UINT len = (nPat+1)*MAX_PATTERNNAME;
 		char *p = new char[len];   // changed from CHAR
 		if (!p) return FALSE;
 		memset(p, 0, len);
 		if (m_lpszPatternNames)
 		{
 			memcpy(p, m_lpszPatternNames, m_nPatternNames * MAX_PATTERNNAME);
 			delete m_lpszPatternNames;
 			m_lpszPatternNames = NULL;
 		}
 		m_lpszPatternNames = p;
 		m_nPatternNames = nPat + 1;
 	}
 	memcpy(m_lpszPatternNames + nPat * MAX_PATTERNNAME, szName, MAX_PATTERNNAME);
 	return TRUE;
 }
 
 
 BOOL CSoundFile::GetPatternName(UINT nPat, LPSTR lpszName, UINT cbSize) const
 //---------------------------------------------------------------------------
 {
 	if ((!lpszName) || (!cbSize)) return FALSE;
 	lpszName[0] = 0;
 	if (cbSize > MAX_PATTERNNAME) cbSize = MAX_PATTERNNAME;
 	if ((m_lpszPatternNames) && (nPat < m_nPatternNames))
 	{
 		memcpy(lpszName, m_lpszPatternNames + nPat * MAX_PATTERNNAME, cbSize);
 		lpszName[cbSize-1] = 0;
 		return TRUE;
 	}
 	return FALSE;
 }
 
 
 #ifndef FASTSOUNDLIB
 
 UINT CSoundFile::DetectUnusedSamples(BOOL *pbIns)
 //-----------------------------------------------
 {
 	UINT nExt = 0;
 
 	if (!pbIns) return 0;
 	if (m_nInstruments)
 	{
 		memset(pbIns, 0, MAX_SAMPLES * sizeof(BOOL));
 		for (UINT ipat=0; ipat<MAX_PATTERNS; ipat++)
 		{
 			MODCOMMAND *p = Patterns[ipat];
 			if (p)
 			{
 				UINT jmax = PatternSize[ipat] * m_nChannels;
 				for (UINT j=0; j<jmax; j++, p++)
 				{
 					if ((p->note) && (p->note <= 120))
 					{
 						if ((p->instr) && (p->instr < MAX_INSTRUMENTS))
 						{
 							INSTRUMENTHEADER *penv = Headers[p->instr];
 							if (penv)
 							{
 								UINT n = penv->Keyboard[p->note-1];
 								if (n < MAX_SAMPLES) pbIns[n] = TRUE;
 							}
 						} else
 						{
 							for (UINT k=1; k<=m_nInstruments; k++)
 							{
 								INSTRUMENTHEADER *penv = Headers[k];
 								if (penv)
 								{
 									UINT n = penv->Keyboard[p->note-1];
 									if (n < MAX_SAMPLES) pbIns[n] = TRUE;
 								}
 							}
 						}
 					}
 				}
 			}
 		}
 		for (UINT ichk=1; ichk<=m_nSamples; ichk++)
 		{
 			if ((!pbIns[ichk]) && (Ins[ichk].pSample)) nExt++;
 		}
 	}
 	return nExt;
 }
 
 
 BOOL CSoundFile::RemoveSelectedSamples(BOOL *pbIns)
 //-------------------------------------------------
 {
diff --git a/core/multimedia/opieplayer/vorbis/tremor/block.c b/core/multimedia/opieplayer/vorbis/tremor/block.c
index 8949253..7b5531b 100644
--- a/core/multimedia/opieplayer/vorbis/tremor/block.c
+++ b/core/multimedia/opieplayer/vorbis/tremor/block.c
@@ -133,194 +133,196 @@ void _vorbis_block_ripcord(vorbis_block *vb){
   /* pull the ripcord */
   vb->localtop=0;
   vb->reap=NULL;
 }
 
 int vorbis_block_clear(vorbis_block *vb){
   _vorbis_block_ripcord(vb);
   if(vb->localstore)_ogg_free(vb->localstore);
 
   memset(vb,0,sizeof(*vb));
   return(0);
 }
 
 static int _vds_init(vorbis_dsp_state *v,vorbis_info *vi){
   int i;
   codec_setup_info *ci=(codec_setup_info *)vi->codec_setup;
   private_state *b=NULL;
 
   memset(v,0,sizeof(*v));
   b=(private_state *)(v->backend_state=_ogg_calloc(1,sizeof(*b)));
 
   v->vi=vi;
   b->modebits=ilog(ci->modes);
 
   /* Vorbis I uses only window type 0 */
   b->window[0]=_vorbis_window(0,ci->blocksizes[0]/2);
   b->window[1]=_vorbis_window(0,ci->blocksizes[1]/2);
 
   /* finish the codebooks */
   if(!ci->fullbooks){
     ci->fullbooks=(codebook *)_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
     for(i=0;i<ci->books;i++){
       vorbis_book_init_decode(ci->fullbooks+i,ci->book_param[i]);
       /* decode codebooks are now standalone after init */
       vorbis_staticbook_destroy(ci->book_param[i]);
       ci->book_param[i]=NULL;
     }
   }
 
   v->pcm_storage=ci->blocksizes[1];
   v->pcm=(ogg_int32_t **)_ogg_malloc(vi->channels*sizeof(*v->pcm));
   v->pcmret=(ogg_int32_t **)_ogg_malloc(vi->channels*sizeof(*v->pcmret));
   for(i=0;i<vi->channels;i++)
     v->pcm[i]=(ogg_int32_t *)_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
 
   /* all 1 (large block) or 0 (small block) */
   /* explicitly set for the sake of clarity */
   v->lW=0; /* previous window size */
   v->W=0;  /* current window size */
 
   /* initialize all the mapping/backend lookups */
   b->mode=(vorbis_look_mapping **)_ogg_calloc(ci->modes,sizeof(*b->mode));
   for(i=0;i<ci->modes;i++){
     int mapnum=ci->mode_param[i]->mapping;
     int maptype=ci->map_type[mapnum];
     b->mode[i]=_mapping_P[maptype]->look(v,ci->mode_param[i],
 					 ci->map_param[mapnum]);
   }
   return(0);
 }
 
 int vorbis_synthesis_restart(vorbis_dsp_state *v){
   vorbis_info *vi=v->vi;
   codec_setup_info *ci;
 
   if(!v->backend_state)return -1;
   if(!vi)return -1;
   ci=vi->codec_setup;
   if(!ci)return -1;
 
   v->centerW=ci->blocksizes[1]/2;
   v->pcm_current=v->centerW;
   
   v->pcm_returned=-1;
   v->granulepos=-1;
   v->sequence=-1;
   ((private_state *)(v->backend_state))->sample_count=-1;
 
   return(0);
 }
 
 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
   _vds_init(v,vi);
   vorbis_synthesis_restart(v);
 
   return(0);
 }
 
 void vorbis_dsp_clear(vorbis_dsp_state *v){
   int i;
   if(v){
     vorbis_info *vi=v->vi;
     codec_setup_info *ci=(codec_setup_info *)(vi?vi->codec_setup:NULL);
     private_state *b=(private_state *)v->backend_state;
 
     if(v->pcm){
-      for(i=0;i<vi->channels;i++)
-	if(v->pcm[i])_ogg_free(v->pcm[i]);
+      if (vi) {
+	for(i=0;i<vi->channels;i++)
+	  if(v->pcm[i])_ogg_free(v->pcm[i]);
+      }
       _ogg_free(v->pcm);
       if(v->pcmret)_ogg_free(v->pcmret);
     }
 
     /* free mode lookups; these are actually vorbis_look_mapping structs */
     if(ci){
       for(i=0;i<ci->modes;i++){
 	int mapnum=ci->mode_param[i]->mapping;
 	int maptype=ci->map_type[mapnum];
 	if(b && b->mode)_mapping_P[maptype]->free_look(b->mode[i]);
       }
     }
 
     if(b){
       if(b->mode)_ogg_free(b->mode);    
       _ogg_free(b);
     }
     
     memset(v,0,sizeof(*v));
   }
 }
 
 /* Unlike in analysis, the window is only partially applied for each
    block.  The time domain envelope is not yet handled at the point of
    calling (as it relies on the previous block). */
 
 int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
   vorbis_info *vi=v->vi;
   codec_setup_info *ci=(codec_setup_info *)vi->codec_setup;
   private_state *b=v->backend_state;
   int i,j;
 
   if(v->pcm_current>v->pcm_returned  && v->pcm_returned!=-1)return(OV_EINVAL);
 
   v->lW=v->W;
   v->W=vb->W;
   v->nW=-1;
 
   if((v->sequence==-1)||
      (v->sequence+1 != vb->sequence)){
     v->granulepos=-1; /* out of sequence; lose count */
     b->sample_count=-1;
   }
 
   v->sequence=vb->sequence;
   
   if(vb->pcm){  /* no pcm to process if vorbis_synthesis_trackonly 
                    was called on block */
     int n=ci->blocksizes[v->W]/2;
     int n0=ci->blocksizes[0]/2;
     int n1=ci->blocksizes[1]/2;
     
     int thisCenter;
     int prevCenter;
     
     if(v->centerW){
       thisCenter=n1;
       prevCenter=0;
     }else{
       thisCenter=0;
       prevCenter=n1;
     }
     
     /* v->pcm is now used like a two-stage double buffer.  We don't want
        to have to constantly shift *or* adjust memory usage.  Don't
        accept a new block until the old is shifted out */
     
     /* overlap/add PCM */
     
     for(j=0;j<vi->channels;j++){
       /* the overlap/add section */
       if(v->lW){
 	if(v->W){
 	  /* large/large */
 	  ogg_int32_t *pcm=v->pcm[j]+prevCenter;
 	  ogg_int32_t *p=vb->pcm[j];
 	  for(i=0;i<n1;i++)
 	    pcm[i]+=p[i];
 	}else{
 	  /* large/small */
 	  ogg_int32_t *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
 	  ogg_int32_t *p=vb->pcm[j];
 	  for(i=0;i<n0;i++)
 	    pcm[i]+=p[i];
 	}
       }else{
 	if(v->W){
 	  /* small/large */
 	  ogg_int32_t *pcm=v->pcm[j]+prevCenter;
 	  ogg_int32_t *p=vb->pcm[j]+n1/2-n0/2;
 	  for(i=0;i<n0;i++)
 	    pcm[i]+=p[i];
 	  for(;i<n1/2+n0/2;i++)
 	    pcm[i]=p[i];
 	}else{
 	  /* small/small */
diff --git a/core/multimedia/opieplayer/vorbis/tremor/info.c b/core/multimedia/opieplayer/vorbis/tremor/info.c
index 941695e..3499ae4 100644
--- a/core/multimedia/opieplayer/vorbis/tremor/info.c
+++ b/core/multimedia/opieplayer/vorbis/tremor/info.c
@@ -4,194 +4,194 @@
  *                                                                  *
  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
  *                                                                  *
  * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2003    *
  * BY THE Xiph.Org FOUNDATION http://www.xiph.org/                  *
  *                                                                  *
  ********************************************************************
 
  function: maintain the info structure, info <-> header packets
 
  ********************************************************************/
 
 /* general handling of the header and the vorbis_info structure (and
    substructures) */
 
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include "ogg.h"
 #include "ivorbiscodec.h"
 #include "codec_internal.h"
 #include "codebook.h"
 #include "registry.h"
 #include "window.h"
 #include "misc.h"
 #include "os.h"
 
 /* helpers */
 static void _v_readstring(oggpack_buffer *o,char *buf,int bytes){
   while(bytes--){
     *buf++=oggpack_read(o,8);
   }
 }
 
 void vorbis_comment_init(vorbis_comment *vc){
   memset(vc,0,sizeof(*vc));
 }
 
 /* This is more or less the same as strncasecmp - but that doesn't exist
  * everywhere, and this is a fairly trivial function, so we include it */
 static int tagcompare(const char *s1, const char *s2, int n){
   int c=0;
   while(c < n){
     if(toupper(s1[c]) != toupper(s2[c]))
       return !0;
     c++;
   }
   return 0;
 }
 
 char *vorbis_comment_query(vorbis_comment *vc, char *tag, int count){
   long i;
   int found = 0;
   int taglen = strlen(tag)+1; /* +1 for the = we append */
   char *fulltag = (char *)alloca(taglen+ 1);
 
   strcpy(fulltag, tag);
   strcat(fulltag, "=");
   
   for(i=0;i<vc->comments;i++){
     if(!tagcompare(vc->user_comments[i], fulltag, taglen)){
       if(count == found)
 	/* We return a pointer to the data, not a copy */
       	return vc->user_comments[i] + taglen;
       else
 	found++;
     }
   }
   return NULL; /* didn't find anything */
 }
 
 int vorbis_comment_query_count(vorbis_comment *vc, char *tag){
   int i,count=0;
   int taglen = strlen(tag)+1; /* +1 for the = we append */
   char *fulltag = (char *)alloca(taglen+1);
   strcpy(fulltag,tag);
   strcat(fulltag, "=");
 
   for(i=0;i<vc->comments;i++){
     if(!tagcompare(vc->user_comments[i], fulltag, taglen))
       count++;
   }
 
   return count;
 }
 
 void vorbis_comment_clear(vorbis_comment *vc){
   if(vc){
     long i;
     for(i=0;i<vc->comments;i++)
       if(vc->user_comments[i])_ogg_free(vc->user_comments[i]);
     if(vc->user_comments)_ogg_free(vc->user_comments);
 	if(vc->comment_lengths)_ogg_free(vc->comment_lengths);
     if(vc->vendor)_ogg_free(vc->vendor);
+    memset(vc,0,sizeof(*vc));
   }
-  memset(vc,0,sizeof(*vc));
 }
 
 /* blocksize 0 is guaranteed to be short, 1 is guarantted to be long.
    They may be equal, but short will never ge greater than long */
 int vorbis_info_blocksize(vorbis_info *vi,int zo){
   codec_setup_info *ci = (codec_setup_info *)vi->codec_setup;
   return ci ? ci->blocksizes[zo] : -1;
 }
 
 /* used by synthesis, which has a full, alloced vi */
 void vorbis_info_init(vorbis_info *vi){
   memset(vi,0,sizeof(*vi));
   vi->codec_setup=(codec_setup_info *)_ogg_calloc(1,sizeof(codec_setup_info));
 }
 
 void vorbis_info_clear(vorbis_info *vi){
   codec_setup_info     *ci=(codec_setup_info *)vi->codec_setup;
   int i;
 
   if(ci){
 
     for(i=0;i<ci->modes;i++)
       if(ci->mode_param[i])_ogg_free(ci->mode_param[i]);
 
     for(i=0;i<ci->maps;i++) /* unpack does the range checking */
       _mapping_P[ci->map_type[i]]->free_info(ci->map_param[i]);
 
     for(i=0;i<ci->floors;i++) /* unpack does the range checking */
       _floor_P[ci->floor_type[i]]->free_info(ci->floor_param[i]);
     
     for(i=0;i<ci->residues;i++) /* unpack does the range checking */
       _residue_P[ci->residue_type[i]]->free_info(ci->residue_param[i]);
 
     for(i=0;i<ci->books;i++){
       if(ci->book_param[i]){
 	/* knows if the book was not alloced */
 	vorbis_staticbook_destroy(ci->book_param[i]);
       }
       if(ci->fullbooks)
 	vorbis_book_clear(ci->fullbooks+i);
     }
     if(ci->fullbooks)
 	_ogg_free(ci->fullbooks);
     
     _ogg_free(ci);
   }
 
   memset(vi,0,sizeof(*vi));
 }
 
 /* Header packing/unpacking ********************************************/
 
 static int _vorbis_unpack_info(vorbis_info *vi,oggpack_buffer *opb){
   codec_setup_info     *ci=(codec_setup_info *)vi->codec_setup;
   if(!ci)return(OV_EFAULT);
 
   vi->version=oggpack_read(opb,32);
   if(vi->version!=0)return(OV_EVERSION);
 
   vi->channels=oggpack_read(opb,8);
   vi->rate=oggpack_read(opb,32);
 
   vi->bitrate_upper=oggpack_read(opb,32);
   vi->bitrate_nominal=oggpack_read(opb,32);
   vi->bitrate_lower=oggpack_read(opb,32);
 
   ci->blocksizes[0]=1<<oggpack_read(opb,4);
   ci->blocksizes[1]=1<<oggpack_read(opb,4);
   
   if(vi->rate<1)goto err_out;
   if(vi->channels<1)goto err_out;
   if(ci->blocksizes[0]<64)goto err_out; 
   if(ci->blocksizes[1]<ci->blocksizes[0])goto err_out;
   if(ci->blocksizes[1]>8192)goto err_out;
   
   if(oggpack_read(opb,1)!=1)goto err_out; /* EOP check */
 
   return(0);
  err_out:
   vorbis_info_clear(vi);
   return(OV_EBADHEADER);
 }
 
 static int _vorbis_unpack_comment(vorbis_comment *vc,oggpack_buffer *opb){
   int i;
   int vendorlen=oggpack_read(opb,32);
   if(vendorlen<0)goto err_out;
   vc->vendor=(char *)_ogg_calloc(vendorlen+1,1);
   _v_readstring(opb,vc->vendor,vendorlen);
   vc->comments=oggpack_read(opb,32);
   if(vc->comments<0)goto err_out;
   vc->user_comments=(char **)_ogg_calloc(vc->comments+1,sizeof(*vc->user_comments));
   vc->comment_lengths=(int *)_ogg_calloc(vc->comments+1, sizeof(*vc->comment_lengths));
 	    
   for(i=0;i<vc->comments;i++){
     int len=oggpack_read(opb,32);
diff --git a/noncore/apps/opie-write/qrichtext.cpp b/noncore/apps/opie-write/qrichtext.cpp
index f040f1e..768da44 100644
--- a/noncore/apps/opie-write/qrichtext.cpp
+++ b/noncore/apps/opie-write/qrichtext.cpp
@@ -96,236 +96,245 @@ static inline int scale( int value, QPainter *painter )
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 void QTextCommandHistory::addCommand( QTextCommand *cmd )
 {
     if ( current < (int)history.count() - 1 ) {
 	QPtrList<QTextCommand> commands;
 	commands.setAutoDelete( FALSE );
 
 	for( int i = 0; i <= current; ++i ) {
 	    commands.insert( i, history.at( 0 ) );
 	    history.take( 0 );
 	}
 
 	commands.append( cmd );
 	history.clear();
 	history = commands;
 	history.setAutoDelete( TRUE );
     } else {
 	history.append( cmd );
     }
 
     if ( (int)history.count() > steps )
 	history.removeFirst();
     else
 	++current;
 }
 
 QTextCursor *QTextCommandHistory::undo( QTextCursor *c )
 {
     if ( current > -1 ) {
 	QTextCursor *c2 = history.at( current )->unexecute( c );
 	--current;
 	return c2;
     }
     return 0;
 }
 
 QTextCursor *QTextCommandHistory::redo( QTextCursor *c )
 {
     if ( current > -1 ) {
 	if ( current < (int)history.count() - 1 ) {
 	    ++current;
 	    return history.at( current )->execute( c );
 	}
     } else {
 	if ( history.count() > 0 ) {
 	    ++current;
 	    return history.at( current )->execute( c );
 	}
     }
     return 0;
 }
 
 bool QTextCommandHistory::isUndoAvailable()
 {
     return current > -1;
 }
 
 bool QTextCommandHistory::isRedoAvailable()
 {
    return current > -1 && current < (int)history.count() - 1 || current == -1 && history.count() > 0;
 }
 
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 QTextDeleteCommand::QTextDeleteCommand( QTextDocument *d, int i, int idx, const QMemArray<QTextStringChar> &str,
 					const QByteArray& oldStyleInfo )
     : QTextCommand( d ), id( i ), index( idx ), parag( 0 ), text( str ), styleInformation( oldStyleInfo )
 {
     for ( int j = 0; j < (int)text.size(); ++j ) {
 	if ( text[ j ].format() )
 	    text[ j ].format()->addRef();
     }
 }
 
 QTextDeleteCommand::QTextDeleteCommand( QTextParagraph *p, int idx, const QMemArray<QTextStringChar> &str )
     : QTextCommand( 0 ), id( -1 ), index( idx ), parag( p ), text( str )
 {
     for ( int i = 0; i < (int)text.size(); ++i ) {
 	if ( text[ i ].format() )
 	    text[ i ].format()->addRef();
     }
 }
 
 QTextDeleteCommand::~QTextDeleteCommand()
 {
     for ( int i = 0; i < (int)text.size(); ++i ) {
 	if ( text[ i ].format() )
 	    text[ i ].format()->removeRef();
     }
     text.resize( 0 );
 }
 
 QTextCursor *QTextDeleteCommand::execute( QTextCursor *c )
 {
     QTextParagraph *s = doc ? doc->paragAt( id ) : parag;
-    if ( !s ) {
+    if ( !s && doc ) {
 	owarn << "can't locate parag at " << id << ", last parag: " << doc->lastParagraph()->paragId() << "" << oendl; 
 	return 0;
+    } else if ( !doc ) {
+	owarn << "No valid doc" << oendl;
+	return 0;
     }
 
     cursor.setParagraph( s );
     cursor.setIndex( index );
     int len = text.size();
     if ( c )
 	*c = cursor;
     if ( doc ) {
 	doc->setSelectionStart( QTextDocument::Temp, cursor );
 	for ( int i = 0; i < len; ++i )
 	    cursor.gotoNextLetter();
 	doc->setSelectionEnd( QTextDocument::Temp, cursor );
 	doc->removeSelectedText( QTextDocument::Temp, &cursor );
 	if ( c )
 	    *c = cursor;
     } else {
 	s->remove( index, len );
     }
 
     return c;
 }
 
 QTextCursor *QTextDeleteCommand::unexecute( QTextCursor *c )
 {
     QTextParagraph *s = doc ? doc->paragAt( id ) : parag;
-    if ( !s ) {
+    if ( !s && doc ) {
 	owarn << "can't locate parag at " << id << ", last parag: " << doc->lastParagraph()->paragId() << "" << oendl; 
 	return 0;
+    } else if ( !doc ) {
+	owarn << "No valid doc" << oendl;
+	return 0;
     }
 
     cursor.setParagraph( s );
     cursor.setIndex( index );
     QString str = QTextString::toString( text );
     cursor.insert( str, TRUE, &text );
     cursor.setParagraph( s );
     cursor.setIndex( index );
     if ( c ) {
 	c->setParagraph( s );
 	c->setIndex( index );
 	for ( int i = 0; i < (int)text.size(); ++i )
 	    c->gotoNextLetter();
+    } else {
+	owarn << "No valid cursor" << oendl;
+	return 0;
     }
 
     if ( !styleInformation.isEmpty() ) {
 	QDataStream styleStream( styleInformation, IO_ReadOnly );
 	int num;
 	styleStream >> num;
 	QTextParagraph *p = s;
 	while ( num-- && p ) {
 	    p->readStyleInformation( styleStream );
 	    p = p->next();
 	}
     }
     s = cursor.paragraph();
     while ( s ) {
 	s->format();
 	s->setChanged( TRUE );
 	if ( s == c->paragraph() )
 	    break;
 	s = s->next();
     }
 
     return &cursor;
 }
 
 QTextFormatCommand::QTextFormatCommand( QTextDocument *d, int sid, int sidx, int eid, int eidx,
 					const QMemArray<QTextStringChar> &old, QTextFormat *f, int fl )
     : QTextCommand( d ), startId( sid ), startIndex( sidx ), endId( eid ), endIndex( eidx ), format( f ), oldFormats( old ), flags( fl )
 {
     format = d->formatCollection()->format( f );
     for ( int j = 0; j < (int)oldFormats.size(); ++j ) {
 	if ( oldFormats[ j ].format() )
 	    oldFormats[ j ].format()->addRef();
     }
 }
 
 QTextFormatCommand::~QTextFormatCommand()
 {
     format->removeRef();
     for ( int j = 0; j < (int)oldFormats.size(); ++j ) {
 	if ( oldFormats[ j ].format() )
 	    oldFormats[ j ].format()->removeRef();
     }
 }
 
 QTextCursor *QTextFormatCommand::execute( QTextCursor *c )
 {
     QTextParagraph *sp = doc->paragAt( startId );
     QTextParagraph *ep = doc->paragAt( endId );
     if ( !sp || !ep )
 	return c;
 
     QTextCursor start( doc );
     start.setParagraph( sp );
     start.setIndex( startIndex );
     QTextCursor end( doc );
     end.setParagraph( ep );
     end.setIndex( endIndex );
 
     doc->setSelectionStart( QTextDocument::Temp, start );
     doc->setSelectionEnd( QTextDocument::Temp, end );
     doc->setFormat( QTextDocument::Temp, format, flags );
     doc->removeSelection( QTextDocument::Temp );
     if ( endIndex == ep->length() )
 	end.gotoLeft();
     *c = end;
     return c;
 }
 
 QTextCursor *QTextFormatCommand::unexecute( QTextCursor *c )
 {
     QTextParagraph *sp = doc->paragAt( startId );
     QTextParagraph *ep = doc->paragAt( endId );
     if ( !sp || !ep )
 	return 0;
 
     int idx = startIndex;
     int fIndex = 0;
     for ( ;; ) {
 	if ( oldFormats.at( fIndex ).c == '\n' ) {
 	    if ( idx > 0 ) {
 		if ( idx < sp->length() && fIndex > 0 )
 		    sp->setFormat( idx, 1, oldFormats.at( fIndex - 1 ).format() );
 		if ( sp == ep )
 		    break;
 		sp = sp->next();
 		idx = 0;
 	    }
 	    fIndex++;
 	}
 	if ( oldFormats.at( fIndex ).format() )
 	    sp->setFormat( idx, 1, oldFormats.at( fIndex ).format() );
 	idx++;
 	fIndex++;
 	if ( fIndex >= (int)oldFormats.size() )
 	    break;
 	if ( idx >= sp->length() ) {
@@ -1299,210 +1308,221 @@ bool QTextDocument::setMinimumWidth( int needed, int used, QTextParagraph *p )
     } else if ( needed > minw ) {
 	minw = needed;
 	minwParag = p;
 	emit minimumWidthChanged( minw );
     }
     wused = QMAX( wused, used );
     wused = QMAX( wused, minw );
     cw = QMAX( minw, cw );
     return TRUE;
 }
 
 void QTextDocument::setPlainText( const QString &text )
 {
     clear();
     preferRichText = FALSE;
     oTextValid = TRUE;
     oText = text;
 
     int lastNl = 0;
     int nl = text.find( '\n' );
     if ( nl == -1 ) {
 	lParag = createParagraph( this, lParag, 0 );
 	if ( !fParag )
 	    fParag = lParag;
 	QString s = text;
 	if ( !s.isEmpty() ) {
 	    if ( s[ (int)s.length() - 1 ] == '\r' )
 		s.remove( s.length() - 1, 1 );
 	    lParag->append( s );
 	}
     } else {
 	for (;;) {
 	    lParag = createParagraph( this, lParag, 0 );
 	    if ( !fParag )
 		fParag = lParag;
 	    QString s = text.mid( lastNl, nl - lastNl );
 	    if ( !s.isEmpty() ) {
 		if ( s[ (int)s.length() - 1 ] == '\r' )
 		    s.remove( s.length() - 1, 1 );
 		lParag->append( s );
 	    }
 	    if ( nl == 0xffffff )
 		break;
 	    lastNl = nl + 1;
 	    nl = text.find( '\n', nl + 1 );
 	    if ( nl == -1 )
 		nl = 0xffffff;
 	}
     }
     if ( !lParag )
 	lParag = fParag = createParagraph( this, 0, 0 );
 }
 
 struct Q_EXPORT QTextDocumentTag {
     QTextDocumentTag(){}
     QTextDocumentTag( const QString&n, const QStyleSheetItem* s, const QTextFormat& f )
 	:name(n),style(s), format(f), alignment(Qt3::AlignAuto), direction(QChar::DirON),liststyle(QStyleSheetItem::ListDisc) {
 	    wsm = QStyleSheetItem::WhiteSpaceNormal;
     }
     QString name;
     const QStyleSheetItem* style;
     QString anchorHref;
     QStyleSheetItem::WhiteSpaceMode wsm;
     QTextFormat format;
     int alignment : 16;
     int direction : 5;
     QStyleSheetItem::ListStyle liststyle;
 
     QTextDocumentTag(  const QTextDocumentTag& t ) {
 	name = t.name;
 	style = t.style;
 	anchorHref = t.anchorHref;
 	wsm = t.wsm;
 	format = t.format;
 	alignment = t.alignment;
 	direction = t.direction;
 	liststyle = t.liststyle;
     }
     QTextDocumentTag& operator=(const QTextDocumentTag& t) {
 	name = t.name;
 	style = t.style;
 	anchorHref = t.anchorHref;
 	wsm = t.wsm;
 	format = t.format;
 	alignment = t.alignment;
 	direction = t.direction;
 	liststyle = t.liststyle;
 	return *this;
     }
 
 #if defined(Q_FULL_TEMPLATE_INSTANTIATION)
     bool operator==( const QTextDocumentTag& ) const { return FALSE; }
 #endif
 };
 
 
-#define NEWPAR       do{ if ( !hasNewPar) { \
-		    if ( !textEditMode && curpar && curpar->length()>1 && curpar->at( curpar->length()-2)->c == QChar_linesep ) \
-			curpar->remove( curpar->length()-2, 1 ); \
-		    curpar = createParagraph( this, curpar, curpar->next() ); styles.append( vec ); vec = 0;} \
-		    hasNewPar = TRUE; \
-		    curpar->rtext = TRUE;  \
-		    curpar->align = curtag.alignment; \
-		    curpar->lstyle = curtag.liststyle; \
-		    curpar->litem = ( curtag.style->displayMode() == QStyleSheetItem::DisplayListItem ); \
-		    curpar->str->setDirection( (QChar::Direction)curtag.direction ); \
-		    space = TRUE; \
-		    delete vec; vec = new QPtrVector<QStyleSheetItem>( (uint)tags.count() + 1); \
-		    int i = 0; \
-		    for ( QValueStack<QTextDocumentTag>::Iterator it = tags.begin(); it != tags.end(); ++it ) \
-			vec->insert( i++, (*it).style ); \
-		    vec->insert( i, curtag.style ); \
-		    }while(FALSE)
-
+#define NEWPAR do { \
+                   if ( !hasNewPar) { \
+                       if ( !curpar ) { \
+                           owarn << "no current paragraph" << oendl; \
+                           return; \
+                       } \
+                       if ( !textEditMode && curpar && curpar->length()>1 && curpar->at( curpar->length()-2)->c == QChar_linesep ) \
+                           curpar->remove( curpar->length()-2, 1 ); \
+                       curpar = createParagraph( this, curpar, curpar->next() ); styles.append( vec ); \
+                       if ( !curpar ) { \
+                           owarn << "failed in creating a new paragraph" << oendl; \
+                           return; \
+                       } \
+                       vec = 0; \
+                   } \
+                   hasNewPar = TRUE; \
+                   curpar->rtext = TRUE;  \
+                   curpar->align = curtag.alignment; \
+                   curpar->lstyle = curtag.liststyle; \
+                   curpar->litem = ( curtag.style->displayMode() == QStyleSheetItem::DisplayListItem ); \
+                   curpar->str->setDirection( (QChar::Direction)curtag.direction ); \
+                   space = TRUE; \
+                   delete vec; \
+                   vec = new QPtrVector<QStyleSheetItem>( (uint)tags.count() + 1); \
+                   int i = 0; \
+                   for ( QValueStack<QTextDocumentTag>::Iterator it = tags.begin(); it != tags.end(); ++it ) \
+                       vec->insert( i++, (*it).style ); \
+                   vec->insert( i, curtag.style ); \
+               } while ( FALSE )
 
 void QTextDocument::setRichText( const QString &text, const QString &context )
 {
     if ( !context.isEmpty() )
 	setContext( context );
     clear();
     fParag = lParag = createParagraph( this );
     oTextValid = TRUE;
     oText = text;
     setRichTextInternal( text );
     fParag->rtext = TRUE;
 }
 
 void QTextDocument::setRichTextInternal( const QString &text, QTextCursor* cursor )
 {
     QTextParagraph* curpar = lParag;
     int pos = 0;
     QValueStack<QTextDocumentTag> tags;
     QTextDocumentTag initag( "", sheet_->item(""), *formatCollection()->defaultFormat() );
     QTextDocumentTag curtag = initag;
     bool space = TRUE;
     bool canMergeLi = FALSE;
 
     bool textEditMode = FALSE;
 
     const QChar* doc = text.unicode();
     int length = text.length();
     bool hasNewPar = curpar->length() <= 1;
     QString anchorName;
 
     // style sheet handling for margin and line spacing calculation below
     QTextParagraph* stylesPar = curpar;
     QPtrVector<QStyleSheetItem>* vec = 0;
     QPtrList< QPtrVector<QStyleSheetItem> > styles;
     styles.setAutoDelete( TRUE );
 
     if ( cursor ) {
 	cursor->splitAndInsertEmptyParagraph();
 	QTextCursor tmp = *cursor;
 	tmp.gotoPreviousLetter();
 	stylesPar = curpar = tmp.paragraph();
 	hasNewPar = TRUE;
 	textEditMode = TRUE;
     } else {
 	NEWPAR;
     }
 
     // set rtext spacing to FALSE for the initial paragraph.
     curpar->rtext = FALSE;
 
     QString wellKnownTags = "br hr wsp table qt body meta title";
 
     while ( pos < length ) {
 	if ( hasPrefix(doc, length, pos, '<' ) ){
 	    if ( !hasPrefix( doc, length, pos+1, QChar('/') ) ) {
 		// open tag
 		QMap<QString, QString> attr;
 		bool emptyTag = FALSE;
 		QString tagname = parseOpenTag(doc, length, pos, attr, emptyTag);
 		if ( tagname.isEmpty() )
 		    continue; // nothing we could do with this, probably parse error
 
 		const QStyleSheetItem* nstyle = sheet_->item(tagname);
 
 		if ( nstyle ) {
 		    // we might have to close some 'forgotten' tags
 		    while ( !nstyle->allowedInContext( curtag.style ) ) {
 			QString msg;
 			msg.sprintf( "QText Warning: Document not valid ( '%s' not allowed in '%s' #%d)",
 				     tagname.ascii(), curtag.style->name().ascii(), pos);
 			sheet_->error( msg );
 			if ( tags.isEmpty() )
 			    break;
 			curtag = tags.pop();
 		    }
 
 		    /* special handling for p and li for HTML
 		       compatibility. We do not want to embed blocks in
 		       p, and we do not want new blocks inside non-empty
 		       lis. Plus we want to merge empty lis sometimes. */
 		    if( nstyle->displayMode() == QStyleSheetItem::DisplayListItem ) {
 			canMergeLi = TRUE;
 		    } else if ( nstyle->displayMode() == QStyleSheetItem::DisplayBlock ) {
 			while ( curtag.style->name() == "p" ) {
 			    if ( tags.isEmpty() )
 				break;
 			    curtag = tags.pop();
 			}
 
 	   		if ( curtag.style->displayMode() == QStyleSheetItem::DisplayListItem ) {
 			    // we are in a li and a new block comes along
 			    if ( nstyle->name() == "ul" || nstyle->name() == "ol" )
 				hasNewPar = FALSE; // we want an empty li (like most browsers)
 			    if ( !hasNewPar ) {
 				/* do not add new blocks inside
 				   non-empty lis */
@@ -1802,194 +1822,197 @@ void QTextDocument::setRichTextInternal( const QString &text, QTextCursor* curso
 		    c = parseChar( doc, length, pos, QStyleSheetItem::WhiteSpacePre );
 		    if ( c == QChar_linesep )
 			break;
 		} else {
 		    int l = pos;
 		    c = parseChar( doc, length, pos, curtag.wsm );
 
 		    // in white space pre mode: treat any space as non  breakable
 		    if ( c == ' ' && curtag.wsm == QStyleSheetItem::WhiteSpacePre )
 			c = QChar::nbsp;
 
 		    if ( c == ' ' || c == QChar_linesep ) {
 			/* avoid overlong paragraphs by forcing a new
 			       paragraph after 4096 characters. This case can
 			       occur when loading undiscovered plain text
 			       documents in rich text mode. Instead of hanging
 			       forever, we do the trick.
 			    */
 			if ( curtag.wsm == QStyleSheetItem::WhiteSpaceNormal && s.length() > 4096 ) do {
 			    if ( doc[l] == '\n' ) {
 				hasNewPar = FALSE; // for a new paragraph ...
 				NEWPAR;
 				hasNewPar = FALSE; // ... and make it non-reusable
 				c = '\n';  // make sure we break below
 				break;
 			    }
 			} while ( ++l < pos );
 		    }
 		}
 
 		if ( c == '\n' )
 		    break;  // break on  newlines, pre delievers a QChar_linesep
 
 		bool c_isSpace = c.isSpace() && c.unicode() != 0x00a0U && !textEditMode;
 
 		if ( curtag.wsm == QStyleSheetItem::WhiteSpaceNormal && c_isSpace && space )
 		    continue;
 		if ( c == '\r' )
 		    continue;
 		space = c_isSpace;
 		s += c;
 	    }
 	    if ( !s.isEmpty() && curtag.style->displayMode() != QStyleSheetItem::DisplayNone ) {
 		hasNewPar = FALSE;
 		int index = QMAX( curpar->length(),1) - 1;
 		curpar->append( s );
 		QTextFormat* f = formatCollection()->format( &curtag.format );
 		curpar->setFormat( index, s.length(), f, FALSE ); // do not use collection because we have done that already
 		f->ref += s.length() -1; // that what friends are for...
 		if ( !curtag.anchorHref.isEmpty() ) {
 		    for ( int i = 0; i < int(s.length()); i++ )
 			curpar->at(index + i)->setAnchor( QString::null, curtag.anchorHref );
 		}
 		if ( !anchorName.isEmpty()  ) {
 		    curpar->at(index)->setAnchor( anchorName, curpar->at(index)->anchorHref() );
 		    anchorName = QString::null;
 		}
 	    }
 	}
     }
     if ( hasNewPar && curpar != fParag && !cursor ) {
 	// cleanup unused last paragraphs
 	curpar = curpar->p;
 	delete curpar->n;
     }
     if ( !anchorName.isEmpty()  ) {
 	curpar->at(curpar->length() - 1)->setAnchor( anchorName, curpar->at( curpar->length() - 1 )->anchorHref() );
 	anchorName = QString::null;
     }
 
 
     setRichTextMarginsInternal( styles, stylesPar );
 
     if ( cursor ) {
  	cursor->gotoPreviousLetter();
   	cursor->remove();
      }
 
 }
 
 void QTextDocument::setRichTextMarginsInternal( QPtrList< QPtrVector<QStyleSheetItem> >& styles, QTextParagraph* stylesPar )
 {
     // margin and line spacing calculation
     QPtrVector<QStyleSheetItem>* prevStyle = 0;
     QPtrVector<QStyleSheetItem>* curStyle = styles.first();
     QPtrVector<QStyleSheetItem>* nextStyle = styles.next();
     while ( stylesPar ) {
 	if ( !curStyle ) {
 	    stylesPar = stylesPar->next();
 	    prevStyle = curStyle;
 	    curStyle = nextStyle;
 	    nextStyle = styles.next();
 	    continue;
 	}
 
 	int i, mar;
-	QStyleSheetItem* mainStyle = curStyle->size() ? (*curStyle)[curStyle->size()-1] : 0;
-	if ( mainStyle && mainStyle->displayMode() == QStyleSheetItem::DisplayListItem )
+	QStyleSheetItem* mainStyle = (*curStyle)[curStyle->size()-1];
+	if ( !mainStyle )
+	    return;
+
+	if ( mainStyle->displayMode() == QStyleSheetItem::DisplayListItem )
 	    stylesPar->setListItem( TRUE );
 	int numLists = 0;
 	for ( i = 0; i < (int)curStyle->size(); ++i ) {
 	    if ( (*curStyle)[ i ]->displayMode() == QStyleSheetItem::DisplayBlock
 		 && int((*curStyle)[ i ]->listStyle()) != QStyleSheetItem::Undefined )
 		numLists++;
 	}
 	stylesPar->ldepth = numLists;
 	if ( stylesPar->next() && nextStyle ) {
 	    // also set the depth of the next paragraph, required for the margin calculation
 	    numLists = 0;
 	    for ( i = 0; i < (int)nextStyle->size(); ++i ) {
 		if ( (*nextStyle)[ i ]->displayMode() == QStyleSheetItem::DisplayBlock
 		     && int((*nextStyle)[ i ]->listStyle()) != QStyleSheetItem::Undefined )
 		    numLists++;
 	    }
 	    stylesPar->next()->ldepth = numLists;
 	}
 
 	// do the top margin
 	QStyleSheetItem* item = mainStyle;
 	int m;
 	if (stylesPar->utm > 0 ) {
 	    m = stylesPar->utm-1;
 	    stylesPar->utm = 0;
 	} else {
 	    m = QMAX(0, item->margin( QStyleSheetItem::MarginTop ) );
 	    if ( item->displayMode() == QStyleSheetItem::DisplayListItem
 		 && stylesPar->ldepth )
 	      m /= stylesPar->ldepth;
 	}
 	for ( i = (int)curStyle->size() - 2 ; i >= 0; --i ) {
 	    item = (*curStyle)[ i ];
 	    if ( prevStyle && i < (int) prevStyle->size() &&
 		 (  item->displayMode() == QStyleSheetItem::DisplayBlock &&
 		    (*prevStyle)[ i ] == item ) )
 		break;
 	    // emulate CSS2' standard 0 vertical margin for multiple ul or ol tags
  	    if ( int(item->listStyle()) != QStyleSheetItem::Undefined  &&
 		 ( (  i> 0 && (*curStyle)[ i-1 ] == item ) || (*curStyle)[i+1] == item ) )
 		continue;
 	    mar = QMAX( 0, item->margin( QStyleSheetItem::MarginTop ) );
 	    m = QMAX( m, mar );
 	}
 	stylesPar->utm = m - stylesPar->topMargin();
 
 	// do the bottom margin
 	item = mainStyle;
 	if (stylesPar->ubm > 0 ) {
 	    m = stylesPar->ubm-1;
 	    stylesPar->ubm = 0;
 	} else {
 	    m = QMAX(0, item->margin( QStyleSheetItem::MarginBottom ) );
 	    if ( item->displayMode() == QStyleSheetItem::DisplayListItem
 		 && stylesPar->ldepth )
 	      m /= stylesPar->ldepth;
 	}
 	for ( i = (int)curStyle->size() - 2 ; i >= 0; --i ) {
 	    item = (*curStyle)[ i ];
 	    if ( nextStyle && i < (int) nextStyle->size() &&
 		 (  item->displayMode() == QStyleSheetItem::DisplayBlock &&
 		    (*nextStyle)[ i ] == item ) )
 		break;
 	    // emulate CSS2' standard 0 vertical margin for multiple ul or ol tags
  	    if ( int(item->listStyle()) != QStyleSheetItem::Undefined  &&
 		 ( (  i> 0 && (*curStyle)[ i-1 ] == item ) || (*curStyle)[i+1] == item ) )
 		continue;
 	    mar = QMAX(0, item->margin( QStyleSheetItem::MarginBottom ) );
 	    m = QMAX( m, mar );
 	}
 	stylesPar->ubm = m - stylesPar->bottomMargin();
 
 	// do the left margin, simplyfied
 	item = mainStyle;
 	if (stylesPar->ulm > 0 ) {
 	    m = stylesPar->ulm-1;
 	    stylesPar->ulm = 0;
 	} else {
 	    m = QMAX( 0, item->margin( QStyleSheetItem::MarginLeft ) );
 	}
 	for ( i = (int)curStyle->size() - 2 ; i >= 0; --i ) {
 	    item = (*curStyle)[ i ];
 	    m += QMAX( 0, item->margin( QStyleSheetItem::MarginLeft ) );
 	}
 	stylesPar->ulm = m - stylesPar->leftMargin();
 
 	// do the right margin, simplyfied
 	item = mainStyle;
 	if (stylesPar->urm > 0 ) {
 	    m = stylesPar->urm-1;
 	    stylesPar->urm = 0;
 	} else {
 	    m = QMAX( 0, item->margin( QStyleSheetItem::MarginRight ) );
 	}
 	for ( i = (int)curStyle->size() - 2 ; i >= 0; --i ) {
 	    item = (*curStyle)[ i ];
@@ -5248,193 +5271,193 @@ int QTextFormatterBreakInWords::format( QTextDocument *doc,QTextParagraph *parag
 	    col = 0;
 	    if ( wrapAtColumn() != -1 )
 		minw = QMAX( minw, w );
 	} else if ( lineStart ) {
 	    lineStart->baseLine = QMAX( lineStart->baseLine, c->ascent() );
 	    h = QMAX( h, c->height() );
 	    lineStart->h = h;
 	}
 
 	c->x = x;
 	x += ww;
 	wused = QMAX( wused, x );
     }
 
     int m = parag->bottomMargin();
     if ( !parag->next() )
 	m = 0;
     else
 	m = QMAX(m, parag->next()->topMargin() ) / 2;
     parag->setFullWidth( fullWidth );
     y += h + m;
     if ( doc )
 	minw += doc->rightMargin();
     if ( !wrapEnabled )
 	minw = QMAX(minw, wused);
 
     thisminw = minw;
     thiswused = wused;
     return y;
 }
 
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 QTextFormatterBreakWords::QTextFormatterBreakWords()
 {
 }
 
 #define DO_FLOW( lineStart ) do{ if ( doc && doc->isPageBreakEnabled() ) { \
 		    int yflow = lineStart->y + parag->rect().y();\
 		    int shift = doc->flow()->adjustFlow( yflow, dw, lineStart->h ); \
 		    lineStart->y += shift;\
 		    y += shift;\
 		}}while(FALSE)
 
 int QTextFormatterBreakWords::format( QTextDocument *doc, QTextParagraph *parag,
 				      int start, const QMap<int, QTextLineStart*> & )
 {
     QTextStringChar *c = 0;
     QTextStringChar *firstChar = 0;
     QTextString *string = parag->string();
     int left = doc ? parag->leftMargin() + doc->leftMargin() : 0;
     int x = left + ( doc ? parag->firstLineMargin() : 0 );
     int y = parag->prev() ? QMAX(parag->prev()->bottomMargin(),parag->topMargin()) / 2: 0;
     int h = y;
     int len = parag->length();
     if ( doc )
 	x = doc->flow()->adjustLMargin( y + parag->rect().y(), parag->rect().height(), x, 0 );
     int dw = parag->documentVisibleWidth() - ( doc ? ( left != x ? 0 : doc->rightMargin() ) : 0 );
 
     int curLeft = x;
     int rm = parag->rightMargin();
     int rdiff = doc ? doc->flow()->adjustRMargin( y + parag->rect().y(), parag->rect().height(), rm, 0 ) : 0;
     int w = dw - rdiff;
     bool fullWidth = TRUE;
     int marg = left + rdiff;
     int minw = 0;
     int wused = 0;
     int tminw = marg;
     int linespacing = doc ? parag->lineSpacing() : 0;
     bool wrapEnabled = isWrapEnabled( parag );
 
     start = 0;
     if ( start == 0 )
 	c = &parag->string()->at( 0 );
 
     int i = start;
     QTextLineStart *lineStart = new QTextLineStart( y, y, 0 );
     insertLineStart( parag, 0, lineStart );
     int lastBreak = -1;
     int tmpBaseLine = 0, tmph = 0;
     bool lastWasNonInlineCustom = FALSE;
 
     int align = parag->alignment();
     if ( align == Qt3::AlignAuto && doc && doc->alignment() != Qt3::AlignAuto )
 	align = doc->alignment();
 
     align &= Qt3::AlignHorizontal_Mask;
 
     QPainter *painter = QTextFormat::painter();
     int col = 0;
     int ww = 0;
     QChar lastChr;
     for ( ; i < len; ++i, ++col ) {
 	if ( c )
 	    lastChr = c->c;
 	// ### next line should not be needed
-	if ( painter )
+	if ( c && painter )
 	    c->format()->setPainter( painter );
 	c = &string->at( i );
 	c->rightToLeft = FALSE;
 	if ( i > 0 && (x > curLeft || ww == 0) || lastWasNonInlineCustom ) {
 	    c->lineStart = 0;
 	} else {
 	    c->lineStart = 1;
 	    firstChar = c;
 	}
 
 	if ( c->isCustom() && c->customItem()->placement() != QTextCustomItem::PlaceInline )
 	    lastWasNonInlineCustom = TRUE;
 	else
 	    lastWasNonInlineCustom = FALSE;
 
 	if ( c->c.unicode() >= 32 || c->isCustom() ) {
 	    ww = string->width( i );
 	} else if ( c->c == '\t' ) {
 	    int nx = parag->nextTab( i, x - left ) + left;
 	    if ( nx < x )
 		ww = w - x;
 	    else
 		ww = nx - x;
 	} else {
 	    ww = c->format()->width( ' ' );
 	}
 
 	// last character ("invisible" space) has no width
 	if ( i == len - 1 )
 	    ww = 0;
 
 	QTextCustomItem* ci = c->customItem();
 	if ( c->isCustom() && ci->ownLine() ) {
 	    x = doc ? doc->flow()->adjustLMargin( y + parag->rect().y(), parag->rect().height(), left, 4 ) : left;
 	    w = dw - ( doc ? doc->flow()->adjustRMargin( y + parag->rect().y(), parag->rect().height(), rm, 4 ) : 0 );
 	    QTextLineStart *lineStart2 = formatLine( parag, string, lineStart, firstChar, c-1, align, SPACE(w - x) );
 	    ci->resize( w - x);
 	    if ( ci->width < w - x ) {
 		if ( align & Qt::AlignHCenter )
 		    x = ( w - ci->width ) / 2;
 		else if ( align & Qt::AlignRight ) {
 		    x = w - ci->width;
 		}
 	    }
 	    c->x = x;
 	    curLeft = x;
 	    if ( i == 0 || !isBreakable( string, i - 1 ) || string->at( i - 1 ).lineStart == 0 ) {
 		y += QMAX( h, QMAX( tmph, linespacing ) );
 		tmph = c->height();
 		h = tmph;
 		lineStart = lineStart2;
 		lineStart->y = y;
 		insertLineStart( parag, i, lineStart );
 		c->lineStart = 1;
 		firstChar = c;
 	    } else {
 		tmph = c->height();
 		h = tmph;
 		delete lineStart2;
 	    }
 	    lineStart->h = h;
 	    lineStart->baseLine = h;
 	    tmpBaseLine = lineStart->baseLine;
 	    lastBreak = -2;
 	    x = 0xffffff;
 	    minw = QMAX( minw, tminw );
 
 	    int tw = ci->minimumWidth() + ( doc ? doc->leftMargin() : 0 );
 	    if ( tw < QWIDGETSIZE_MAX )
 		tminw = tw;
 	    else
 		tminw = marg;
  	    wused = QMAX( wused, ci->width );
 	    continue;
 	} else if ( c->isCustom() && ci->placement() != QTextCustomItem::PlaceInline ) {
 	    int tw = ci->minimumWidth();
 	    if ( tw < QWIDGETSIZE_MAX )
 		minw = QMAX( minw, tw );
 	}
 
 	bool lastWasOwnLineCustomItem = lastBreak == -2;
 	bool hadBreakableChar = lastBreak != -1;
 	bool lastWasHardBreak = lastChr == QChar_linesep;
 
 	// we break if
 	// 1. the last character was a hard break (QChar_linesep) or
 	// 2. the last charater was a own-line custom item (eg. table or ruler) or
 	// 3. wrapping was enabled, it was not a space and following
 	// condition is true: We either had a breakable character
 	// previously or we ar allowed to break in words and - either
 	// we break at w pixels and the current char would exceed that
 	// or - we break at a column and the current character would
 	// exceed that.
 	if ( lastWasHardBreak || lastWasOwnLineCustomItem ||
 	     ( wrapEnabled &&
 	       ( (!c->c.isSpace() && (hadBreakableChar || allowBreakInWords()) &&
diff --git a/noncore/settings/networksettings2/opietooth2/OTSDPAttribute.cpp b/noncore/settings/networksettings2/opietooth2/OTSDPAttribute.cpp
index 9069c09..3fd877f 100644
--- a/noncore/settings/networksettings2/opietooth2/OTSDPAttribute.cpp
+++ b/noncore/settings/networksettings2/opietooth2/OTSDPAttribute.cpp
@@ -202,128 +202,131 @@ void OTSDPAttribute::setInt(const OTSDPAttribute::int128_t & val) {
 void OTSDPAttribute::setUInt(const uint128_t & val) {
     type = UINT;
     Value.uintVal = new uint128_t(val);
 }
 
 void OTSDPAttribute::setUUID(const OTUUID & val) {
     type = UUID;
     Value.uuidVal = new OTUUID( val );
 }
 
 void OTSDPAttribute::setBool(bool val) {
     type = BOOLEAN;
     Value.boolVal = val;
 }
 
 void OTSDPAttribute::setString( const QString & val) {
     type = STRING;
     Value.stringVal = new QString( val );
 }
 
 void OTSDPAttribute::setURL( const QString & val) {
     type = URL;
     Value.stringVal = new QString(val);
 }
 
 void OTSDPAttribute::setSequence(const AttributeVector& val) {
     type = SEQUENCE;
     Value.sequenceVal = new AttributeVector();
     Value.sequenceVal->setAutoDelete( TRUE );
     *Value.sequenceVal = val;
 }
 
 void OTSDPAttribute::setAlternative(const AttributeVector& val) {
     type = ALTERNATIVE;
     Value.sequenceVal = new AttributeVector();
     Value.sequenceVal->setAutoDelete( TRUE );
     *Value.sequenceVal = val;
 }
 
 QString OTSDPAttribute::getString() {
     assert(type == STRING);
     return *Value.stringVal;
 }
 
 QString OTSDPAttribute::getURL() {
     assert(type == URL);
     return *Value.stringVal;
 }
 
 const OTSDPAttribute::int128_t & OTSDPAttribute::getInt() {
     assert(type == INT);
     return *Value.intVal;
 }
 
 
 const OTSDPAttribute::uint128_t & OTSDPAttribute::getUInt() {
     assert(type == UINT);
     return *Value.uintVal;
 }
 
 const OTUUID & OTSDPAttribute::getUUID() {
     assert(type == UUID);
     return *Value.uuidVal;
 }
 
 bool OTSDPAttribute::getBool() {
     assert(type == BOOLEAN);
     return Value.boolVal;
 }
 
 AttributeVector * OTSDPAttribute::getSequence() {
     assert(type == SEQUENCE);
     return Value.sequenceVal;
 }
 
 AttributeVector * OTSDPAttribute::getAlternative() {
     assert(type == ALTERNATIVE);
     return Value.sequenceVal;
 }
 
 UUIDVector OTSDPAttribute::getAllUUIDs() {
 
     UUIDVector uuids;
 
     if (getType() == UUID) {
       uuids.resize( uuids.size()+1 );
       uuids[uuids.size()-1] = getUUID();
     } else {
       AttributeVector * subAttributes = 0 ;
 
       if (getType() == SEQUENCE) {
           subAttributes = getSequence();
       } else if (getType() == ALTERNATIVE) {
           subAttributes = getAlternative();
       }
 
+      if (!subAttributes)
+          return 0;
+
       int os;
       for( unsigned int i = 0; i < subAttributes->count(); i++ ) {
         UUIDVector subUUIDs = (*subAttributes)[i]->getAllUUIDs();
 
         os = uuids.size();
         uuids.resize( uuids.size()+subUUIDs.count() );
 
         for( unsigned int k = 0; k < subUUIDs.count(); k++ ) {
           uuids[os + k] = subUUIDs[k];
         }
       }
     }
     return uuids;
 }
 
 static char * Attr2String[] = {
         "Invalid",
         "Nil",
         "UInt",
         "int",
         "UUID",
         "Boolean",
         "String",
         "Sequence",
         "Alternative",
         "URL",
         "Unknown"
 };
 
 const char * OTSDPAttribute::getTypeString() {
     return Attr2String[type];
 }
diff --git a/noncore/settings/packagemanager/oipkgconfigdlg.cpp b/noncore/settings/packagemanager/oipkgconfigdlg.cpp
index d014378..78a18f7 100644
--- a/noncore/settings/packagemanager/oipkgconfigdlg.cpp
+++ b/noncore/settings/packagemanager/oipkgconfigdlg.cpp
@@ -343,207 +343,209 @@ void OIpkgConfigDlg::initOptionsWidget()
     m_optForceRecursive = new QCheckBox( tr( "Force Recursive" ), container );
     QWhatsThis::add( m_optForceRecursive, tr( "Tap here to enable or disable the '-recursive' option for Ipkg." ) );
     layout->addMultiCellWidget( m_optForceRecursive, 4, 4, 0, 1 );
 
     m_optVerboseWget = new QCheckBox( tr( "Verbose fetch" ), container );
     QWhatsThis::add( m_optVerboseWget, tr( "Tap here to enable or disable the '-verbose_wget' option for Ipkg." ) );
     layout->addMultiCellWidget( m_optVerboseWget, 5, 5, 0, 1 );
 
     QLabel *l = new QLabel( tr( "Information level:" ), container );
     QWhatsThis::add( l, tr( "Select information level for Ipkg." ) );
     layout->addMultiCellWidget( l, 6, 6, 0, 1 );
 
     m_optVerboseIpkg = new QComboBox( container );
     QWhatsThis::add( m_optVerboseIpkg, tr( "Select information level for Ipkg." ) );
     m_optVerboseIpkg->insertItem( tr( "Errors only" ) );
     m_optVerboseIpkg->insertItem( tr( "Normal messages" ) );
     m_optVerboseIpkg->insertItem( tr( "Informative messages" ) );
     m_optVerboseIpkg->insertItem( tr( "Troubleshooting output" ) );
     layout->addMultiCellWidget( m_optVerboseIpkg, 7, 7, 0, 1 );
 
     l = new QLabel( tr( "Package source lists directory:" ), container );
     QWhatsThis::add( l, tr( "Enter the directory where package source feed information is stored." ) );
     layout->addMultiCellWidget( l, 8, 8, 0, 1 );
 
     m_optSourceLists = new QLineEdit( container );
     QWhatsThis::add( m_optSourceLists, tr( "Enter the directory where package source feed information is stored." ) );
     layout->addWidget( m_optSourceLists, 9, 0 );
 
     QPushButton *btn = new QPushButton( Opie::Core::OResource::loadPixmap( "folder", Opie::Core::OResource::SmallIcon ),
                                         QString::null, container );
     btn->setMinimumHeight( AppLnk::smallIconSize()+4 );
     btn->setMaximumWidth( btn->height() );
     QWhatsThis::add( btn, tr( "Tap here to select the directory where package source feed information is stored." ) );
     connect( btn, SIGNAL(clicked()), this, SLOT(slotOptSelectSourceListsPath()) );
     layout->addWidget( btn, 9, 1 );
 
     layout->addItem( new QSpacerItem( 1, 1, QSizePolicy::Minimum, QSizePolicy::Expanding ) );
 }
 
 void OIpkgConfigDlg::initData()
 {
     // Read ipkg configuration (server/destination/proxy) information
     if ( m_ipkg && !m_installOptions )
     {
         m_configs = m_ipkg->configItems();
         if ( m_configs )
         {
             for ( OConfItemListIterator configIt( *m_configs ); configIt.current(); ++configIt )
             {
                 OConfItem *config = configIt.current();
 
                 // Add configuration item to the appropriate dialog controls
                 if ( config )
                 {
                     switch ( config->type() )
                     {
                         case OConfItem::Source :  m_serverList->insertItem( config->name() ); break;
                         case OConfItem::Destination : m_destList->insertItem( config->name() ); break;
                         case OConfItem::Option :
                             {
                                 if ( config->name() == "http_proxy" )
                                 {
                                     m_proxyHttpServer->setText( config->value() );
                                     m_proxyHttpActive->setChecked( config->active() );
                                 }
                                 else if ( config->name() == "ftp_proxy" )
                                 {
                                     m_proxyFtpServer->setText( config->value() );
                                     m_proxyFtpActive->setChecked( config->active() );
                                 }
                                 else if ( config->name() == "proxy_username" )
                                 {
                                     m_proxyUsername->setText( config->value() );
                                 }
                                 else if ( config->name() == "proxy_password" )
                                 {
                                     m_proxyPassword->setText( config->value() );
                                 }
                             }
                             break;
                         case OConfItem::Other :
                             {
                                 if ( config->name() == "lists_dir" )
                                     m_optSourceLists->setText( config->value() );
                                 else // TODO - use proper libipkg define
                                     m_optSourceLists->setText( "/usr/lib/ipkg/lists" );
                             }
                             break;
                         default : break;
                     };
                 }
             }
         }
     }
 
     // Get Ipkg execution options
-    int options = m_ipkg->ipkgExecOptions();
+    int options = 0;
+    if ( m_ipkg )
+        options = m_ipkg->ipkgExecOptions();
     if ( options & FORCE_DEPENDS )
         m_optForceDepends->setChecked( true );
     if ( options & FORCE_REINSTALL )
         m_optForceReinstall->setChecked( true );
     if ( options & FORCE_REMOVE )
         m_optForceRemove->setChecked( true );
     if ( options & FORCE_OVERWRITE )
         m_optForceOverwrite->setChecked( true );
     if ( options & FORCE_RECURSIVE )
         m_optForceRecursive->setChecked( true );
     if ( options & FORCE_VERBOSE_WGET )
         m_optVerboseWget->setChecked( true );
 
-    m_optVerboseIpkg->setCurrentItem( m_ipkg->ipkgExecVerbosity() );
+    m_optVerboseIpkg->setCurrentItem( ( m_ipkg ? m_ipkg->ipkgExecVerbosity() : 0 ) );
 }
 
 void OIpkgConfigDlg::slotServerSelected( int index )
 {
     m_serverCurrent = index;
 
     // Enable Edit and Delete buttons
     m_serverEditBtn->setEnabled( true );
     m_serverDeleteBtn->setEnabled( true );
 }
 
 void OIpkgConfigDlg::slotServerNew()
 {
     OConfItem *server = new OConfItem( OConfItem::Source );
 
     OIpkgServerDlg dlg( server, this );
     if ( QPEApplication::execDialog( &dlg ) == QDialog::Accepted )
     {
         // Add to configuration option list
         m_configs->append( server );
         m_configs->sort();
 
         // Add to server list
         m_serverList->insertItem( server->name() );
         m_serverList->setCurrentItem( m_serverList->count() );
     }
     else
         delete server;
 }
 
 void OIpkgConfigDlg::slotServerEdit()
 {
     // Find selected server in list
     OConfItem *server = m_ipkg->findConfItem( OConfItem::Source, m_serverList->currentText() );
 
     // Edit server
     if ( server )
     {
         QString origName = server->name();
         OIpkgServerDlg dlg( server, this );
         if ( QPEApplication::execDialog( &dlg ) == QDialog::Accepted )
         {
             // Check to see if name has changed, if so update the server list
             if ( server->name() != origName )
                 m_serverList->changeItem( server->name(), m_serverCurrent );
         }
     }
 }
 
 void OIpkgConfigDlg::slotServerDelete()
 {
     // Find selected server in list
     OConfItem *server = m_ipkg->findConfItem( OConfItem::Source, m_serverList->currentText() );
 
     // Delete server
     if ( server )
     {
         m_configs->removeRef( server );
         m_serverList->removeItem( m_serverCurrent );
     }
 }
 
 void OIpkgConfigDlg::slotDestSelected( int index )
 {
     m_destCurrent = index;
 
     // Enable Edit and Delete buttons
     m_destEditBtn->setEnabled( true );
     m_destDeleteBtn->setEnabled( true );
 }
 
 void OIpkgConfigDlg::slotDestNew()
 {
     OConfItem *dest = new OConfItem( OConfItem::Destination );
 
     OIpkgDestDlg dlg( dest, this );
     if ( QPEApplication::execDialog( &dlg ) == QDialog::Accepted )
     {
         // Add to configuration option list
         m_configs->append( dest );
         m_configs->sort();
 
         // Add to destination list
         m_destList->insertItem( dest->name() );
         m_destList->setCurrentItem( m_destList->count() );
     }
     else
         delete dest;
 }
 
 void OIpkgConfigDlg::slotDestEdit()
 {
     // Find selected destination in list
     OConfItem *dest = m_ipkg->findConfItem( OConfItem::Destination, m_destList->currentText() );
 
     // Edit destination