File indexing completed on 2023-09-24 04:06:36

 /*
     This file is part of the KDE libraries
 
     Copyright (C) 1999 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2004 Apple Computer, Inc.
 
     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., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 //----------------------------------------------------------------------------
 //
 // KDE HTML Widget -- String class
 
 #ifndef KHTMLSTRING_H
 #define KHTMLSTRING_H
 
 #include "dom/dom_string.h"
 
 #include <QList>
 #include <QString>
 
 #include <assert.h>
 
 using namespace DOM;
 
 namespace khtml
 {
 
 class DOMStringIt
 {
 public:
     DOMStringIt()
     {
         s = nullptr, l = 0;
         lines = 0;
     }
     DOMStringIt(QChar *str, uint len)
     {
         s = str, l = len;
         lines = 0;
     }
     DOMStringIt(const QString &str)
     {
         s = str.unicode();
         l = str.length();
         lines = 0;
     }
 
     DOMStringIt *operator++()
     {
         if (!pushedChar.isNull()) {
             pushedChar = 0;
         } else if (l > 0) {
             if (*s == QLatin1Char('\n')) {
                 lines++;
             }
             s++, l--;
         }
         return this;
     }
 public:
     void push(const QChar &c)
     {
         /* assert(pushedChar.isNull());*/  pushedChar = c;
     }
 
     const QChar &operator*() const
     {
         return pushedChar.isNull() ? *s : pushedChar;
     }
     const QChar *operator->() const
     {
         return pushedChar.isNull() ? s : &pushedChar;
     }
 
     bool escaped() const
     {
         return !pushedChar.isNull();
     }
     uint length() const
     {
         return l + (!pushedChar.isNull());
     }
 
     const QChar *current() const
     {
         return pushedChar.isNull() ? s : &pushedChar;
     }
     int lineCount() const
     {
         return lines;
     }
 
 protected:
     QChar pushedChar;
     const QChar *s;
     int l;
     int lines;
 };
 
 class TokenizerString;
 
 class TokenizerSubstring
 {
     friend class TokenizerString;
 public:
     TokenizerSubstring() : m_length(0), m_current(nullptr) {}
     TokenizerSubstring(const QString &str) : m_string(str), m_length(str.length()), m_current(m_length == 0 ? nullptr : str.unicode()) {}
     TokenizerSubstring(const QChar *str, int length) : m_length(length), m_current(length == 0 ? nullptr : str) {}
 
     void clear()
     {
         m_length = 0;
         m_current = nullptr;
     }
 
     void appendTo(QString &str) const
     {
         if (m_string.unicode() == m_current) {
             if (str.isEmpty()) {
                 str = m_string;
             } else {
                 str.append(m_string);
             }
         } else {
             str.insert(str.length(), m_current, m_length);
         }
     }
 private:
     QString m_string;
     int m_length;
     const QChar *m_current;
 };
 
 class TokenizerString
 {
 
 public:
     TokenizerString() : m_currentChar(nullptr), m_lines(0), m_composite(false) {}
     TokenizerString(const QChar *str, int length) : m_currentString(str, length), m_currentChar(m_currentString.m_current), m_lines(0), m_composite(false) {}
     TokenizerString(const QString &str) : m_currentString(str), m_currentChar(m_currentString.m_current), m_lines(0), m_composite(false) {}
     TokenizerString(const TokenizerString &o) : m_pushedChar1(o.m_pushedChar1), m_pushedChar2(o.m_pushedChar2),
         m_currentString(o.m_currentString), m_substrings(o.m_substrings),
         m_lines(o.m_lines), m_composite(o.m_composite)
     {
         m_currentChar = m_pushedChar1.isNull() ? m_currentString.m_current : &m_pushedChar1;
     }
 
     void clear();
 
     void append(const TokenizerString &);
     void prepend(const TokenizerString &);
 
     void push(QChar c)
     {
         if (m_pushedChar1.isNull()) {
             m_pushedChar1 = c;
             m_currentChar = m_pushedChar1.isNull() ? m_currentString.m_current : &m_pushedChar1;
         } else {
             assert(m_pushedChar2.isNull());
             m_pushedChar2 = c;
         }
     }
 
     bool isEmpty() const
     {
         return !current();
     }
     uint length() const;
 
     void advance()
     {
         if (!m_pushedChar1.isNull()) {
             m_pushedChar1 = m_pushedChar2;
             m_pushedChar2 = 0;
         } else if (m_currentString.m_current) {
             m_lines += *m_currentString.m_current++ == QLatin1Char('\n');
             if (--m_currentString.m_length == 0) {
                 advanceSubstring();
             }
         }
         m_currentChar = m_pushedChar1.isNull() ? m_currentString.m_current : &m_pushedChar1;
     }
     uint count() const
     {
         return m_substrings.count();
     }
 
     bool escaped() const
     {
         return !m_pushedChar1.isNull();
     }
 
     int lineCount() const
     {
         return m_lines;
     }
     void resetLineCount()
     {
         m_lines = 0;
     }
 
     QString toString() const;
 
     void operator++()
     {
         advance();
     }
     const QChar &operator*() const
     {
         return *current();
     }
     const QChar *operator->() const
     {
         return current();
     }
 
 private:
     void append(const TokenizerSubstring &);
     void prepend(const TokenizerSubstring &);
 
     void advanceSubstring();
     const QChar *current() const
     {
         return m_currentChar;
     }
 
     QChar m_pushedChar1;
     QChar m_pushedChar2;
     TokenizerSubstring m_currentString;
     const QChar *m_currentChar;
     QList<TokenizerSubstring> m_substrings;
     int m_lines;
     bool m_composite;
 
 };
 
 class TokenizerQueue : public QList<TokenizerString>
 {
 
 public:
     TokenizerQueue() {}
     ~TokenizerQueue() {}
     void  push(const TokenizerString &t)
     {
         prepend(t);
     }
     TokenizerString pop()
     {
         if (isEmpty()) {
             return TokenizerString();
         }
         TokenizerString t(first());
         erase(begin());
         return t;
     }
     TokenizerString &top()
     {
         return first();
     }
     TokenizerString &bottom()
     {
         return last();
     }
 };
 
 }
 
 #endif