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
@@ -1,1942 +1,1944 @@
 /*
     Copyright (C) 1999 Torben Weis <weis@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include "kurl.h"
 
 #ifndef KDE_QT_ONLY
 #include <kdebug.h>
 #include <kglobal.h>
 //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();
 
   if ( !old_length )
     return segment.isNull() ? QString::null : QString(""); // differenciate null and empty
 
   // a worst case approximation
   QChar *new_segment = new QChar[ old_length * 3 + 1 ];
   int new_length = 0;
 
   for ( int i = 0; i < old_length; i++ )
   {
     // 'unsave' and 'reserved' characters
     // according to RFC 1738,
     // 2.2. URL Character Encoding Issues (pp. 3-4)
     // WABA: Added non-ascii
     unsigned char character = local[i];
     if ( (character <= 32) || (character >= 127) ||
          strchr(encode_string, character) )
     {
       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
 
   // Note: when merging qt-addon, use QResolver::domainToAscii here
 #ifndef KDE_QT_ONLY
   Q_UNUSED( encode_slash );
   Q_UNUSED( encoding_hint );
   return KIDNA::toAscii(segment);
 #else
   return encode(segment, encode_slash, encoding_hint);
 #endif
 }
 
 static int hex2int( unsigned int _char )
 {
   if ( _char >= 'A' && _char <='F')
     return _char - 'A' + 10;
   if ( _char >= 'a' && _char <='f')
     return _char - 'a' + 10;
   if ( _char >= '0' && _char <='9')
     return _char - '0';
   return -1;
 }
 
 // WABA: The result of lazy_encode isn't usable for a URL which
 // needs to satisfies RFC requirements. However, the following
 // operation will make it usable again:
 //      encode(decode(...))
 //
 // As a result one can see that url.prettyURL() does not result in
 // a RFC compliant URL but that the following sequence does:
 //      KURL(url.prettyURL()).url()
 
 
 static QString lazy_encode( const QString& segment )
 {
   int old_length = segment.length();
 
   if ( !old_length )
     return QString::null;
 
   // a worst case approximation
   QChar *new_segment = new QChar[ old_length * 3 + 1 ];
   int new_length = 0;
 
   for ( int i = 0; i < old_length; i++ )
   {
     unsigned int character = segment[i].unicode(); // Don't use latin1()
                                                    // It returns 0 for non-latin1 values
     // Small set of really ambiguous chars
     if ((character < 32) ||  // Low ASCII
         ((character == '%') && // The escape character itself
            (i+2 < old_length) && // But only if part of a valid escape sequence!
           (hex2int(segment[i+1].unicode())!= -1) &&
           (hex2int(segment[i+2].unicode())!= -1)) ||
         (character == '?') || // Start of query delimiter
         (character == '@') || // Username delimiter
         (character == '#') || // Start of reference delimiter
         ((character == 32) && (i+1 == old_length))) // A trailing space
     {
       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++ ] = segment[i];
   }
 
   QString result = QString(new_segment, new_length);
   delete [] new_segment;
   return result;
 }
 
 static void decode( const QString& segment, QString &decoded, QString &encoded, int encoding_hint=0, bool updateDecoded = true )
 {
   decoded = QString::null;
   encoded = segment;
 
   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;
 
   // make a copy of the old one
   char *new_segment = new char[ old_length + 1 ];
   QChar *new_usegment = new QChar[ old_length * 3 + 1 ];
 
   int i = 0;
   while( i < old_length )
   {
     bool bReencode = false;
     unsigned char character = csegment[ i++ ];
     if ((character <= ' ') || (character > 127))
        bReencode = true;
 
     new_usegment [ new_length2++ ] = character;
     if (character == '%' )
     {
       int a = i+1 < old_length ? hex2int( csegment[i] ) : -1;
       int b = i+1 < old_length ? hex2int( csegment[i+1] ) : -1;
       if ((a == -1) || (b == -1)) // Only replace if sequence is valid
       {
          // Contains stray %, make sure to re-encode!
          bReencode = true;
       }
       else
       {
          // Valid %xx sequence
          character = a * 16 + b; // Replace with value of %dd
          if (!character && updateDecoded)
             break; // Stop at %00
 
          new_usegment [ new_length2++ ] = (unsigned char) csegment[i++];
          new_usegment [ new_length2++ ] = (unsigned char) csegment[i++];
       }
     }
     if (bReencode)
     {
       new_length2--;
       new_usegment [ new_length2++ ] = '%';
 
       unsigned int c = character / 16;
       c += (c > 9) ? ('A' - 10) : '0';
       new_usegment[ new_length2++ ] = c;
 
       c = character % 16;
       c += (c > 9) ? ('A' - 10) : '0';
       new_usegment[ new_length2++ ] = c;
     }
 
     new_segment [ new_length++ ] = character;
   }
   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)
 {
   QString result;
   QString tmp;
   decode(segment, result, tmp, encoding_hint);
   return result;
 }
 
 static QString cleanpath(const QString &path, bool cleanDirSeparator=true)
 {
   if (path.isEmpty()) return QString::null;
   int len = path.length();
   bool slash = (len && path[len-1] == '/') ||
                (len > 1 && path[len-2] == '/' && path[len-1] == '.');
 
   // The following code cleans up directory path much like
   // QDir::cleanDirPath() except it can be made to ignore multiple
   // directory separators by setting the flag to false.  That fixes
   // bug# 15044, mail.altavista.com and other similar brain-dead server
   // implementations that do not follow what has been specified in
   // RFC 2396!! (dA)
   QString result;
   int cdUp, orig_pos, pos;
 
   cdUp = 0;
   pos = orig_pos = len;
   while ( pos && (pos = path.findRev('/',--pos)) != -1 )
   {
     len = orig_pos - pos - 1;
     if ( len == 2 && path[pos+1] == '.' && path[pos+2] == '.' )
       cdUp++;
     else
     {
       // Ignore any occurances of '.'
       // This includes entries that simply do not make sense like /..../
       if ( (len || !cleanDirSeparator) &&
            (len != 1 || path[pos+1] != '.' ) )
       {
           if ( !cdUp )
               result.prepend(path.mid(pos, len+1));
           else
               cdUp--;
       }
     }
     orig_pos = pos;
   }
 
   if ( result.isEmpty() )
     result = "/";
   else if ( slash && result.at(result.length()-1) != '/' )
        result.append('/');
 
   return result;
 }
 
 bool KURL::isRelativeURL(const QString &_url)
 {
   int len = _url.length();
   if (!len) return true; // Very short relative URL.
   const QChar *str = _url.unicode();
 
   // Absolute URL must start with alpha-character
   if (!isalpha(str[0].latin1()))
      return true; // Relative URL
 
   for(int i = 1; i < len; i++)
   {
      char c = str[i].latin1(); // Note: non-latin1 chars return 0!
      if (c == ':')
         return false; // Absolute URL
 
      // Protocol part may only contain alpha, digit, + or -
      if (!isalpha(c) && !isdigit(c) && (c != '+') && (c != '-'))
         return true; // Relative URL
   }
   // URL did not contain ':'
   return true; // Relative URL
 }
 
 KURL::List::List(const KURL &url)
 {
     append( url );
 }
 
 KURL::List::List(const QStringList &list)
 {
   for (QStringList::ConstIterator it = list.begin();
        it != list.end();
        it++)
     {
       append( KURL(*it) );
     }
 }
 
 QStringList KURL::List::toStringList() const
 {
   QStringList lst;
    for( KURL::List::ConstIterator it = begin();
         it != end();
         it++)
    {
       lst.append( (*it).url() );
    }
    return lst;
 }
 
 
 KURL::KURL()
 {
   reset();
 }
 
 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)
 {
   QString QueryForWire=a.m_strQuery_encoded;
   if (!a.m_strQuery_encoded.isNull())
     QueryForWire.prepend("?");
 
     s << a.m_strProtocol << a.m_strUser << a.m_strPass << a.m_strHost
       << a.m_strPath << a.m_strPath_encoded << QueryForWire << a.m_strRef_encoded
       << Q_INT8(a.m_bIsMalformed ? 1 : 0) << a.m_iPort;
     return s;
 }
 
 QDataStream & operator>> (QDataStream & s, KURL & a)
 {
     Q_INT8 malf;
     QString QueryFromWire;
     s >> a.m_strProtocol >> a.m_strUser >> a.m_strPass >> a.m_strHost
       >> a.m_strPath >> a.m_strPath_encoded >> QueryFromWire >> a.m_strRef_encoded
       >> 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();
   if ( !_u.m_strHost.isEmpty() && !rUrl.isEmpty() &&
        rUrl.find( _u.m_strProtocol, 0, false ) == 0 &&
        rUrl[len] == ':' && (rUrl[len+1] != '/' ||
        (rUrl[len+1] == '/' && rUrl[len+2] != '/')) )
   {
     rUrl.remove( 0, rUrl.find( ':' ) + 1 );
   }
 
   if ( rUrl.isEmpty() )
   {
     *this = _u;
   }
   else if ( rUrl[0] == '#' )
   {
     *this = _u;
     QString ref = decode(rUrl.mid(1), encoding_hint);
     if ( ref.isNull() )
         ref = ""; // we know there was an (empty) html ref, we saw the '#'
     setHTMLRef( ref );
   }
   else if ( isRelativeURL( rUrl) )
   {
     *this = _u;
     m_strQuery_encoded = QString::null;
     m_strRef_encoded = QString::null;
     if ( rUrl[0] == '/')
     {
         if ((rUrl.length() > 1) && (rUrl[1] == '/'))
         {
            m_strHost = QString::null;
         }
         m_strPath = QString::null;
         m_strPath_encoded = QString::null;
     }
     else if ( rUrl[0] != '?' )
     {
        int pos = m_strPath.findRev( '/' );
        if (pos >= 0)
           m_strPath.truncate(pos);
        m_strPath += '/';
        if (!m_strPath_encoded.isEmpty())
        {
           pos = m_strPath_encoded.findRev( '/' );
           if (pos >= 0)
              m_strPath_encoded.truncate(pos);
           m_strPath_encoded += '/';
        }
     }
     else
     {
        if ( m_strPath.isEmpty() )
           m_strPath = '/';
     }
     KURL tmp( url() + rUrl, encoding_hint);
     *this = tmp;
     cleanPath(false);
   }
   else
   {
     KURL tmp( rUrl, encoding_hint);
     *this = tmp;
     // Preserve userinfo if applicable.
     if (!_u.m_strUser.isEmpty() && m_strUser.isEmpty() && (_u.m_strHost == m_strHost) && (_u.m_strProtocol == m_strProtocol))
     {
        m_strUser = _u.m_strUser;
        m_strPass = _u.m_strPass;
     }
   }
 }
 
 void KURL::reset()
 {
   m_strProtocol = QString::null;
   m_strUser = QString::null;
   m_strPass = QString::null;
   m_strHost = QString::null;
   m_strPath = QString::null;
   m_strPath_encoded = QString::null;
   m_strQuery_encoded = QString::null;
   m_strRef_encoded = QString::null;
   m_bIsMalformed = true;
   m_iPort = 0;
 }
 
 bool KURL::isEmpty() const
 {
   return (m_strPath.isEmpty() && m_strProtocol.isEmpty());
 }
 
 void KURL::parse( const QString& _url, int encoding_hint )
 {
   //kdDebug(126) << "parse " << _url << endl;
   // Return immediately whenever the given url
   // is empty or null.
   if ( _url.isEmpty() )
   {
     m_strProtocol = _url;
     return;
   }
 
   QString port;
   bool badHostName = false;
   int start = 0;
   uint len = _url.length();
   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++;
       start = pos;
       goto Node9;
     }
   else
     goto NodeErr;
 
   //Node 3: We need at least one character here
   if ( pos == len )
       goto NodeErr;
   start = pos;
 
   // Node 4: Accept any amount of characters.
   if (buf[pos] == '[')     // An IPv6 host follows.
       goto Node8;
   // Terminate on / or @ or ? or # or " or ; or <
   x = buf[pos];
   while( (x != ':') && (x != '@') && (x != '/') && (x != '?') && (x != '#') )
   {
      if ((x == '\"') || (x == ';') || (x == '<'))
         badHostName = true;
      if (++pos == len)
         break;
      x = buf[pos];
   }
   if ( pos == len )
     {
       if (badHostName)
          goto NodeErr;
 
       setHost(decode(QString( buf + start, pos - start ), encoding_hint));
       goto NodeOk;
     }
   if ( x == '@' )
     {
       m_strUser = decode(QString( buf + start, pos - start ), encoding_hint);
       pos++;
       goto Node7;
     }
   else if ( (x == '/') || (x == '?') || (x == '#'))
     {
       if (badHostName)
          goto NodeErr;
 
       setHost(decode(QString( buf + start, pos - start ), encoding_hint));
       start = pos;
       goto Node9;
     }
   else if ( x != ':' )
     goto NodeErr;
   m_strUser = decode(QString( buf + start, pos - start ), encoding_hint);
   pos++;
 
   // Node 5: We need at least one character
   if ( pos == len )
     goto NodeErr;
   start = pos++;
 
   // Node 6: Read everything until @, /, ? or #
   while( (pos < len) &&
                 (buf[pos] != '@') &&
                 (buf[pos] != '/') &&
                 (buf[pos] != '?') &&
                 (buf[pos] != '#')) pos++;
   // If we now have a '@' the ':' seperates user and password.
   // Otherwise it seperates host and port.
   if ( (pos == len) || (buf[pos] != '@') )
     {
       // Ok the : was used to separate host and port
       if (badHostName)
          goto NodeErr;
       setHost(m_strUser);
       m_strUser = QString::null;
       QString tmp( buf + start, pos - start );
       char *endptr;
       m_iPort = (unsigned short int)strtol(tmp.ascii(), &endptr, 10);
       if ((pos == len) && (strlen(endptr) == 0))
         goto NodeOk;
       // there is more after the digits
       pos -= strlen(endptr);
       start = pos++;
       goto Node9;
     }
   m_strPass = decode(QString( buf + start, pos - start), encoding_hint);
   pos++;
 
   // Node 7: We need at least one character
  Node7:
   if ( pos == len )
     goto NodeErr;
 
  Node8:
   if (buf[pos] == '[')
   {
     // IPv6 address
     start = ++pos; // Skip '['
 
     if (pos == len)
     {
        badHostName = true;
        goto NodeErr;
     }
     // Node 8b: Read everything until ] or terminate
     badHostName = false;
     x = buf[pos];
     while( (x != ']') )
     {
        if ((x == '\"') || (x == ';') || (x == '<'))
           badHostName = true;
        if (++pos == len)
        {
           badHostName = true;
           break;
        }
        x = buf[pos];
     }
     if (badHostName)
        goto NodeErr;
     setHost(decode(QString( buf + start, pos - start ), encoding_hint));
     if (pos < len) pos++; // Skip ']'
     if (pos == len)
        goto NodeOk;
   }
   else
   {
     // Non IPv6 address
     start = pos;
 
     // Node 8b: Read everything until / : or terminate
     badHostName = false;
     x = buf[pos];
     while( (x != ':') && (x != '@') && (x != '/') && (x != '?') && (x != '#') )
     {
        if ((x == '\"') || (x == ';') || (x == '<'))
           badHostName = true;
        if (++pos == len)
           break;
        x = buf[pos];
     }
     if (badHostName)
        goto NodeErr;
     if ( pos == len )
     {
        setHost(decode(QString( buf + start, pos - start ), encoding_hint));
        goto NodeOk;
     }
     setHost(decode(QString( buf + start, pos - start ), encoding_hint));
   }
   x = buf[pos];
   if ( x == '/' )
     {
       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;
   setEncodedPath( tmp, encoding_hint );
 
   if ( pos == len )
       goto NodeOk;
 
  //Node10: // parse query or reference depending on what comes first
   delim = (buf[pos++]=='#'?'?':'#');
 
   start = pos;
 
   while(pos < len && buf[pos]!=delim ) pos++;
 
   tmp = QString(buf + start, pos - start);
   if (delim=='#')
       setQuery(tmp, encoding_hint);
   else
       m_strRef_encoded = tmp;
 
   if (pos == len)
       goto NodeOk;
 
  //Node11: // feed the rest into the remaining variable
   tmp = QString( buf + pos + 1, len - pos - 1);
   if (delim == '#')
       m_strRef_encoded = tmp;
   else
       setQuery(tmp, encoding_hint);
 
  NodeOk:
   //kdDebug(126)<<"parsing finished. m_strProtocol="<<m_strProtocol<<" m_strHost="<<m_strHost<<" m_strPath="<<m_strPath<<endl;
   m_bIsMalformed = false; // Valid URL
 
   //kdDebug()<<"Prot="<<m_strProtocol<<"\nUser="<<m_strUser<<"\nPass="<<m_strPass<<"\nHost="<<m_strHost<<"\nPath="<<m_strPath<<"\nQuery="<<m_strQuery_encoded<<"\nRef="<<m_strRef_encoded<<"\nPort="<<m_iPort<<endl;
   if (m_strProtocol.isEmpty())
   {
     m_strProtocol = fileProt;
   }
   return;
 
  NodeErr:
 //  kdDebug(126) << "KURL couldn't parse URL \"" << _url << "\"" << endl;
   reset();
   m_strProtocol = _url;
 }
 
 KURL& KURL::operator=( const QString& _url )
 {
   reset();
   parse( _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();
 
   return *this;
 }
 #endif
 
 KURL& KURL::operator=( const KURL& _u )
 {
   m_strProtocol = _u.m_strProtocol;
   m_strUser = _u.m_strUser;
   m_strPass = _u.m_strPass;
   m_strHost = _u.m_strHost;
   m_strPath = _u.m_strPath;
   m_strPath_encoded = _u.m_strPath_encoded;
   m_strQuery_encoded = _u.m_strQuery_encoded;
   m_strRef_encoded = _u.m_strRef_encoded;
   m_bIsMalformed = _u.m_bIsMalformed;
   m_iPort = _u.m_iPort;
 
   return *this;
 }
 
 bool KURL::operator==( const KURL& _u ) const
 {
   if ( isMalformed() || _u.isMalformed() )
     return false;
 
   if ( m_strProtocol == _u.m_strProtocol &&
        m_strUser == _u.m_strUser &&
        m_strPass == _u.m_strPass &&
        m_strHost == _u.m_strHost &&
        m_strPath == _u.m_strPath &&
        // The encoded path may be null, but the URLs are still equal (David)
        ( m_strPath_encoded.isNull() || _u.m_strPath_encoded.isNull() ||
          m_strPath_encoded == _u.m_strPath_encoded ) &&
        m_strQuery_encoded == _u.m_strQuery_encoded &&
        m_strRef_encoded == _u.m_strRef_encoded &&
        m_iPort == _u.m_iPort )
   {
     return true;
   }
 
   return false;
 }
 
 bool KURL::operator==( const QString& _u ) const
 {
   KURL u( _u );
   return ( *this == u );
 }
 
 bool KURL::cmp( const KURL &u, bool ignore_trailing ) const
 {
   return equals( u, ignore_trailing );
 }
 
 bool KURL::equals( const KURL &_u, bool ignore_trailing ) const
 {
   if ( isMalformed() || _u.isMalformed() )
     return false;
 
   if ( ignore_trailing )
   {
     QString path1 = path(1);
     QString path2 = _u.path(1);
     if ( path1 != path2 )
       return false;
 
     if ( m_strProtocol == _u.m_strProtocol &&
          m_strUser == _u.m_strUser &&
          m_strPass == _u.m_strPass &&
          m_strHost == _u.m_strHost &&
          m_strQuery_encoded == _u.m_strQuery_encoded &&
          m_strRef_encoded == _u.m_strRef_encoded &&
          m_iPort == _u.m_iPort )
       return true;
 
     return false;
   }
 
   return ( *this == _u );
 }
 
 bool KURL::isParentOf( const KURL& _u ) const
 {
   if ( isMalformed() || _u.isMalformed() )
     return false;
 
   if ( m_strProtocol == _u.m_strProtocol &&
        m_strUser == _u.m_strUser &&
        m_strPass == _u.m_strPass &&
        m_strHost == _u.m_strHost &&
        m_strQuery_encoded == _u.m_strQuery_encoded &&
        m_strRef_encoded == _u.m_strRef_encoded &&
        m_iPort == _u.m_iPort )
   {
     if ( path().isEmpty() || _u.path().isEmpty() )
         return false; // can't work with implicit paths
 
     QString p1( cleanpath( path() ) );
     if ( p1.at(p1.length()-1) != '/' )
         p1 += '/';
     QString p2( cleanpath( _u.path() ) );
     if ( p2.at(p2.length()-1) != '/' )
         p2 += '/';
 
     //kdDebug(126) << "p1=" << p1 << endl;
     //kdDebug(126) << "p2=" << p2 << endl;
     //kdDebug(126) << "p1.length()=" << p1.length() << endl;
     //kdDebug(126) << "p2.left(!$)=" << p2.left( p1.length() ) << endl;
     return p2.startsWith( p1 );
   }
   return false;
 }
 
 void KURL::setFileName( const QString& _txt )
 {
   m_strRef_encoded = QString::null;
   int i = 0;
   while( _txt[i] == '/' ) ++i;
   QString tmp;
   if ( i )
     tmp = _txt.mid( i );
   else
     tmp = _txt;
 
   QString path = m_strPath_encoded.isEmpty() ? m_strPath : m_strPath_encoded;
   if ( path.isEmpty() )
     path = "/";
   else
   {
     int lastSlash = path.findRev( '/' );
     if ( lastSlash == -1)
     {
       // The first character is not a '/' ???
       // This looks strange ...
       path = "/";
     }
     else if ( path.right(1) != "/" )
       path.truncate( lastSlash+1 ); // keep the "/"
   }
   if (m_strPath_encoded.isEmpty())
   {
      path += tmp;
      setPath( path );
   }
   else
   {
      path += encode_string(tmp);
      setEncodedPath( path );
   }
   cleanPath();
 }
 
 void KURL::cleanPath( bool cleanDirSeparator ) // taken from the old KURL
 {
   m_strPath = cleanpath(m_strPath, cleanDirSeparator);
   // WABA: Is this safe when "/../" is encoded with %?
   m_strPath_encoded = cleanpath(m_strPath_encoded, cleanDirSeparator);
 }
 
 static QString trailingSlash( int _trailing, const QString &path )
 {
   QString result = path;
 
   if ( _trailing == 0 )
     return result;
   else if ( _trailing == 1 )
   {
     int len = result.length();
     if ( len == 0 )
       result = QString::null;
     else if ( result[ len - 1 ] != '/' )
       result += "/";
     return result;
   }
   else if ( _trailing == -1 )
   {
     if ( result == "/" )
       return result;
     int len = result.length();
     if ( len != 0 && result[ len - 1 ] == '/' )
       result.truncate( len - 1 );
     return result;
   }
   else {
     assert( 0 );
     return QString::null;
   }
 }
 
 void KURL::adjustPath( int _trailing )
 {
   if (!m_strPath_encoded.isEmpty())
   {
      m_strPath_encoded = trailingSlash( _trailing, m_strPath_encoded );
   }
   m_strPath = trailingSlash( _trailing, m_strPath );
 }
 
 
 QString KURL::encodedPathAndQuery( int _trailing, bool _no_empty_path, int encoding_hint ) const
 {
   QString tmp;
   if (!m_strPath_encoded.isEmpty() && encoding_hint == 0)
   {
      tmp = trailingSlash( _trailing, m_strPath_encoded );
   }
   else
   {
      tmp = path( _trailing );
      if ( _no_empty_path && tmp.isEmpty() )
         tmp = "/";
      tmp = encode( tmp, false, encoding_hint );
   }
 
   // TODO apply encoding_hint to the query
   if (!m_strQuery_encoded.isNull())
       tmp += '?' + m_strQuery_encoded;
   return tmp;
 }
 
 void KURL::setEncodedPath( const QString& _txt, int encoding_hint )
 {
   m_strPath_encoded = _txt;
 
   decode( m_strPath_encoded, m_strPath, m_strPath_encoded, encoding_hint );
   // Throw away encoding for local files, makes file-operations faster.
   if (m_strProtocol == fileProt)
      m_strPath_encoded = QString::null;
 }
 
 
 void KURL::setEncodedPathAndQuery( const QString& _txt, int encoding_hint )
 {
   int pos = _txt.find( '?' );
   if ( pos == -1 )
   {
     setEncodedPath(_txt, encoding_hint);
     m_strQuery_encoded = QString::null;
   }
   else
   {
     setEncodedPath(_txt.left( pos ), encoding_hint);
     setQuery(_txt.right(_txt.length() - pos - 1), encoding_hint);
   }
 }
 
 QString KURL::path( int _trailing ) const
 {
   return trailingSlash( _trailing, path() );
 }
 
 bool KURL::isLocalFile() const
 {
   if ( (m_strProtocol != fileProt ) || hasSubURL() )
      return false;
      
   if (m_strHost.isEmpty() || (m_strHost == "localhost"))
      return true;
      
   char hostname[ 256 ];
   hostname[ 0 ] = '\0';
 #ifdef _WIN32_
   // pending LR fixme
   //hostname = "localhost";
 #else
   if (!gethostname( hostname, 255 ))
      hostname[sizeof(hostname)-1] = '\0';
 #endif
   for(char *p = hostname; *p; p++)
      *p = tolower(*p);
      
   return (m_strHost == hostname);
 }
 
 void KURL::setFileEncoding(const QString &encoding)
 {
   if (!isLocalFile())
      return;
 
   QString q = query();
 
   if (!q.isEmpty() && (q[0] == '?'))
      q = q.mid(1);
 
   QStringList args = QStringList::split('&', q);
   for(QStringList::Iterator it = args.begin();
       it != args.end();)
   {
       QString s = decode_string(*it);
       if (s.startsWith("charset="))
 //US changed erase into remove ???
          it = args.remove(it);
       else
          ++it;
   }
   if (!encoding.isEmpty())
      args.append("charset="+encode_string(encoding));
 
   if (args.isEmpty())
      setQuery(QString::null);
   else
      setQuery(args.join("&"));
 }
 
 QString KURL::fileEncoding() const
 {
   if (!isLocalFile())
      return QString::null;
 
   QString q = query();
 
   if (q.isEmpty())
      return QString::null;
 
   if (q[0] == '?')
      q = q.mid(1);
 
   QStringList args = QStringList::split('&', q);
   for(QStringList::ConstIterator it = args.begin();
       it != args.end();
       ++it)
   {
       QString s = decode_string(*it);
       if (s.startsWith("charset="))
          return s.mid(8);
   }
   return QString::null;
 }
 
 bool KURL::hasSubURL() const
 {
   if ( m_strProtocol.isEmpty() || m_bIsMalformed )
     return false;
   if (m_strRef_encoded.isEmpty())
      return false;
   if (m_strRef_encoded.startsWith("gzip:"))
      return true;
   if (m_strRef_encoded.startsWith("bzip:"))
      return true;
   if (m_strRef_encoded.startsWith("bzip2:"))
      return true;
   if (m_strRef_encoded.startsWith("tar:"))
      return true;
   if ( m_strProtocol == "error" ) // anything that starts with error: has suburls
      return true;
   return false;
 }
 
 QString KURL::url( int _trailing, int encoding_hint ) const
 {
   if( m_bIsMalformed )
   {
     // Return the whole url even when the url is
     // malformed.  Under such conditions the url
     // is stored in m_strProtocol.
     return m_strProtocol;
   }
 
   QString u = m_strProtocol;
   if (!u.isEmpty())
      u += ":";
 
   if ( hasHost() )
   {
     u += "//";
     if ( hasUser() )
     {
       u += encode(m_strUser, true, encoding_hint);
       if ( hasPass() )
       {
         u += ":";
         u += encode(m_strPass, true, encoding_hint);
       }
       u += "@";
     }
     bool IPv6 = (m_strHost.find(':') != -1);
     if (IPv6)
        u += '[' + m_strHost + ']';
     else
        u += encodeHost(m_strHost, true, encoding_hint);
     if ( m_iPort != 0 ) {
       QString buffer;
       buffer.sprintf( ":%u", m_iPort );
       u += buffer;
     }
   }
 
   u += encodedPathAndQuery( _trailing, false, encoding_hint );
 
   if ( hasRef() )
   {
     u += "#";
     u += m_strRef_encoded;
   }
 
   return u;
 }
 
 QString KURL::prettyURL( int _trailing ) const
 {
   if( m_bIsMalformed )
   {
     // Return the whole url even when the url is
     // malformed.  Under such conditions the url
     // is stored in m_strProtocol.
     return m_strProtocol;
   }
 
   QString u = m_strProtocol;
   if (!u.isEmpty())
      u += ":";
 
   if ( hasHost() )
   {
     u += "//";
     if ( hasUser() )
     {
       u += lazy_encode(m_strUser);
       // Don't show password!
       u += "@";
     }
     bool IPv6 = (m_strHost.find(':') != -1);
     if (IPv6)
     {
        u += '[' + m_strHost + ']';
     }
     else
     {
        u += lazy_encode(m_strHost);
     }
     if ( m_iPort != 0 ) {
       QString buffer;
       buffer.sprintf( ":%u", m_iPort );
       u += buffer;
     }
   }
 
   u += trailingSlash( _trailing, lazy_encode( m_strPath ) );
   if (!m_strQuery_encoded.isNull())
       u += '?' + m_strQuery_encoded;
 
   if ( hasRef() )
   {
     u += "#";
     u += m_strRef_encoded;
   }
 
   return u;
 }
 
 QString KURL::prettyURL( int _trailing, AdjustementFlags _flags) const
 {
         QString u = prettyURL(_trailing);
         if (_flags & StripFileProtocol && u.startsWith("file:"))
                 u.remove(0, 5);
         return u;
 }
 
 QString KURL::htmlURL() const
 {
 //US QStyleSheet::escape was not in my Qt distribution. Why ???
 //US  return QStyleSheet::escape(prettyURL());
   return prettyURL();
 }
 
 KURL::List KURL::split( const KURL& _url )
 {
   QString ref;
   KURL::List lst;
   KURL url = _url;
 
   while(true)
   {
      KURL u = url;
      u.m_strRef_encoded = QString::null;
      lst.append(u);
      if (url.hasSubURL())
      {
         url = KURL(url.m_strRef_encoded);
      }
      else
      {
         ref = url.m_strRef_encoded;
         break;
      }
   }
 
   // Set HTML ref in all URLs.
   KURL::List::Iterator it;
   for( it = lst.begin() ; it != lst.end(); ++it )
   {
      (*it).m_strRef_encoded = ref;
   }
 
   return lst;
 }
 
 KURL::List KURL::split( const QString& _url )
 {
   return split(KURL(_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
     KURL::List list = KURL::split(*this);
     KURL::List::Iterator it = list.fromLast();
     return (*it).fileName(_strip_trailing_slash);
   }
   const QString &path = m_strPath;
 
   int len = path.length();
   if ( len == 0 )
     return fname;
 
   if ( _strip_trailing_slash )
   {
     while ( len >= 1 && path[ len - 1 ] == '/' )
       len--;
   }
   else if ( path[ len - 1 ] == '/' )
     return fname;
 
   // Does the path only consist of '/' characters ?
   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;
     else
       // Might get here if _strip_trailing_slash is true
       fname = path.left( len );
   }
   else
   {
      fname = path.mid( i + 1, len - i - 1 ); // TO CHECK
   }
   return fname;
 }
 
 void KURL::addPath( const QString& _txt )
 {
   if (hasSubURL())
   {
      KURL::List lst = split( *this );
      KURL &u = lst.last();
      u.addPath(_txt);
      *this = join( lst );
      return;
   }
   
   m_strPath_encoded = QString::null;
 
   if ( _txt.isEmpty() )
     return;
 
   int i = 0;
   int len = m_strPath.length();
   // NB: avoid three '/' when building a new path from nothing
   if ( len == 0 ) {
     while( _txt[i] == '/' ) ++i;
   }
   // Add the trailing '/' if it is missing
   else if ( _txt[0] != '/' && ( len == 0 || m_strPath[ len - 1 ] != '/' ) )
     m_strPath += "/";
 
   // No double '/' characters
   i = 0;
   if ( len != 0 && m_strPath[ len - 1 ] == '/' )
   {
     while( _txt[i] == '/' )
       ++i;
   }
 
   m_strPath += _txt.mid( i );
 }
 
 QString KURL::directory( bool _strip_trailing_slash_from_result,
                          bool _ignore_trailing_slash_in_path ) const
 {
   QString result = m_strPath_encoded.isEmpty() ? m_strPath : m_strPath_encoded;
   if ( _ignore_trailing_slash_in_path )
     result = trailingSlash( -1, result );
 
   if ( result.isEmpty() || result == "/" )
     return result;
 
   int i = result.findRev( "/" );
   // If ( i == -1 ) => the first character is not a '/'
   // So it's some URL like file:blah.tgz, with no path
   if ( i == -1 )
     return QString::null;
 
   if ( i == 0 )
   {
     result = "/";
     return result;
   }
 
   if ( _strip_trailing_slash_from_result )
     result = result.left( i );
   else
     result = result.left( i + 1 );
 
   if (!m_strPath_encoded.isEmpty())
     result = decode(result);
 
   return result;
 }
 
 
 bool KURL::cd( const QString& _dir )
 {
   if ( _dir.isEmpty() || m_bIsMalformed )
     return false;
 
   if (hasSubURL())
   {
      KURL::List lst = split( *this );
      KURL &u = lst.last();
      u.cd(_dir);
      *this = join( lst );
      return true;
   }
 
   // absolute path ?
   if ( _dir[0] == '/' )
   {
     m_strPath_encoded = QString::null;
     m_strPath = _dir;
     setHTMLRef( QString::null );
     m_strQuery_encoded = QString::null;
     return true;
   }
 
   // Users home directory on the local disk ?
   if ( ( _dir[0] == '~' ) && ( m_strProtocol == fileProt ))
   {
     m_strPath_encoded = QString::null;
     m_strPath = QDir::homeDirPath();
     m_strPath += "/";
     m_strPath += _dir.right(m_strPath.length() - 1);
     setHTMLRef( QString::null );
     m_strQuery_encoded = QString::null;
     return true;
   }
 
   // relative path
   // we always work on the past of the first url.
   // Sub URLs are not touched.
 
   // append '/' if necessary
   QString p = path(1);
   p += _dir;
   p = cleanpath( p );
   setPath( p );
 
   setHTMLRef( QString::null );
   m_strQuery_encoded = QString::null;
 
   return true;
 }
 
 KURL KURL::upURL( ) const
 {
   if (!query().isEmpty())
   {
      KURL u(*this);
      u.setQuery(QString::null);
      return u;
   };
 
   if (!hasSubURL())
   {
      KURL u(*this);
      u.cd("../");
      return u;
   }
 
   // We have a subURL.
   KURL::List lst = split( *this );
   if (lst.isEmpty())
       return KURL(); // Huh?
   while (true)
   {
      KURL &u = lst.last();
      QString old = u.path();
      u.cd("../");
      if (u.path() != old)
          break; // Finshed.
      if (lst.count() == 1)
          break; // Finished.
      lst.remove(lst.fromLast());
   }
   return join( lst );
 }
 
 QString KURL::htmlRef() const
 {
   if ( !hasSubURL() )
   {
     return decode( ref() );
   }
 
   List lst = split( *this );
   return decode( (*lst.begin()).ref() );
 }
 
 QString KURL::encodedHtmlRef() const
 {
   if ( !hasSubURL() )
   {
     return ref();
   }
 
   List lst = split( *this );
   return (*lst.begin()).ref();
 }
 
 void KURL::setHTMLRef( const QString& _ref )
 {
   if ( !hasSubURL() )
   {
     m_strRef_encoded = encode( _ref, true, 0 /*?*/);
     return;
   }
 
   List lst = split( *this );
 
   (*lst.begin()).setRef( encode( _ref, true, 0 /*?*/) );
 
   *this = join( lst );
 }
 
 bool KURL::hasHTMLRef() const
 {
   if ( !hasSubURL() )
   {
     return hasRef();
   }
 
   List lst = split( *this );
   return (*lst.begin()).hasRef();
 }
 
 void
 KURL::setProtocol( const QString& _txt )
 {
    m_strProtocol = _txt;
    m_bIsMalformed = false;
 }
 
 void
 KURL::setUser( const QString& _txt )
 {
    m_strUser = _txt;
 }
 
 void
 KURL::setPass( const QString& _txt )
 {
    m_strPass = _txt;
 }
 
 void
 KURL::setHost( const QString& _txt )
 {
 #ifndef KDE_QT_ONLY
    m_strHost = KIDNA::toUnicode(_txt);
    if (m_strHost.isEmpty())
       m_strHost = _txt.lower(); // Probably an invalid hostname, but...
 #else
    m_strHost = _txt.lower();
 #endif
 }
 
 void
 KURL::setPort( unsigned short int _p )
 {
    m_iPort = _p;
 }
 
 void KURL::setPath( const QString & path )
 {
   if (isEmpty())
     m_bIsMalformed = false;
   if (m_strProtocol.isEmpty())
   {
     m_strProtocol = fileProt;
   }
   m_strPath = path;
   m_strPath_encoded = QString::null;
 }
 
 void KURL::setDirectory( const QString &dir)
 {
 //US this has to be fixed. endsWith is not available in my distribution
 //US  if ( dir.endsWith("/"))
 //US     setPath(dir);
 //US  else
      setPath(dir+"/");
 }
 
 void KURL::setQuery( const QString &_txt, int encoding_hint)
 {
    if (!_txt.length())
    {
       m_strQuery_encoded = _txt;
       return;
    }
    if (_txt[0] =='?')
       m_strQuery_encoded = _txt.mid(1);
    else
       m_strQuery_encoded = _txt;
 
    int l = m_strQuery_encoded.length();
    int i = 0;
    QString result;
    while (i < l)
    {
       int s = i;
       // Re-encode. Break encoded string up according to the reserved
       // characters '&:;=/?' and re-encode part by part.
       while(i < l)
       {
          char c = m_strQuery_encoded[i].latin1();
          if ((c == '&') || (c == ':') || (c == ';') ||
              (c == '=') || (c == '/') || (c == '?'))
             break;
          i++;
       }
       if (i > s)
       {
          QString tmp = m_strQuery_encoded.mid(s, i-s);
          QString newTmp;
          decode( tmp, newTmp, tmp, encoding_hint, false );
          result += tmp;
       }
       if (i < l)
       {
          result += m_strQuery_encoded[i];
          i++;
       }
    }
    m_strQuery_encoded = result;
 }
 
 QString KURL::query() const
 {
     if (m_strQuery_encoded.isNull())
         return QString::null;
     return '?'+m_strQuery_encoded;
 }
 
 QString KURL::decode_string(const QString &str, int encoding_hint)
 {
    return decode(str, encoding_hint);
 }
 
 QString KURL::encode_string(const QString &str, int encoding_hint)
 {
    return encode(str, false, encoding_hint);
 }
 
 QString KURL::encode_string_no_slash(const QString &str, int encoding_hint)
 {
    return encode(str, true, encoding_hint);
 }
 
 bool urlcmp( const QString& _url1, const QString& _url2 )
 {
   // Both empty ?
   if ( _url1.isEmpty() && _url2.isEmpty() )
     return true;
   // Only one empty ?
   if ( _url1.isEmpty() || _url2.isEmpty() )
     return false;
 
   KURL::List list1 = KURL::split( _url1 );
   KURL::List list2 = KURL::split( _url2 );
 
   // Malformed ?
   if ( list1.isEmpty() || list2.isEmpty() )
     return false;
 
   return ( list1 == list2 );
 }
 
 bool urlcmp( const QString& _url1, const QString& _url2, bool _ignore_trailing, bool _ignore_ref )
 {
   // Both empty ?
   if ( _url1.isEmpty() && _url2.isEmpty() )
     return true;
   // Only one empty ?
   if ( _url1.isEmpty() || _url2.isEmpty() )
     return false;
 
   KURL::List list1 = KURL::split( _url1 );
   KURL::List list2 = KURL::split( _url2 );
 
   // Malformed ?
   if ( list1.isEmpty() || list2.isEmpty() )
     return false;
 
   unsigned int size = list1.count();
   if ( list2.count() != size )
     return false;
 
   if ( _ignore_ref )
   {
     (*list1.begin()).setRef(QString::null);
     (*list2.begin()).setRef(QString::null);
   }
 
   KURL::List::Iterator it1 = list1.begin();
   KURL::List::Iterator it2 = list2.begin();
   for( ; it1 != list1.end() ; ++it1, ++it2 )
     if ( !(*it1).equals( *it2, _ignore_trailing ) )
       return false;
 
   return true;
 }
 /*US we do not need this functions
 
 QMap< QString, QString > KURL::queryItems( int options ) const {
   return queryItems(options, 0);
 }
 
 QMap< QString, QString > KURL::queryItems( int options, int encoding_hint ) const {
   if ( m_strQuery_encoded.isEmpty() )
     return QMap<QString,QString>();
 
   QMap< QString, QString > result;
   QStringList items = QStringList::split( '&', m_strQuery_encoded );
   for ( QStringList::const_iterator it = items.begin() ; it != items.end() ; ++it ) {
     int equal_pos = (*it).find( '=' );
     if ( equal_pos > 0 ) { // = is not the first char...
       QString name = (*it).left( equal_pos );
       if ( options & CaseInsensitiveKeys )
         name = name.lower();
       QString value = (*it).mid( equal_pos + 1 );
       if ( value.isEmpty() )
         result.insert( name, QString::fromLatin1("") );
       else {
         // ### why is decoding name not neccessary?
         value.replace( '+', ' ' ); // + in queries means space
         result.insert( name, decode_string( value, encoding_hint ) );
       }
     } else if ( equal_pos < 0 ) { // no =
       QString name = (*it);
       if ( options & CaseInsensitiveKeys )
         name = name.lower();
       result.insert( name, QString::null );
     }
   }
 
   return result;
 }
 
 QString KURL::queryItem( const QString& _item ) const
 {
   return queryItem( _item, 0 );
 }
 
 QString KURL::queryItem( const QString& _item, int encoding_hint ) const
 {
   QString item = _item + '=';
   if ( m_strQuery_encoded.length() <= 1 )
     return QString::null;
 
   QStringList items = QStringList::split( '&', m_strQuery_encoded );
   unsigned int _len = item.length();
   for ( QStringList::ConstIterator it = items.begin(); it != items.end(); ++it )
   {
     if ( (*it).startsWith( item ) )
     {
       if ( (*it).length() > _len )
       {
         QString str = (*it).mid( _len );
         str.replace( '+', ' ' ); // + in queries means space.
         return decode_string( str, encoding_hint );
       }
       else // empty value
         return QString::fromLatin1("");
     }
   }
 
   return QString::null;
 }
 US we do not need this functions*/
 
 void KURL::removeQueryItem( const QString& _item )
 {
   QString item = _item + '=';
   if ( m_strQuery_encoded.length() <= 1 )
     return;
 
   QStringList items = QStringList::split( '&', m_strQuery_encoded );
   for ( QStringList::Iterator it = items.begin(); it != items.end(); )
   {
     if ( (*it).startsWith( item ) || (*it == _item) )
     {
       QStringList::Iterator deleteIt = it;
       ++it;
       items.remove(deleteIt);
     }
     else
     {
        ++it;
     }
   }
   m_strQuery_encoded = items.join( "&" );
 }
 
 void KURL::addQueryItem( const QString& _item, const QString& _value, int encoding_hint )
 {
   QString item = _item + '=';
   QString value = encode( _value, true, encoding_hint );
 
   if (!m_strQuery_encoded.isEmpty())
      m_strQuery_encoded += '&';
   m_strQuery_encoded += item + value;
 }
 
 // static
 KURL KURL::fromPathOrURL( const QString& text )
 {
     if ( text.isEmpty() )
         return KURL();
     
     KURL url;
     if ( text[0] == '/' )
         url.setPath( text );
     else
         url = text;
 
     return url;
 }