psrc_split_lib.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "psrc_split_lib.h"
 
 
void flushCode(std::ofstream & fs, PTypeCode::PTypeCode typeCode, PString & code, bool isPlatexMode, const PString & envName, bool keepTex){
        if(typeCode == PTypeCode::CODE){
                if(isPlatexMode){
                        code = code.eraseFirstLastChar("\n");
                }else{
                        code = code.eraseFirstChar("\n");
                }
                if(code != ""){
                        if(isPlatexMode){
                                fs << "\\begin{" << envName << "}" << std::endl;
                                fs << code << std::endl;
                                fs << "\\end{" << envName << "}" << std::endl << std::endl;
                        }else{
                                fs << code;
                        }
                }
                code = "";
        }
}
 
 
void splitInputFile(std::ofstream & fs, PFileParser & parser,
                        bool keepComment, bool keepTex, bool isPlatexMode, const PString & envName,
                        const PString & lineCommentBegin, const PString & lineCommenEnd,
                        const PString & monolineComment,
                        const PString & ptexLineCommentBegin, const PString & ptexLineCommenEnd,
                        const PString & ptexMonolineComment)
{
        PString ptexComment(""), code("");
        PTypeCode::PTypeCode typeCode(PTypeCode::CODE);
        while(!parser.isEndOfFile()){
                //Check if a ptex comment matches
                if(parser.isMatch(ptexLineCommentBegin)){                                               //Multiline version
                        PString fullComment(parser.getUntilKeyWithoutPatern(ptexLineCommenEnd));
                        flushCode(fs, typeCode, code, isPlatexMode, envName, keepTex);
                        typeCode = PTypeCode::PTEX_COMMENT;
                        ptexComment += fullComment;
                }else if(parser.isMatch(ptexMonolineComment)){                                          //Mono line version
                        PString fullComment(parser.getUntilKeyWithoutPatern("\n"));
                        flushCode(fs, typeCode, code, isPlatexMode, envName, keepTex);
                        typeCode = PTypeCode::PTEX_COMMENT;
                        ptexComment += fullComment;
                }else if(parser.isMatch(lineCommentBegin)){                                     //Check if a Standard multiline comment matches
                        PString fullComment(lineCommentBegin + parser.getUntilKeyWithoutPatern(lineCommenEnd) + lineCommenEnd);
                        if(typeCode == PTypeCode::PTEX_COMMENT){        //Flush latex comment if there was one
                                if(keepTex){fs << ptexComment << std::endl;}
                                ptexComment = "";
                        }
                        typeCode = PTypeCode::CODE;
                        if(keepComment){
                                code += fullComment;
                        }
                }else if(parser.isMatch(monolineComment)){
                        PString fullComment(monolineComment + parser.getUntilKeyWithoutPatern("\n") + "\n");
                        if(typeCode == PTypeCode::PTEX_COMMENT){        //Flush latex comment if there was one
                                if(keepTex){fs << ptexComment << std::endl;}
                                ptexComment = "";
                        }
                        typeCode = PTypeCode::CODE;
                        if(keepComment){
                                code += fullComment;
                        }
                }else{                                                                          //This is simple code
                        if(typeCode == PTypeCode::PTEX_COMMENT){        //Flush latex comment if there was one
                                if(keepTex){fs << ptexComment << std::endl;}
                                ptexComment = "";
                        }
                        typeCode = PTypeCode::CODE;
                        code += parser.getCurrentCh();
                        parser.getNextChar();
                }
        }
        //Check is there is still somme code, standardComment or ptexComment to be saved
        flushCode(fs, typeCode, code, isPlatexMode, envName, keepTex);
        if(ptexComment != "" && keepTex){
                fs << ptexComment << std::endl;
        }
}
 
 
 
bool createPTexFile(const PPath & outputFile, const PPath & inputFile,
                        bool keepComment, bool keepTex, bool removefirstcomment, bool isPlatexMode,
                        const PString & envName,
                        const PString & lineCommentBegin, const PString & lineCommenEnd, const PString & monolineComment)
{
        PString ptexLineCommentBegin("");
        PString ptexLineCommenEnd("");
        if(lineCommentBegin != "" && lineCommenEnd != ""){
                ptexLineCommentBegin = lineCommentBegin + "{";
                ptexLineCommenEnd = "}" + lineCommenEnd;
        }
        PString ptexMonolineComment("");
        if(monolineComment != ""){
                ptexMonolineComment = monolineComment + "{";
        }
        
        std::ofstream fs;
        if(!openFileStream(fs, outputFile)){return false;}
        
        PFileParser parser;
        if(!parser.open(inputFile)){
                std::cerr << "createPTexFile : can't parse input file '"<<inputFile<<"'" << std::endl;
                return false;
        }
        parser.setEscapeChar('\0');
        parser.setWhiteSpace("");
        if(removefirstcomment){
                if(parser.isMatch(lineCommentBegin)){
                        parser.getUntilKeyWithoutPatern(lineCommenEnd);
                }
        }
        splitInputFile(fs, parser, keepComment, keepTex, isPlatexMode, envName, lineCommentBegin, lineCommenEnd, monolineComment,
                        ptexLineCommentBegin, ptexLineCommenEnd, ptexMonolineComment);
        fs.close();
        return true;
}
 
 
PPath getSplitOutputFileName(const PPath & outputFile, bool isPlatexMode){
        PString nameOutputFile(outputFile);
        PString ext(outputFile.getExtension());
        if(isPlatexMode && ext != "ptex"){
                nameOutputFile += ".ptex";
        }
        return nameOutputFile;
}
 
 
bool processFile(const PPath & outputFile, const PPath & inputFile,
                bool keepComment, bool keepTex, bool removefirstcomment, bool isPlatexMode)
{
        if(outputFile == "" || inputFile == ""){
                std::cerr << "processFile : missing input or output file" << std::endl;
                return false;
        }
        PString nameOutputFile(getSplitOutputFileName(outputFile, isPlatexMode));
        PString ext(inputFile.getExtension());
        PString baseFileName(inputFile.getFileName().eraseExtension());
        if(ext == "c" || ext == "cpp" || ext == "c++" || ext == "h" || ext == "hpp"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "cpp", "/*", "*/", "//");
        }else if(ext == "cu"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "cuda", "/*", "*/", "//");
        }else if(ext == "cmake" || baseFileName == "CMakeLists"){
                return createPTexFile(outputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "cmake", "#[[", "]]", "#");
        }else if(ext == "py"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "python", "'''", "'''", "#");
        }else if(ext == "sh"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "bash", ": '", "'", "#");
        }else if(baseFileName == "Dockerfile"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "dockerfile", "", "", "#");
        }else if(baseFileName == "Singularity" || baseFileName == "Apptainer"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "apptainer", "", "", "#");
        }else if(ext == "submit"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "condor", "", "", "#");
        }else if(ext == "yml"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "yml", "", "", "#");
        } if(ext == "toml"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "toml", "", "", "#");
        }else if(ext == "md"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "markdown", "<!--", "-->", "");
        }else if(ext == "gnuplot"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "gnuplot", "", "", "#");
        }else if(ext == "rs"){
                return createPTexFile(nameOutputFile, inputFile, keepComment, keepTex, removefirstcomment, isPlatexMode, "rust", "/*", "*/", "//");
        }else{
                std::cout << "Copy file '"<<inputFile<<"' into '"<<nameOutputFile<<"'" << std::endl;
                std::ifstream ifs(inputFile.c_str());
                std::ofstream fs(nameOutputFile.c_str());
                fs << ifs.rdbuf();
                fs.close();
                return true;
        }
}