main.cpp

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <stdlib.h>
#include <fstream>
#include <iostream>
 
#include "OptionParser.h"
#include "PFileParser.h"
 
 
OptionParser createOptionParser(){
        OptionParser parser(true, __PROGRAM_VERSION__);
        parser.setExampleLongOption("phoenix_dripfile --input=fileInput.txt --command=\"some_program FILENAME\"");
        parser.setExampleShortOption("phoenix_dripfile -i fileInput1.txt -c \"some_program FILENAME\"");
        
        parser.addOption("input", "i", OptionType::FILENAME, true, "list of input files");
        parser.addOption("command", "c", OptionType::STRING, true, "Command to be executed by the program. The token 'FILENAME' specifies where the generated file has to be passed in the command");
        
        size_t firstToken(0lu), lastToken(-1lu), incrementToken(1lu);
        parser.addOption("firsttoken", "f", firstToken, "Index of the first token to be tested");
        parser.addOption("lasttoken", "l", lastToken, "Index of the last token to be tested");
        parser.addOption("incrementtoken", "k", incrementToken, "Increment of the index to be used");
        
        PString delimitor("+-*/!:~&|<>.()[]{}\"'%");
        parser.addOption("delimitor", "d", delimitor, "All delimitor characters to be used to tokenise the input file");
        
        parser.addOption("nofail", "x", OptionType::NONE, false, "Does not take account if the tested program failed or not. Always retruns 0");
        
        return parser;
}
 
 
bool processFile(const PPath & inputFile, const PString & command,
                 size_t firstToken, size_t lastToken, size_t incrementToken, const PString & delimitor, bool isNoFail)
{
        std::cout << "processFile : using file '"<<inputFile<<"'" << std::endl;
        PString extention(inputFile.getExtension());
        if(extention != ""){extention = "." + extention;}
        PPath configFile("temporary_file" + extention);
        PString updatedCommand(command.replace("FILENAME", configFile));
        if(command == updatedCommand){
                std::cerr << "processFile : 'FILENAME' token missing in the command" << std::endl;
                std::cerr << "\t" << command << std::endl;
                return false;
        }
        std::cout << "Command : '"<<updatedCommand<<"'" << std::endl;
        
        PFileParser parser;
        parser.setSeparator(delimitor);
        if(!parser.open(inputFile)){return false;}
        
        bool b(true);
        size_t tokenIndex(firstToken);
        PString body("");
        for(size_t i(0lu); i < firstToken; ++i){        //Let's create the basic configuration file with the first number of token
                PString skippedStr("");
                PString token(parser.getNextToken(skippedStr));
                body += skippedStr + token;
        }
        while(tokenIndex < lastToken && !parser.isEndOfFile()){
                //Let's create the config file
                if(!configFile.saveFileContent(body)){
                        std::cerr << "processFile : cannot save file '"<<configFile<<"'" << std::endl; 
                        return false;
                }
                //Let's call the updatedCommand
                std::cout << "- token " << tokenIndex << " => ";
                if(system(updatedCommand.c_str()) != 0 && !isNoFail){
                        std::cout << "FAIL" << std::endl;
                        return false;
                }
                std::cout << "OK" << std::endl;
                for(size_t i(0lu); i < incrementToken; ++i){
                        PString skippedStr("");
                        PString token(parser.getNextToken(skippedStr));
                        body += skippedStr + token;
                        ++tokenIndex;
                }
        }
        return b;
}
 
 
 
bool processVecFile(const PVecPath & vecInputFile, const PString & command,
                size_t firstToken, size_t lastToken, size_t incrementToken, const PString & delimitor, bool isNoFail)
{
        bool b(true);
        for(PVecPath::const_iterator it(vecInputFile.begin()); it != vecInputFile.end() && b; ++it){
                b &= processFile(*it, command, firstToken, lastToken, incrementToken, delimitor, isNoFail);
        }
        return b;
}
 
 
int main(int argc, char** argv){
        OptionParser parser = createOptionParser();
        parser.parseArgument(argc, argv);
        
        const OptionMode & defaultMode = parser.getDefaultMode();
        PVecPath vecInputFile;
        defaultMode.getValue(vecInputFile, "input");
        
        PString command("");
        defaultMode.getValue(command, "command");
        
        size_t firstToken(0lu), lastToken(-1lu), incrementToken(1lu);
        defaultMode.getValue(firstToken, "firsttoken");
        defaultMode.getValue(lastToken, "lasttoken");
        defaultMode.getValue(incrementToken, "incrementtoken");
        if(incrementToken == 0lu){incrementToken = 1lu;}        //incrementToken cannot be 0
        
        PString delimitor("");
        defaultMode.getValue(delimitor, "delimitor");
        
        bool isNoFail = defaultMode.isOptionExist("nofail");
        
        bool b(processVecFile(vecInputFile, command,
                firstToken, lastToken, incrementToken, delimitor, isNoFail));
        return b - 1;
}