Hosting courtesy of Sourceforge

               

---

Parse.cpp

Go to the documentation of this file.

//
//      Copyright (C) 2002 Robert Renaud
//
//      This program is free software; you can redistribute it and/or
//      modify it under the terms of the GNU General Public License
//      as published by the Free Software Foundation; either version 2
//      of the License, or (at your option) any later version.
//
//      This program 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 General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program; if not, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#include "Parse.h"
#include <algorithm>

/*
Parse::Parser::Parser(const Parser& otherParser)  :
input(otherParser.input) 
{
for (ActionMap_t::iterator i = otherParser.actionMap.begin(); 
i != otherParser.actionMap.end(); ++i) {
actionMap.insert(*i);
}
}
*/

Parse::Parser::~Parser() {
        for (ActionMap_t::iterator i = actionMap.begin(); i != actionMap.end(); ++i) {
        i->second->finishingAction();   
                delete i->second;
        }
}

void Parse::Parser::addAction(string identifier, ParseAction* action) {
        Util::makeLowercase(identifier);
        actionMap[identifier] = action;
}

Parse::SimpleParser::SimpleParser(std::istream &inputFile)
:
input(inputFile)
{ }


// #include <iostream>  cout debugging...

void Parse::SimpleParser::read() {
        #ifdef DEBUG_PARSE_PARSER
                debugOut << "SimpleParser::read()" << endl;
        #endif
        char openingVal;
        string identifier;
        string junk;
        char junkChar;
        
/*      std::cout << "outputting known identifiers" << endl;
        for (ActionMap_t::iterator i = actionMap.begin(); i != actionMap.end(); ++i) {
        std::cout << "\t" << i->first << endl;
        }
        std::cout << "done with known identifiers" << endl;
*/
        
        set<char> charsImplyingAnIdentifierWasRead;
        charsImplyingAnIdentifierWasRead.insert('=');
        charsImplyingAnIdentifierWasRead.insert('{');
        
        while(!input.eof()) {
                
                input >> openingVal;
                if (openingVal == '}') { // closing bracket, this function is done
                        return;
                }
                
                if (openingVal == '#') { // # indicates comment
                        getline(input,junk, '\n'); // eat the line
                        #ifdef DEBUG_PARSE_PARSER
                                debugOut << "\tfound comment " << "\"" << junk << "\"" << endl;
                        #endif
                        continue;  // go back to start of while
                }
                
                input.putback(openingVal); // this was part of an identifier, put it back
                
                identifier = Util::getNextIdentifier(input, charsImplyingAnIdentifierWasRead);
                
                input >> junkChar; // get the terminating char left in input by gNI

                Util::makeLowercase(identifier);
                Util::eraseSpaces(identifier);
                ActionMap_t::iterator i = actionMap.find(identifier);                   
        
                // if the identifier was added previously to the map
                if (i != actionMap.end()) {
                        // call the correpsonding action func to read the value from input
                //      cout << identifier << endl;
                        #ifdef DEBUG_PARSE_PARSER
                                debugOut << "\tcalling getValue() for identifier \"" << identifier << "\"" << endl;
                        #endif
                        i->second->getValue(input);
                } else {
                        if (!input.eof()) {
                                input >> junk;
                        /*      std::cout << identifier << " not recognized, corresponding junk data "
                                        << junk << endl;
                        */
                        }
                }
        }
}

Parse::CommandLineParser::CommandLineParser(int a, char** b, string tc) :
argc(a),
argv(b),
tagChars(tc)
{ }


void Parse::CommandLineParser::read() { 

        int i = 1;
        while (i < argc) {
                int minValueIndex;
                int maxValueIndex;              
                std::string identifier;
                std::string values;

                while (i<argc && std::find(tagChars.begin(), tagChars.end(), argv[i][0])==tagChars.end()) {  // skip to first identifier
            i++;
                }
                
                identifier = argv[i];
                //cout << "identifier "<< identifier << " at string pos " << i << endl;

                i++;            
                minValueIndex = i;              
                // find how many value strings there are
                while (i<argc && std::find(tagChars.begin(), tagChars.end(), argv[i][0])==tagChars.end()) {
                        i++;
                }       
                maxValueIndex = i;

                //cout << "minValueIndex = " << minValueIndex << " , maxValueIndex = " << maxValueIndex << endl << endl;
                for (int j = minValueIndex; j < maxValueIndex; j++) {
                        values += argv[j];  // concat value char* to string
                        values += ' ';
                }

                ActionMap_t::iterator parseActionPair = actionMap.find(identifier);
                if (parseActionPair != actionMap.end()) {
                        std::istringstream inStream(values); // change string to stream
                        parseActionPair->second->getValue(inStream);
                }
        }                       
}
                
Parse::DelegateToSubParser::DelegateToSubParser(Parser* p) :
parser(p)
{ }

Parse::DelegateToSubParser::~DelegateToSubParser() {
        delete parser;
}

void Parse::DelegateToSubParser::getValue(std::istream& in) {
        parser->read();
}

---