textgrammar.h

Go to the documentation of this file.

#pragma once

#include <QHash>
#include <QList>
#include <QMap>
#include <QString>
#include <QStringList>

class QFile;

namespace edbee {

class RegExp;
class TextGrammar;
class Edbee;


class TextGrammarRule
{
public:

    enum Instruction {
        MainRule,                   
        RuleList,                   
        SingleLineRegExp,           
        MultiLineRegExp,            
        IncludeCall,                
        Parser                      
    };


    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_;
    };

    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 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 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;
};

} // edbee