1 files changed, 16 insertions, 14 deletions

diff --git a/microkde/kurl.cpp b/microkde/kurl.cpp
index 2574e25..122ad71 100644
--- a/microkde/kurl.cpp
+++ b/microkde/kurl.cpp
@@ -25,48 +25,50 @@
 //US#include <kidna.h>
 #endif
 
 #include <stdio.h>
 #include <assert.h>
 #include <ctype.h>
 #include <stdlib.h>
 #ifdef _WIN32_
 
 #else
 #include <unistd.h>
 #endif
-#include <qurl.h>
+#include <q3url.h>
 #include <qdir.h>
 #include <qstringlist.h>
 #include <qregexp.h>
 //US#include <qstylesheet.h>
 #include <qmap.h>
 #include <qtextcodec.h>
+//Added by qt3to4:
+#include <Q3CString>
 
 static const QString fileProt = "file";
 
 static QTextCodec * codecForHint( int encoding_hint /* not 0 ! */ )
 {
     return QTextCodec::codecForMib( encoding_hint );
 }
 
 static QString encode( const QString& segment, bool encode_slash, int encoding_hint )
 {
   const char *encode_string;
   if (encode_slash)
     encode_string = "<>#@\"&%?={}|^~[]\'`\\:+/";
   else
     encode_string = "<>#@\"&%?={}|^~[]\'`\\:+";
 
-  QCString local;
+  Q3CString local;
   if (encoding_hint==0)
     local = segment.local8Bit();
   else
   {
       QTextCodec * textCodec = codecForHint( encoding_hint );
       if (!textCodec)
           local = segment.local8Bit();
       else
           local = textCodec->fromUnicode( segment );
   }
 
   int old_length = local.length();
@@ -91,25 +93,25 @@ static QString encode( const QString& segment, bool encode_slash, int encoding_h
       new_segment[ new_length++ ] = '%';
 
       unsigned int c = character / 16;
       c += (c > 9) ? ('A' - 10) : '0';
       new_segment[ new_length++ ] = c;
 
       c = character % 16;
       c += (c > 9) ? ('A' - 10) : '0';
       new_segment[ new_length++ ] = c;
 
     }
     else
-      new_segment[ new_length++ ] = local[i];
+      new_segment[ new_length++ ] = character;
   }
 
   QString result = QString(new_segment, new_length);
   delete [] new_segment;
   return result;
 }
 
 static QString encodeHost( const QString& segment, bool encode_slash, int encoding_hint )
 {
   // Hostnames are encoded differently
   // we use the IDNA transformation instead
 
@@ -196,25 +198,25 @@ static void decode( const QString& segment, QString &decoded, QString &encoded,
 
   int old_length = segment.length();
   if ( !old_length )
     return;
 
   QTextCodec *textCodec = 0;
   if (encoding_hint)
       textCodec = codecForHint( encoding_hint );
 
   if (!textCodec)
       textCodec = QTextCodec::codecForLocale();
 
-  QCString csegment = textCodec->fromUnicode(segment);
+  Q3CString csegment = textCodec->fromUnicode(segment);
   // Check if everything went ok
   if (textCodec->toUnicode(csegment) != segment)
   {
       // Uh oh
       textCodec = codecForHint( 106 ); // Fall back to utf-8
       csegment = textCodec->fromUnicode(segment);
   } 
   old_length = csegment.length();
 
   int new_length = 0;
   int new_length2 = 0;
 
@@ -269,25 +271,25 @@ static void decode( const QString& segment, QString &decoded, QString &encoded,
   }
   new_segment [ new_length ] = 0;
 
   encoded = QString( new_usegment, new_length2);
 
   // Encoding specified
   if (updateDecoded)
   {
      QByteArray array;
      array.setRawData(new_segment, new_length);
      decoded = textCodec->toUnicode( array, new_length );
      array.resetRawData(new_segment, new_length);
-     QCString validate = textCodec->fromUnicode(decoded);
+     Q3CString validate = textCodec->fromUnicode(decoded);
 
      if (strcmp(validate.data(), new_segment) != 0)
      {
         decoded = QString::fromLocal8Bit(new_segment, new_length);
      }
   }
 
   delete [] new_segment;
   delete [] new_usegment;
 }
 
 static QString decode(const QString &segment, int encoding_hint = 0)
@@ -410,25 +412,25 @@ KURL::~KURL()
 KURL::KURL( const QString &url, int encoding_hint )
 {
   reset();
   parse( url, encoding_hint );
 }
 
 KURL::KURL( const char * url, int encoding_hint )
 {
   reset();
   parse( QString::fromLatin1(url), encoding_hint );
 }
 
-KURL::KURL( const QCString& url, int encoding_hint )
+KURL::KURL( const Q3CString& url, int encoding_hint )
 {
   reset();
   parse( QString::fromLatin1(url), encoding_hint );
 }
 
 KURL::KURL( const KURL& _u )
 {
   *this = _u;
 }
 
 QDataStream & operator<< (QDataStream & s, const KURL & a)
 {
@@ -451,25 +453,25 @@ QDataStream & operator>> (QDataStream & s, KURL & a)
       >> malf >> a.m_iPort;
     a.m_bIsMalformed = (malf != 0);
 
     if ( QueryFromWire.isEmpty() )
       a.m_strQuery_encoded = QString::null;
     else
       a.m_strQuery_encoded = QueryFromWire.mid(1);
 
     return s;
 }
 
 #ifndef QT_NO_NETWORKPROTOCOL
-KURL::KURL( const QUrl &u )
+KURL::KURL( const Q3Url &u )
 {
   *this = u;
 }
 #endif
 
 KURL::KURL( const KURL& _u, const QString& _rel_url, int encoding_hint )
 {
   // WORKAROUND THE RFC 1606 LOOPHOLE THAT ALLOWS
   // http:/index.html AS A VALID SYNTAX FOR RELATIVE
   // URLS. ( RFC 2396 section 5.2 item # 3 )
   QString rUrl = _rel_url;
   int len = _u.m_strProtocol.length();
@@ -580,31 +582,31 @@ void KURL::parse( const QString& _url, int encoding_hint )
   const QChar* buf = _url.unicode();
   const QChar* orig = buf;
 
   QChar delim;
   QString tmp;
 
   uint pos = 0;
 
   // Node 1: Accept alpha or slash
   QChar x = buf[pos++];
   if ( x == '/' )
     goto Node9;
-  if ( !isalpha( (int)x ) )
+  if ( !x.isLetter() )
     goto NodeErr;
 
   // Node 2: Accept any amount of (alpha|digit|'+'|'-')
   // '.' is not currently accepted, because current KURL may be confused.
   // Proceed with :// :/ or :
-  while( pos < len && (isalpha((int)buf[pos]) || isdigit((int)buf[pos]) ||
+  while( pos < len && ( buf[pos].isLetter() || buf[pos].isDigit() ||
           buf[pos] == '+' || buf[pos] == '-')) pos++;
 
   if ( pos+2 < len && buf[pos] == ':' && buf[pos+1] == '/' && buf[pos+2] == '/' )
     {
       m_strProtocol = QString( orig, pos ).lower();
       pos += 3;
     }
   else if (pos+1 < len && buf[pos] == ':' ) // Need to always compare length()-1 otherwise KURL passes "http:" as legal!!
     {
       m_strProtocol = QString( orig, pos ).lower();
       //kdDebug(126)<<"setting protocol to "<<m_strProtocol<<endl;
       pos++;
@@ -760,29 +762,29 @@ void KURL::parse( const QString& _url, int encoding_hint )
     {
       start = pos++;
       goto Node9;
     }
   else if ( x != ':' )
     goto NodeErr;
   pos++;
 
   // Node 8a: Accept at least one digit
   if ( pos == len )
     goto NodeErr;
   start = pos;
-  if ( !isdigit( buf[pos++] ) )
+  if ( !buf[pos++].isDigit() )
     goto NodeErr;
 
   // Node 8b: Accept any amount of digits
-  while( pos < len && isdigit( buf[pos] ) ) pos++;
+  while( pos < len && buf[pos].isDigit() ) pos++;
   port = QString( buf + start, pos - start );
   m_iPort = port.toUShort();
   if ( pos == len )
     goto NodeOk;
   start = pos++;
 
  Node9: // parse path until query or reference reached
 
   while( pos < len && buf[pos] != '#' && buf[pos]!='?' ) pos++;
 
   tmp = QString( buf + start, pos - start );
   //kdDebug(126)<<" setting encoded path&query to:"<<tmp<<endl;
@@ -839,25 +841,25 @@ KURL& KURL::operator=( const QString& _url )
   return *this;
 }
 
 KURL& KURL::operator=( const char * _url )
 {
   reset();
   parse( QString::fromLatin1(_url) );
 
   return *this;
 }
 
 #ifndef QT_NO_NETWORKPROTOCOL
-KURL& KURL::operator=( const QUrl & u )
+KURL& KURL::operator=( const Q3Url & u )
 {
   m_strProtocol = u.protocol();
   m_strUser = u.user();
   m_strPass = u.password();
   m_strHost = u.host();
   m_strPath = u.path( FALSE );
   m_strPath_encoded = QString::null;
   m_strQuery_encoded = u.query();
   m_strRef_encoded = u.ref();
   m_bIsMalformed = !u.isValid();
   m_iPort = u.port();
 
@@ -1365,25 +1367,25 @@ KURL::List KURL::split( const QString& _url )
 
 KURL KURL::join( const KURL::List & lst )
 {
   if (lst.isEmpty()) return KURL();
   KURL tmp;
 
   KURL::List::ConstIterator first = lst.fromLast();
   for( KURL::List::ConstIterator it = first; it != lst.end(); --it )
   {
      KURL u(*it);
      if (it != first)
      {
-        if (!u.m_strRef_encoded) u.m_strRef_encoded = tmp.url();
+        if (u.m_strRef_encoded.isEmpty()) u.m_strRef_encoded = tmp.url();
         else u.m_strRef_encoded += "#" + tmp.url(); // Support more than one suburl thingy
      }
      tmp = u;
   }
 
   return tmp;
 }
 
 QString KURL::fileName( bool _strip_trailing_slash ) const
 {
   QString fname;
   if (hasSubURL()) { // If we have a suburl, then return the filename from there
@@ -1409,25 +1411,25 @@ QString KURL::fileName( bool _strip_trailing_slash ) const
   if ( len == 1 && path[ 0 ] == '/' )
     return fname;
 
   // Skip last n slashes
   int n = 1;
   if (!m_strPath_encoded.isEmpty())
   {
      // This is hairy, we need the last unencoded slash.
      // Count in the encoded string how many encoded slashes follow the last
      // unencoded one.
      int i = m_strPath_encoded.findRev( '/', len - 1 );
      QString fileName_encoded = m_strPath_encoded.mid(i+1);
-     n += fileName_encoded.contains("%2f", false);
+     n += fileName_encoded.count("%2f", Qt::CaseInsensitive);
   }
   int i = len;
   do {
     i = path.findRev( '/', i - 1 );
   }
   while (--n && (i > 0));
 
   // If ( i == -1 ) => the first character is not a '/'
   // So it's some URL like file:blah.tgz, return the whole path
   if ( i == -1 ) {
     if ( len == (int)path.length() )
       fname = path;