katehighlight.h

Go to the documentation of this file.

/* This file is part of the KDE libraries
   Copyright (C) 2001,2002 Joseph Wenninger <jowenn@kde.org>
   Copyright (C) 2001 Christoph Cullmann <cullmann@kde.org>
   Copyright (C) 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.

   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.
*/

#ifndef __KATE_HIGHLIGHT_H__
#define __KATE_HIGHLIGHT_H__

#include "katetextline.h"
#include "kateextendedattribute.h"
#include "katesyntaxmanager.h"
#include "spellcheck/prefixstore.h"

#include <kconfig.h>
#include <kactionmenu.h>

#include <QtCore/QVector>
#include <QtCore/QList>
#include <QtCore/QHash>
#include <QtCore/QMap>

#include <QtCore/QRegExp>
#include <QtCore/QObject>
#include <QtCore/QStringList>
#include <QtCore/QPointer>
#include <QtCore/QDate>
#include <QtCore/QLinkedList>

class KateHlContext;
class KateHlItem;
class KateHlIncludeRule;
class KateTextLine;
class KateSyntaxModeListItem;
class KateSyntaxContextData;

// same as in kmimemagic, no need to feed more data
#define KATE_HL_HOWMANY 1024

// min. x seconds between two dynamic contexts reset
#define KATE_DYNAMIC_CONTEXTS_RESET_DELAY (30 * 1000)


class KateHlContextModification
{
  public:
    enum modType {
      doNothing = 0,
      doPush = 1,
      doPops = 2,
      doPopsAndPush = 3
    };

    KateHlContextModification (int _newContext = -1, int _pops = 0) : type (doNothing), newContext (_newContext), pops (_pops) //krazy:exclude=explicit
    {
      if (newContext >= 0 && pops == 0) type = doPush;
      else if (newContext < 0 && pops > 0) type = doPops;
      else if (newContext >= 0 && pops > 0) type = doPopsAndPush;
      else type = doNothing;
    }

  public:
    char type;

    int newContext;

    int pops;
};

class KateEmbeddedHlInfo
{
  public:
    KateEmbeddedHlInfo() {loaded=false;context0=-1;}
    KateEmbeddedHlInfo(bool l, int ctx0) {loaded=l;context0=ctx0;}

  public:
    bool loaded;
    int context0;
};

// some typedefs
typedef QList<KateHlIncludeRule*> KateHlIncludeRules;
typedef QMap<QString,KateEmbeddedHlInfo> KateEmbeddedHlInfos;
typedef QMap<KateHlContextModification*,QString> KateHlUnresolvedCtxRefs;

class KateHighlighting
{
  public:
    KateHighlighting(const KateSyntaxModeListItem *def);
    ~KateHighlighting();

  private:
    void cleanup ();

    void makeNoneContext();

  public:
    struct ContextChange {
      KateHlContext* toContext;
      int pos;
    };

    void doHighlight ( const Kate::TextLineData *prevLine,
                       Kate::TextLineData *textLine,
                       const Kate::TextLineData *nextLine,
                       bool &ctxChanged,
                       int tabWidth = 0,
                       QVector<ContextChange>* contextChanges = 0);

    void setKateExtendedAttributeList(const QString &schema, QList<KateExtendedAttribute::Ptr> &,
      KConfig* cfg=0 /*if 0  standard kate config*/, bool writeDefaultsToo=false);

    const QString &name() const {return iName;}
    const QString &nameTranslated() const {return iNameTranslated;}
    const QString &section() const {return iSection;}
    bool hidden() const {return iHidden;}
    const QString &version() const {return iVersion;}
    const QString &style() const { return iStyle; }
    const QString &author () const { return iAuthor; }
    const QString &license () const { return iLicense; }
    const QString &getIdentifier() const {return identifier;}
    void use();
    void release();

    bool isInWord( QChar c, int attrib=0 ) const;

    bool canBreakAt( QChar c, int attrib=0 ) const;
    QLinkedList<QRegExp> emptyLines(int attribute=0) const;

    bool isEmptyLine(const Kate::TextLineData *textline) const;

    bool canComment( int startAttr, int endAttr ) const;

    signed char commentRegion(int attr) const;

    QString getCommentStart( int attrib=0 ) const;

    QString getCommentEnd( int attrib=0 ) const;

    QString getCommentSingleLineStart( int attrib=0 ) const;


    const QHash<QString, QChar>& characterEncodings( int attrib = 0 ) const;

    enum CSLPos { CSLPosColumn0=0,CSLPosAfterWhitespace=1};

    CSLPos getCommentSingleLinePosition( int attrib=0 ) const;

    int attribute( int context ) const;

    bool attributeRequiresSpellchecking( int attr );

    QString hlKeyForAttrib( int attrib ) const;
    QString hlKeyForContext( int attrib ) const;

    int defaultStyleForAttribute( int attrib ) const;

    void clearAttributeArrays ();

    QList<KTextEditor::Attribute::Ptr> attributes (const QString &schema);

    inline bool noHighlighting () const { return noHl; }

    // be carefull: all documents hl should be invalidated after calling this method!
    void dropDynamicContexts();

    QString indentation () { return m_indentation; }

    void getKateExtendedAttributeList(const QString &schema, QList<KateExtendedAttribute::Ptr> &, KConfig* cfg=0);
    void getKateExtendedAttributeListCopy(const QString &schema, QList<KateExtendedAttribute::Ptr> &,KConfig* cfg=0);

    const QHash<QString, QChar>& getCharacterEncodings( int attrib ) const;
    const KatePrefixStore& getCharacterEncodingsPrefixStore( int attrib ) const;
    const QHash<QChar, QString>& getReverseCharacterEncodings( int attrib ) const;
    int getEncodedCharactersInsertionPolicy( int attrib ) const;

    QStringList getEmbeddedHighlightingModes() const;

    KateHlContext *contextNum (int n) { if (n >= 0 && n < m_contexts.size()) return m_contexts[n]; Q_ASSERT (0); return m_contexts[0]; }
    
  private:
    void addCharacterEncoding( const QString& key, const QString& encoding, const QChar& c );

  private:
    void init();
    void done();
    void makeContextList ();
    int makeDynamicContext(KateHlContext *model, const QStringList *args);
    void handleKateHlIncludeRules ();
    void handleKateHlIncludeRulesRecursive(int index, KateHlIncludeRules *list);
    int addToContextList(const QString &ident, int ctx0);
    void addToKateExtendedAttributeList();
    void createKateExtendedAttribute (QList<KateExtendedAttribute::Ptr> &list);
    void readGlobalKeywordConfig();
    void readWordWrapConfig();
    void readCommentConfig();
    void readEmptyLineConfig();
    void readIndentationConfig ();
    void readFoldingConfig ();
    void readSpellCheckingConfig();

    KateHlContext *generateContextStack(Kate::TextLineData::ContextStack &contextStack, KateHlContextModification modification, int &indexLastContextPreviousLine);

    KateHlItem *createKateHlItem(KateSyntaxContextData *data, QList<KateExtendedAttribute::Ptr> &iDl, QStringList *RegionList, QStringList *ContextList);
    int lookupAttrName(const QString& name, QList<KateExtendedAttribute::Ptr> &iDl);

    void createContextNameList(QStringList *ContextNameList, int ctx0);
    KateHlContextModification getContextModificationFromString(QStringList *ContextNameList, QString tmpLineEndContext,/*NO CONST*/ QString &unres);

    QList<KateExtendedAttribute::Ptr> internalIDList;

    QVector<KateHlContext*> m_contexts;

    QMap< QPair<KateHlContext *, QString>, short> dynamicCtxs;

    // make them pointers perhaps
    // NOTE: gets cleaned once makeContextList() finishes
    KateEmbeddedHlInfos embeddedHls;
    // valid once makeContextList() finishes
    QStringList embeddedHighlightingModes;
    KateHlUnresolvedCtxRefs unresolvedContextReferences;
    QStringList RegionList;
    QStringList ContextNameList;

    bool noHl;
    bool folding;
    bool casesensitive;
    QString weakDeliminator;
    QString deliminator;

    QString iName;
    QString iNameTranslated;
    QString iSection;
    bool iHidden;
    QString identifier;
    QString iVersion;
    QString iStyle;
    QString iAuthor;
    QString iLicense;
    QString m_indentation;
    int refCount;
    int startctx, base_startctx;

    QString errorsAndWarnings;
    QString buildIdentifier;
    QString buildPrefix;
    bool building;
    uint itemData0;
    uint buildContext0Offset;
    KateHlIncludeRules includeRules;
    bool m_foldingIndentationSensitive;

    // map schema name to attributes...
    QHash< QString, QList<KTextEditor::Attribute::Ptr> > m_attributeArrays;

    // list of all created items to delete them later
    QList<KateHlItem *> m_hlItemCleanupList;

    class HighlightPropertyBag {
      public:
        QString singleLineCommentMarker;
        QString multiLineCommentStart;
        QString multiLineCommentEnd;
        QString multiLineRegion;
        CSLPos  singleLineCommentPosition;
        QString deliminator;
        QString wordWrapDeliminator;
        QLinkedList<QRegExp> emptyLines;
        QHash<QString, QChar> characterEncodings;
        KatePrefixStore characterEncodingsPrefixStore;
        QHash<QChar, QString> reverseCharacterEncodings;
        int encodedCharactersInsertionPolicy;
    };

    QHash<QString, HighlightPropertyBag*> m_additionalData;

    QMap<int, QString> m_hlIndex;
    QMap<int, QString> m_ctxIndex;
  public:
    inline bool foldingIndentationSensitive () { return m_foldingIndentationSensitive; }
    inline bool allowsFolding(){return folding;}
};

#endif

// kate: space-indent on; indent-width 2; replace-tabs on;