textgrammar.h

Go to the documentation of this file.

// edbee - Copyright (c) 2012-2025 by Rick Blommers and contributors
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "edbee/exports.h"
 
#include <QHash>
#include <QList>
#include <QMap>
#include <QString>
#include <QStringList>
 
class QFile;
 
namespace edbee {
 
class RegExp;
class TextGrammar;
class Edbee;
 

class EDBEE_EXPORT TextGrammarRule {
public:

    enum Instruction {
        MainRule,                   
        RuleList,                   
        SingleLineRegExp,           
        MultiLineRegExp,            
        IncludeCall,                
        Parser                      
    };
    enum Instruction {…};
 
 
    TextGrammarRule( TextGrammar* grammar, Instruction instruction );
    ~TextGrammarRule();
 
    static TextGrammarRule* createMainRule( TextGrammar* grammar, const QString& scopeName );
    static TextGrammarRule* createRuleList( TextGrammar* grammar );
    static TextGrammarRule* createSingleLineRegExp( TextGrammar* grammar, const QString& scopeName, const QString& regExp );
    static TextGrammarRule* createMultiLineRegExp( TextGrammar* grammar, const QString& scopeName, const QString& contentScopeName, const QString& beginRegExp, const QString& endRegExp );
    static TextGrammarRule* createIncludeRule( TextGrammar* grammar, const QString& includeName );
 
    inline bool isMainRule() { return instruction_ == MainRule; }
    inline bool isRuleList() { return instruction_ == RuleList; }
    inline bool isMultiLineRegExp() { return instruction_ == MultiLineRegExp; }
    inline bool isSingleLineRegExp() { return instruction_ == SingleLineRegExp; }
    inline bool isIncludeCall() { return instruction_ == IncludeCall; }
 
    int ruleCount() const { return ruleList_.size(); }
    TextGrammarRule* rule( int idx ) const;
    void giveRule( TextGrammarRule* rule );
 
    void giveMatchRegExp( RegExp* regExp );
    void setEndRegExpString( const QString& str );
 
    Instruction instruction() const { return instruction_; }
    void setInstruction( Instruction ins ) { instruction_ = ins; }
    QString scopeName() const  { return scopeName_; }
    void setScopeName( const QString& scopeName ) { scopeName_ = scopeName; }
    RegExp* matchRegExp() const { return matchRegExp_; }
    QString endRegExpString() const { return endRegExpString_; }
    const QMap<int,QString>& matchCaptures() { return matchCaptures_; }
    const QMap<int,QString>& endCaptures() { return endCaptures_; }
    QString contentScopeName() const { return contentScopeName_; }
    void setContentScopeName( const QString& name) { contentScopeName_ = name; }

    QString includeName() { return contentScopeName_;  }
    void setIncludeName( const QString& name ) { contentScopeName_ = name; }
 
    void setCapture( int idx, const QString& name ) { matchCaptures_.insert(idx,name); }
    void setEndCapture( int idx, const QString& name ) { endCaptures_.insert(idx,name); }
 
    QString toString(bool includePatterns=true);
 
 
    // An itetor class for iterating over the ruleset (todo template this)
    class Iterator
    {
    public:
        Iterator( const TextGrammarRule* rule ) : index_(0), ruleRef_(rule){}
        bool hasNext() { return index_ < ruleRef_->ruleCount(); }
        TextGrammarRule* next() { return ruleRef_->rule(index_++); }
    private:
        int index_;
        const TextGrammarRule* ruleRef_;
    };
    class Iterator {…};
 
    Iterator* createIterator() { return new Iterator(this); }
 
    TextGrammar* grammar() { return grammarRef_; }
 
private:
 
    static RegExp* createRegExp( const QString& regexp );
 
 
private:
    TextGrammar* grammarRef_;        
    Instruction instruction_;            
    QString scopeName_;                  
 
    RegExp* matchRegExp_;                
    //RegExp* endRegExp_;                  ///< The end regular expression matcher
    QString endRegExpString_;            
 
    QMap<int,QString> matchCaptures_;    
    QMap<int,QString> endCaptures_;      
 
    QString contentScopeName_;           
 
    QList<TextGrammarRule*> ruleList_;   
};
class EDBEE_EXPORT TextGrammarRule {…};
 
 
//================================
 

class EDBEE_EXPORT TextGrammar {
public:
 
    TextGrammar( const QString& name, const QString& displayName );
    ~TextGrammar();
 
    void giveMainRule( TextGrammarRule* mainRule );
 
    QString name() const;
    QString displayName() const;
    TextGrammarRule* mainRule() const;
    QStringList fileExtensions() const;
 
    void giveToRepos( const QString& name, TextGrammarRule* rule);
    TextGrammarRule* findFromRepos( const QString& name, TextGrammarRule* defValue = 0  );
    void addFileExtension( const QString& ext );
 
private:
    QString name_;                               
    QString displayName_;                        
    TextGrammarRule *mainRule_;                      
    QMap<QString, TextGrammarRule*> repository_;     
    QStringList fileExtensions_;                  
};
class EDBEE_EXPORT TextGrammar {…};
 
 
 
//================================
 

class EDBEE_EXPORT TextGrammarManager {
protected:
    TextGrammarManager();
    virtual ~TextGrammarManager();
 
public:
    TextGrammar* readGrammarFile(const QString& file );
    void readAllGrammarFilesInPath(const QString& path );
 
    TextGrammar* get( const QString& name );
    void giveGrammar( TextGrammar* grammar );
 
    QList<QString> grammarNames();
    QList<TextGrammar*> grammars();
    QList<TextGrammar*> grammarsSortedByDisplayName();
 
    TextGrammar* defaultGrammar() { return defaultGrammarRef_; }
    TextGrammar* detectGrammarWithFilename( const QString& fileName );
 
    QString lastErrorMessage() const;
 
private:
 
    TextGrammar* defaultGrammarRef_;                   
    QMap<QString,TextGrammar*> grammarMap_;            
    QString lastErrorMessage_;                             
 
    friend class Edbee;
};
class EDBEE_EXPORT TextGrammarManager {…};
 
} // edbee