main.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <sys/stat.h>
#include <sys/types.h>
 
#include "OptionParser.h"
#include "psrc_split_lib.h"
 
 
struct SplitArgument{
        PPath outputDir{"./"};
        PVecPath listInputFile;
        bool keepComment{false};
        bool keepTex{false};
        bool removefirstcomment{false};
        bool isPlatexMode{false};
        PVecPath listIgnoreDir;
};
 
bool processFileOrDir(const PPath & outputDir, const PPath & inputFile, const SplitArgument & option);
 
 
OptionParser createOptionParser(){
        OptionParser parser(true, __PROGRAM_VERSION__);
        parser.setExampleLongOption("phoenix_srcsplittexdir --input=fileInput.cpp --output=output.ptex --platex");
        parser.setExampleShortOption("phoenix_srcsplittexdir -i fileInput.cpp -o output.ptex -p");
        
        parser.addOption("input", "i", OptionType::FILENAME, true, "name of the input file (source, c, cpp, cmake, py, cu)");
        
        PPath defaultOutputDir("./");
        parser.addOption("output", "o", defaultOutputDir, "output directory for generated files and directories");
        
        parser.addOption("keepcomment", "k", OptionType::NONE, false, "keep the comment of the targeted language");
        parser.addOption("keeptex", "t", OptionType::NONE, false, "keep the ptex comment in the output file");
        parser.addOption("removefirstcomment", "f", OptionType::NONE, false, "remove the first comment of the file (can be the Licence or whatever)");
        parser.addOption("platex", "p", OptionType::NONE, false, "activate platex mode (add begin and end around code part)");
        
        parser.addOption("ignoredir", "d", OptionType::FILENAME, false, "List of directories to be ignored");
        return parser;
}
 
 
bool createDirectoryWithFiles(const PPath & outputDir, const PPath & directoryName, const PVecPath & listInputFile, const SplitArgument & option)
{
        bool b(true);
        PPath currentOutputDir(outputDir/ directoryName.getFileName());
        if(!currentOutputDir.createDirectory()){
                std::cerr << "createDirectoryWithFiles : Can't create directory '" << currentOutputDir << "'" << std::endl;
                return false;
        }
        for(PVecPath::const_iterator it(listInputFile.begin()); it != listInputFile.end(); ++it){
                b &= processFileOrDir(currentOutputDir, *it, option);
        }
        return b;
}
 
 
PVecPath pathRemoveIfIgnored(const PVecPath & vecPath, const PVecPath & listIgnoreDir){
        PVecPath vecOut;
        for(PVecPath::const_iterator itPath(vecPath.begin()); itPath != vecPath.end(); ++itPath){
                bool isFound = false;
                PVecPath::const_iterator it(listIgnoreDir.begin());
                while(it != listIgnoreDir.end() && !isFound){
                        isFound = itPath->getFileName() == *it;
                        ++it;
                }
                if(!isFound){
                        vecOut.push_back(*itPath);
                }
        }
        return vecOut;
}
 
 
bool processFileOrDir(const PPath & outputDir, const PPath & inputFile, const SplitArgument & option){
        bool isPlatexMode = option.isPlatexMode;
        std::cout << "createFileFunctionGenerator : begin '" << inputFile <<"'" << std::endl;
        PPath fileName(inputFile.getFileName());
        //Get the directory content :
        PVecPath listFileInDir = inputFile.getAllElementInDir();
        if(listFileInDir.size() != 0lu){
                std::cout << "processFileOrDir : get list file in directory '"<<inputFile<<"' :" << std::endl;
                //Let's remove ignore directories
                const PVecPath & listIgnoreDir = option.listIgnoreDir;
                PVecPath vecKeepDir = pathRemoveIfIgnored(listFileInDir, listIgnoreDir);
                
                for(PVecPath::iterator it(vecKeepDir.begin()); it != vecKeepDir.end(); ++it){
                        *it = inputFile / (*it);
                }
                std::cout << "Number of files = " << vecKeepDir.size() << std::endl;
//              phoenix_print(vecKeepDir);
                return createDirectoryWithFiles(outputDir, inputFile, vecKeepDir, option);
        }
        std::cout << "processFileOrDir : create file '" << fileName << "'" << std::endl;
        PPath outputFile(getSplitOutputFileName(outputDir / inputFile.getFileName(), isPlatexMode));
        //Get the permissions on the input file
        
        int fullMode(0);
        bool hasMode(true);
        if(!isPlatexMode){
                struct stat fileStat;
                if(stat(inputFile.c_str(), &fileStat) < 0){
                        hasMode = false;
                        std::cerr << "processFileOrDir : can't get permission of file '"<<inputFile<<"'" << std::endl;
                }else{
                        fullMode = fileStat.st_mode;
                }
        }
        bool  b(processFile(outputFile, inputFile, option.keepComment, option.keepTex, option.removefirstcomment, isPlatexMode));
        //Modify the permissions on the output file
        if(hasMode && !isPlatexMode){
                if(!outputFile.changeMode(fullMode)){
                        std::cerr << "processFileOrDir : Cannot set mode of file '"<<outputFile<<"'" << std::endl;
                }
        }
        return b;
}
 
 
bool processListFile(const SplitArgument & option){
        const PVecPath & listInputFile = option.listInputFile;
        if(listInputFile.size() == 0lu){return true;}
        bool b(true);
        for(PVecPath::const_iterator it(listInputFile.begin()); it != listInputFile.end(); ++it){
                b &= processFileOrDir(option.outputDir, *it, option);
        }
        return b;
}
 
 
int main(int argc, char** argv){
        OptionParser parser = createOptionParser();
        parser.parseArgument(argc, argv);
        
        SplitArgument option;
        
        const OptionMode & defaultMode = parser.getDefaultMode();
        defaultMode.getValue(option.listInputFile, "input");
        
        defaultMode.getValue(option.outputDir, "output");
        
        option.keepComment = defaultMode.isOptionExist("keepcomment");
        option.keepTex = defaultMode.isOptionExist("keeptex");
        option.removefirstcomment = defaultMode.isOptionExist("removefirstcomment");
        option.isPlatexMode = defaultMode.isOptionExist("platex");
        defaultMode.getValue(option.listIgnoreDir, "ignoredir");
        bool b(processListFile(option));
        return b - 1;
}