main.cpp File Reference

#include <stdlib.h>
#include <fstream>
#include <iostream>
#include "OptionParser.h"
#include "PFileParser.h"

Include dependency graph for main.cpp:

Go to the source code of this file.

Functions
OptionParser	createOptionParser ()
	Create the OptionParser of this program. More...
int	main (int argc, char **argv)
bool	processFile (const PPath &inputFile, const PString &command, size_t firstToken, size_t lastToken, size_t incrementToken, const PString &delimitor, bool isNoFail)
	Process the file. More...
bool	processVecFile (const PVecPath &vecInputFile, const PString &command, size_t firstToken, size_t lastToken, size_t incrementToken, const PString &delimitor, bool isNoFail)
	Process the program. More...

Function Documentation

createOptionParser()

OptionParser createOptionParser

(

)

Create the OptionParser of this program.

Returns

OptionParser of this program

Definition at line 18 of file main.cpp.

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

References OptionParser::addOption(), OptionType::FILENAME, OptionType::NONE, OptionParser::setExampleLongOption(), OptionParser::setExampleShortOption(), and OptionType::STRING.

Here is the call graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 121 of file main.cpp.

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

References createOptionParser(), OptionParser::getDefaultMode(), OptionMode::getValue(), OptionMode::isOptionExist(), OptionParser::parseArgument(), and processVecFile().

Here is the call graph for this function:

processFile()

bool processFile	(	const PPath &	inputFile,
		const PString &	command,
		size_t	firstToken,
		size_t	lastToken,
		size_t	incrementToken,
		const PString &	delimitor,
		bool	isNoFail
	)

Process the file.

Parameters

inputFile	: input file
command	: command to be used
firstToken	: Index of the first token to be tested
lastToken	: Index of the last token to be tested
incrementToken	: Increment of the index to be used
delimitor	: All delimitor characters to be used to tokenise the input file
isNoFail	: true to ignore if the tested program failed or not, false for normal behaviour

Returns

true on success, false otherwise

Definition at line 49 of file main.cpp.

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

References PPath::getExtension(), PFileParser::getNextToken(), PFileParser::isEndOfFile(), PFileParser::open(), PString::replace(), PPath::saveFileContent(), and PFileParser::setSeparator().

Referenced by main(), processFileOrDir(), and processVecFile().

Here is the call graph for this function:

Here is the caller graph for this function:

processVecFile()

bool processVecFile	(	const PVecPath &	vecInputFile,
		const PString &	command,
		size_t	firstToken,
		size_t	lastToken,
		size_t	incrementToken,
		const PString &	delimitor,
		bool	isNoFail
	)

Process the program.

Parameters

vecInputFile	: vector of input files
command	: command to be used
firstToken	: Index of the first token to be tested
lastToken	: Index of the last token to be tested
incrementToken	: Increment of the index to be used
delimitor	: All delimitor characters to be used to tokenise the input file
isNoFail	: true to ignore if the tested program failed or not, false for normal behaviour

Returns

true on success, false otherwise

Definition at line 110 of file main.cpp.

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

References processFile().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: