grammar.h

Code for top down parser in C++

//---------------------------------------------------------------------------
#ifndef grammarH
#define grammarH


class RewriteUnit{
public:
    String str;
    bool terminal;  //terminal or non
    bool codeGen;   //code generator statement
    RewriteUnit():str(""),terminal(false){}
};
//------------------------------------


class RewriteRule{
public:
    //each rewrite rule contains a collection of rewrite units
    TList* units;
    RewriteRule(){ units = new TList(); }
    ~RewriteRule(){
        for(int i=0; i<units->Count; i++) delete ((RewriteUnit*)units->Items[i]);
        delete units;
    }

    bool equalTo(RewriteRule* r2){
        if(this->units->Count != r2->units->Count) return false;
        bool equal = true;
        for(int i=0; i<this->units->Count; i++){
            if( ((RewriteUnit*)this->units->Items[i])->terminal != ((RewriteUnit*)r2->units->Items[i])->terminal ){
                equal = false; break;
            }
            if( ((RewriteUnit*)this->units->Items[i])->str != ((RewriteUnit*)r2->units->Items[i])->str ){
                equal = false; break;
            }
        }
        return equal;
    }
};
//------------------------------------


class RewriteRuleGroup{
public:
    //each rewrite rule group contains a collection of rewrite rules
    TList* rules;
    String nonTerminal; //non-terminal which this group rewrites
    int currentRule;

    RewriteRuleGroup():currentRule(0){ rules = new TList(); }
    ~RewriteRuleGroup(){
        for(int i=0; i<rules->Count; i++) delete ((RewriteRule*)rules->Items[i]);
        delete rules;
    }
    String Apply();
};
//------------------------------------


class Grammar{
public:
    //a grammar contains a collection of rewrite rule groups
    TList* ruleGroups;

    Grammar(){ ruleGroups = new TList(); }
    ~Grammar(){
        for(int i=0; i<ruleGroups->Count; i++) delete ((RewriteRuleGroup*)ruleGroups->Items[i]);
        delete ruleGroups;
    }

    void LoadFromFile(String fileName);
    void SaveToFile(String fileName);

    RewriteRuleGroup* getGroup(String nonTerminal){
        RewriteRuleGroup* theGroup = NULL;
        for(int i=0; i<ruleGroups->Count; i++){
            RewriteRuleGroup* poo = (RewriteRuleGroup*)ruleGroups->Items[i];
            if(poo->nonTerminal == nonTerminal){ theGroup = poo; break; }
        }
        return theGroup;
    }

    void EliminateEpsilonProductions();
    void EliminateLeftRecursion();
    void EliminateUnitProductions();
    void FixDegenerates();
};
//------------------------------------


class ParseNode{
public:
    bool terminal;
    String str;
    RewriteRuleGroup* myGroup;
    int currentRuleIndex;
    ParseNode *parent;
    int index, level;

    ParseNode():index(-1),level(0){ }
};
//------------------------------------


//---------------------------------------------------------------------------
#endif