remove intent(in)

2023-12-14 23:57:39 +03:00
parent 92db6bbdea
commit e5572d9dff
1 changed files with 241 additions and 68 deletions
--- a/sapfor/experts/Sapfor_2017/_src/Transformations/checkpoints.cpp
+++ b/sapfor/experts/Sapfor_2017/_src/Transformations/checkpoints.cpp
@@ -3,6 +3,8 @@
 #include <vector>
 #include <string>
 #include <set>
+#include <iostream>
+#include <fstream>  

 #include "../Utils/SgUtils.h"
 #include "../Utils/utils.h"
@@ -38,7 +40,7 @@ static SgType* createArrayCharType(int len, int dim)
 }

 static void findDecls(SgExpression* ex, vector<SgExpression*>& local, const map<string, SgStatement*>& localParams,
-                      set<string>& added)
+    set<string>& added)
 {
    if (ex)
    {
@@ -71,7 +73,7 @@ static void findDecls(SgExpression* ex, vector<SgExpression*>& local, const map<
 }

 static void findLocalData(SgStatement* start, SgStatement* end, vector<SgExpression*>& local,
-                          map<string, SgStatement*>& localParams, set<string>& added)
+    map<string, SgStatement*>& localParams, set<string>& added)
 {
    for (SgStatement* st = start; st != end; st = st->lexNext())
    {
@@ -149,7 +151,7 @@ static SgExpression* getAttribute(SgExpression* spec, const string& type)
 static SgSymbol* makeVar(const string& name) { return new SgSymbol(VARIABLE_NAME, name.c_str()); }

 static void insertToOpenClose(const map<int, UserFiles>& needToSave, const vector<string>& names, const vector<string>& closedStatus,
-                              const string& iosModule)
+    const string& iosModule)
 {
    int z = 0;
    map<string, map<SgStatement*, set<string>>> useOnlyByFileAndFunc;
@@ -317,7 +319,7 @@ static bool createForIOs(const map<int, UserFiles>& filesInfo, SgStatement* func
    str_func->setExpression(0, NULL); //bad solution!
    str_func->insertStmtAfter(*makeDeclaration(NULL, { sSTR }), *str_func);

-    str_func->lastNodeOfStmt()->insertStmtBefore(*new SgInputOutputStmt(WRITE_STAT, *makeExprList({ new SgKeywordValExp("*"), new SgVarRefExp(sSTR)}, false), *new SgVarRefExp(k_par)), *str_func);
+    str_func->lastNodeOfStmt()->insertStmtBefore(*new SgInputOutputStmt(WRITE_STAT, *makeExprList({ new SgKeywordValExp("*"), new SgVarRefExp(sSTR) }, false), *new SgVarRefExp(k_par)), *str_func);
    SgAssignStmt* adjustl = new SgAssignStmt(*new SgVarRefExp(sSTR), *new SgFunctionCallExp(*new SgSymbol(FUNCTION_NAME, "ADJUSTL"), *new SgVarRefExp(sSTR)));
    str_func->lastNodeOfStmt()->insertStmtBefore(*adjustl, *str_func);

@@ -425,7 +427,7 @@ static void fillToProcess(FuncInfo* funcI, set<pair<FuncInfo*, FuncInfo*>>& toPr

 //TODO: reverse if 'before' == false
 static int insertInitNamesOfFiles(const int numOfFiles, const string& additional, SgSymbol* files, SgArrayRefExp* journal,
-                                  SgStatement* insert, bool before = true)
+    SgStatement* insert, bool before = true)
 {
    int maxFileLen = -1;
    string tmp;
@@ -498,8 +500,85 @@ static void replaceExprByExprInSt(SgStatement* st, SgExpression* from, SgExpress
 }


-void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBlocks, const map<int, UserFiles>& filesInfo, 
-                       const vector<FuncInfo*>& allFuncInfo)
+void deleteIntentIn(SgStatement* start, SgStatement* end)
+{
+    for (SgStatement* st = start; st != end; st = st->lexNext())
+    {
+        if (st->expr(2)) {
+            int var = st->expr(2)->lhs()->variant();
+            if (var == 468)
+                st->setExpression(2, NULL);
+        }
+    }
+}
+
+void replaceIntentInWithIntentinOut(SgStatement* start, SgStatement* end)
+{
+    for (SgStatement* st = start; st != end; st = st->lexNext())
+    {
+        if (st->expr(2)) {
+            int var = st->expr(2)->lhs()->variant();
+            if (var == 468)
+                st->expr(2)->lhs()->setVariant(470);
+        }
+    }
+}
+
+static void findLocalDataNoIntentIn(SgStatement* start, SgStatement* end, vector<SgExpression*>& local,
+    map<string, SgStatement*>& localParams, set<string>& added)
+{
+    for (SgStatement* st = start; st != end; st = st->lexNext())
+    {
+        if (st->variant() == PARAM_DECL)
+        {
+            auto decl = (SgParameterStmt*)st;
+            for (int z = 0; z < decl->numberOfConstants(); ++z)
+                localParams[decl->constant(z)->identifier()] = st;
+        }
+
+        if (st->variant() == EXTERN_STAT)
+            for (SgExpression* ex = st->expr(0); ex; ex = ex->rhs())
+                added.insert(ex->lhs()->symbol()->identifier());
+    }
+
+    for (SgStatement* st = start; st != end; st = st->lexNext())
+        if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
+            if (st->expr(2) && st->expr(2)->lhs()->variant() == 468) {
+                SgExpression* ex = st->expr(0);
+                while (ex)
+                {
+                    if (ex->lhs())
+                        if (ex->lhs()->variant() == VAR_REF)
+                            added.insert(ex->lhs()->symbol()->identifier());
+
+                    ex = ex->rhs();
+                }
+            }
+
+    for (SgStatement* st = start; st != end; st = st->lexNext())
+    {
+        //printf("line %d %s Var %s\n", st->lineNumber(), st->fileName(), tag[st->variant()]);
+        if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
+            findDecls(st->expr(0), local, localParams, added);
+    }
+
+    for (SgStatement* st = start; st != end; st = st->lexNext())
+        if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
+            if (st->expr(2) && st->expr(2)->lhs()->variant() == 468) {
+                SgExpression* ex = st->expr(0);
+                while (ex)
+                {
+                    if (ex->lhs())
+                        if (ex->lhs()->variant() == VAR_REF)
+                            added.erase(ex->lhs()->symbol()->identifier());
+
+                    ex = ex->rhs();
+                }
+            }
+}
+
+void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBlocks, const map<int, UserFiles>& filesInfo,
+    const vector<FuncInfo*>& allFuncInfo)
 {
    map<int, cpInfo> inFileCp;
    bool inFile = findSpfCpDir(file, inFileCp);
@@ -566,14 +645,18 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                checkNull(lastDecl, convertFileName(__FILE__).c_str(), __LINE__);
                SgStatement* firstExec = lastDecl->lexNext();

+                //deleteIntentIn(func->lexNext(), firstExec);
+                //replaceIntentInWithIntentinOut(func->lexNext(), firstExec);
+
                vector<SgExpression*> local;
                map<string, SgStatement*> localParams;
                set<string> addedToList;
-                findLocalData(func->lexNext(), lastDecl, local, localParams, addedToList);
-                const vector<SgStatement*> useOfMods = findUseOfModules(func->lexNext(), lastDecl);
+                findLocalDataNoIntentIn(func->lexNext(), firstExec, local, localParams, addedToList);
+                const vector<SgStatement*> useOfMods = findUseOfModules(func->lexNext(), firstExec);

                SgStatement* loadBlock = new SgStatement(IF_NODE);
                SgStatement* storeBlock = new SgStatement(IF_NODE);
+                //std::cout << "##############################################################################" << std::endl;

                point->insertStmtBefore(*loadBlock, *point->controlParent());
                point->insertStmtBefore(*storeBlock, *point->controlParent());
@@ -587,22 +670,37 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                SgArrayRefExp* journal = new SgArrayRefExp(*files, *new SgValueExp(numOfFiles + 1));

                //give max len, dont insert
+                /* after store-block in func with cp:
+                spf_cp_files_0_26(1) = 'spf_cp_file_1_0_26'
+                spf_cp_files_0_26(2) = 'spf_cp_file_2_0_26'
+                spf_cp_files_0_26(3) = 'spf_cp_journal_0_26'
+                */
                int maxFileLen = insertInitNamesOfFiles(numOfFiles, additional, files, journal, NULL);

                vector<SgSymbol*> everyS;
                vector<SgSymbol*> profS;
                vector<SgExpression*> initS;

-                string profSs = "spf_cp_prof_s" + additional;
-                string profEs = "spf_cp_prof_e" + additional;
+                string
+                    profSs = "spf_cp_prof_s" + additional,
+                    profEs = "spf_cp_prof_e" + additional;
+
                profS.push_back(new SgSymbol(VARIABLE_NAME, profSs.c_str(), SgTypeFloat(), func));
                profS.push_back(new SgSymbol(VARIABLE_NAME, profEs.c_str(), SgTypeFloat(), func));

-                SgSymbol* timeF = new SgSymbol(FUNCTION_NAME, "omp_get_wtime", SgTypeDouble(),func); // OR dvtime
+                SgSymbol* timeF = new SgSymbol(FUNCTION_NAME, "omp_get_wtime", SgTypeDouble(), func); // OR dvtime

+                //spf_cp_prof_s(e)_0_26 = omp_get_wtime()
                SgStatement* profCallS = new SgAssignStmt(*new SgVarRefExp(profS[0]), *new SgFunctionCallExp(*timeF));
                SgStatement* profCallE = new SgAssignStmt(*new SgVarRefExp(profS[1]), *new SgFunctionCallExp(*timeF));

+                /* beginning of store block :
+                * ! STORE CHECKPOINT
+                spf_cp_interval_0_26 = spf_cp_interval_0_26 + 1
+                if (spf_cp_interval_0_26 .ge. 1) then
+                    spf_cp_interval_0_26 = 0
+                endif
+                */
                if (type == typeEvery::TIME)
                {
                    string everySs = "spf_cp_start" + additional;
@@ -633,14 +731,31 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                    everyS.push_back(new SgSymbol(VARIABLE_NAME, everyIs.c_str(), SgTypeInt(), func));
                    initS.push_back(new SgValueExp(0));
                    SgAssignStmt* init = new SgAssignStmt(*new SgVarRefExp(everyS[0]), *new SgValueExp(0));
+                    //std::cout << "INIT::" << std::endl;
+                    //init->unparsestdout();
+                    //std::cout << "storeBlock before::" << std::endl;
+                    //storeBlock->unparsestdout();
                    storeBlock->insertStmtAfter(*init, *storeBlock);
+                    //std::cout << "storeBlock after init::" << std::endl;
+                    //storeBlock->unparsestdout();

                    SgAssignStmt* inc = new SgAssignStmt(*new SgVarRefExp(everyS[0]), *new SgVarRefExp(everyS[0]) + *new SgValueExp(1));
+                    //std::cout << "INC::" << std::endl;
+                    //init->unparsestdout();
+                    //std::cout << "storeBlock->controlParent()::" << std::endl;
+                    //storeBlock->controlParent()->unparsestdout();
                    storeBlock->insertStmtBefore(*inc, *storeBlock->controlParent());
                    inc->addComment("! STORE CHECKPOINT\n");
+                    //std::cout << "storeBlock after inc::" << std::endl;
+                    //storeBlock->unparsestdout();

                    storeBlock->setExpression(0, *new SgVarRefExp(everyS[0]) >= *new SgValueExp(every));
+                    //std::cout << "storeBlock after setexpr::" << std::endl;
+                    //storeBlock->unparsestdout();
+                    //std::cout << "storeBlock->controlParent()::" << std::endl;
+                    //storeBlock->controlParent()->unparsestdout();
                }
+                //std::cout << "##############################################################################" << std::endl;

                vector<SgSymbol*> loadS;
                vector<SgExpression*> initLoadS;
@@ -658,9 +773,9 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                loadS.push_back(new SgSymbol(VARIABLE_NAME, iostatS.c_str(), SgTypeInt(), func));
                initLoadS.push_back(NULL);

-              /*string loadSaveS = "spf_cp_load_save" + additional;
-                loadS.push_back(new SgSymbol(VARIABLE_NAME, loadSaveS.c_str(), SgTypeInt(), func));
-                initLoadS.push_back(new SgValueExp(0));*/
+                /*string loadSaveS = "spf_cp_load_save" + additional;
+                  loadS.push_back(new SgSymbol(VARIABLE_NAME, loadSaveS.c_str(), SgTypeInt(), func));
+                  initLoadS.push_back(new SgValueExp(0));*/

                string loadLabelS = "spf_cp_load_label" + additional;
                loadS.push_back(new SgSymbol(VARIABLE_NAME, loadLabelS.c_str(), SgTypeInt(), func));
@@ -670,10 +785,18 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                loadS.push_back(new SgSymbol(VARIABLE_NAME, saveFS.c_str(), SgTypeInt(), func));
                initLoadS.push_back(new SgValueExp(0));

+                //std::cout << "loadBlock->controlParent()::" << std::endl;
+                //loadBlock->controlParent()->unparsestdout();
                loadBlock->setExpression(0, *new SgVarRefExp(loadS[0]) == *new SgValueExp(0));
                SgAssignStmt* init = new SgAssignStmt(*new SgVarRefExp(loadS[0]), *new SgValueExp(1));
+                //std::cout << "INIT::" << std::endl;
+                //init->unparsestdout();
                insertToLoadS.push_back(init);

+                //std::cout << "loadBlock->controlParent()::" << std::endl;
+                //loadBlock->controlParent()->unparsestdout();
+                //std::cout << "##############################################################################" << std::endl;
+
                vector<SgExpression*> listSpec;

                SgExpression& unitNull = SgAssignOp(*new SgKeywordValExp("unit"), *new SgKeywordValExp("*"));
@@ -684,6 +807,7 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                SgExpression* iostat = new SgVarRefExp(loadS[2]);
                SgExpression* fileIdx = new SgVarRefExp(loadS[1]);

+                // for first open journal file in load block
                listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("iostat"), *iostat));
                listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("status"), *new SgValueExp("old")));
                listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("file"), *journal));
@@ -711,9 +835,17 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                insertToifLoadOk.push_back(open);

                SgIfStmt* ifLoadOk1 = new SgIfStmt(*iostat == *new SgValueExp(0), *new SgIOControlStmt(CLOSE_STAT, unit));
+                //std::cout << "ifLoadOk1::" << std::endl;
+                //ifLoadOk1->unparsestdout();


                insertToifLoadOk.push_back(ifLoadOk1);
+                /* from "! LOAD DATA FROM CHECKPOINT"
+                spf_cp_file_n_0_26 = spf_cp_file_n_0_26 + 1
+                  if (spf_cp_file_n_0_26 .eq. 3) then
+                     spf_cp_file_n_0_26 = 1
+                  endif
+                */
                ifLoadOk1->insertStmtAfter(*new SgIfStmt(*fileIdx == *new SgValueExp(numOfFiles + 1), *new SgAssignStmt(*fileIdx, *new SgValueExp(1))), *ifLoadOk1);
                ifLoadOk1->insertStmtAfter(*new SgAssignStmt(*fileIdx, *fileIdx + *new SgValueExp(1)), *ifLoadOk1);
                ifLoadOk1->addComment("! LOAD DATA FROM CHECKPOINT\n");
@@ -730,6 +862,7 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                //open all files
                if (createdModuleForIO)
                {
+                    //std::cout << "createdModuleForIO" << std::endl;
                    SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, iosNames[1].c_str()));
                    ifLoadOk1->insertStmtAfter(*call, *ifLoadOk1);
                }
@@ -737,6 +870,7 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                //READ from modules
                for (auto& mod : moduleNames)
                {
+                    //std::cout << "READ from modules" << std::endl;
                    SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, ("SPF_CP_" + mod).c_str()));
                    call->addArg(*new SgValueExp(unitNum));
                    call->addArg(*new SgValueExp(0));
@@ -746,11 +880,16 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                //READ DATA
                if (local.size())
                {
+                    //std::cout << "READ DATA" << std::endl;
                    auto dataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(local, false));
                    ifLoadOk1->insertStmtAfter(*dataRead, *ifLoadOk1);
                }

                ifLoadOk1->insertStmtAfter(profCallS->copy(), *ifLoadOk1);
+                //std::cout << "loadBlock->controlParent()::" << std::endl;
+                //loadBlock->controlParent()->unparsestdout();
+
+                // loadblock done (need to upload)

                listSpec.clear();
                listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("form"), *new SgValueExp("unformatted")));
@@ -822,19 +961,41 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                assign->insertStmtBefore(*new SgIOControlStmt(CLOSE_STAT, unit), *ifStoreOk);

                ifStoreOk->insertStmtAfter(profCallS->copy(), *ifStoreOk);
+                // store-block done

+                // block after name of files and before first executable operator
                SgStatement* copyForGoto = loadBlock->copyPtr();
+                //std::cout << "copyForGoto::" << std::endl;
+                //copyForGoto->unparsestdout();
                copyForGoto->deleteLabel();
+                //std::cout << "copyForGoto after delete label::" << std::endl;
+                //copyForGoto->unparsestdout();
+                //std::cout << "firstExec::" << std::endl;
+                //firstExec->unparsestdout();
                firstExec->insertStmtBefore(*copyForGoto, *func);
+                //std::cout << "firstExec parent after insert::" << std::endl;
+                //firstExec->controlParent()->unparsestdout();
+                //loadBlock->controlParent()->unparsestdout();
                insertInitNamesOfFiles(numOfFiles, additional, files, journal, copyForGoto, true);
+                //std::cout << "insert names of files::" << std::endl;

                copyForGoto->insertStmtAfter(insertToLoadS[insertToLoadS.size() - 1]->copy(), *copyForGoto);
+                //std::cout << "copyForGoto::" << std::endl;
+                //copyForGoto->controlParent()->unparsestdout();
                copyForGoto->insertStmtAfter(insertToLoadS[insertToLoadS.size() - 2]->copy(), *copyForGoto);
+                //std::cout << "copyForGoto::" << std::endl;
+                //copyForGoto->controlParent()->unparsestdout();

                copyForGoto = copyForGoto->lexNext()->lexNext();
+                //std::cout << "copyForGoto after double lexnext::" << std::endl;
+                //copyForGoto->unparsestdout();

                copyForGoto->insertStmtAfter(*new SgGotoStmt(*loadblockLab), *copyForGoto);
+                //std::cout << "copyForGoto::" << std::endl;
+                //copyForGoto->controlParent()->unparsestdout();
                copyForGoto->insertStmtAfter(*new SgIOControlStmt(CLOSE_STAT, unit), *copyForGoto);
+                //std::cout << "copyForGoto::" << std::endl;
+                //copyForGoto->controlParent()->unparsestdout();

                for (int z = insertToLoadS.size() - 1; z >= 0; --z)
                    loadBlock->insertStmtAfter(*insertToLoadS[z], *loadBlock);
@@ -842,6 +1003,9 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                for (int z = insertToifLoadOk.size() - 1; z >= 0; --z)
                    ifLoadOk->insertStmtAfter(*insertToifLoadOk[z], *ifLoadOk);

+                // load block added
+
+                //std::cout << "##############################################################################" << std::endl;

                //TODO:
                /*set<string> elemNotDeclHere;
@@ -927,6 +1091,7 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                map<FuncInfo*, SgStatement*> processedFrom;
                for (auto j = toProcess.begin(); j != toProcess.end(); j++)
                {
+                    std::cout << "( " << (j->first)->funcName << " ,    " << (j->second)->funcName << "  ) " << std::endl;
                    int callNum = 1;
                    SgStatement* hedrTo = (j->first)->funcPointer->GetOriginal();
                    SgStatement* hedrFrom = (j->second)->funcPointer->GetOriginal();
@@ -935,10 +1100,13 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                        lastDecl = lastDecl->lexNext();

                    SgStatement* firstExec = lastDecl->lexNext();
+
+                    deleteIntentIn(hedrFrom->lexNext(), firstExec);
+
                    vector<SgExpression*> local;
                    map<string, SgStatement*> localParams;
                    set<string> addedToList;
-                    findLocalData(hedrFrom->lexNext(), lastDecl, local, localParams, addedToList);
+                    findLocalData(hedrFrom->lexNext(), firstExec, local, localParams, addedToList);
                    if (!processedFrom.count(j->second))
                    {
                        SgSymbol* modS = moduleF->symbol();
@@ -1000,20 +1168,25 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                                ifLoadOk->insertStmtAfter(*insertToifLoadOk[z], *ifLoadOk);

                            processedFrom[j->second] = ifLoadOk1->lexNext();
-                            processedFrom[j->second]->unparsestdout();
+                            //processedFrom[j->second]->unparsestdout();
                        }
                        else
                        {
-                            SgStatement * read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *new SgVarRefExp(loadS[3]));
+                            SgStatement* read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *new SgVarRefExp(loadS[3]));
                            gotoBlock->insertStmtAfter(*read, *gotoBlock);
                            processedFrom[j->second] = gotoBlock->lexNext();
+                            firstExec->insertStmtBefore(*gotoBlock, *hedrFrom);
                        }
-
+                        processedFrom[j->second]->unparsestdout();
+                        //std::cout << "gotoblock: " << std::endl;
+                        //gotoBlock->unparsestdout();
                    }

                    for (auto& callInfo : j->second->callsFromDetailed)
                    {
+                        //std::cout << "callinfo name:  " << callInfo.detailCallsFrom.first << std::endl;
                        auto& call = callInfo.pointerDetailCallsFrom;
+                        //std::cout << "callinfo var:  " << call.second << std::endl;
                        SgStatement* st = NULL;

                        if (isSgFuncHedrStmt(hedrTo) && call.second == FUNC_CALL)
@@ -1022,10 +1195,10 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                            if (!strcmp(callExp->funName()->identifier(), (j->first)->funcName.c_str()))
                            {
                                st = SgStatement::getStatmentByExpression(callExp);
-                                SgSymbol * buf = new SgSymbol(VARIABLE_NAME, ("SPF_CALL_"+ (j->first)->funcName + "_" + to_string(callNum)).c_str(), callExp->type(), (j->second)->funcPointer->GetOriginal());
+                                SgSymbol* buf = new SgSymbol(VARIABLE_NAME, ("SPF_CALL_" + (j->first)->funcName + "_" + to_string(callNum)).c_str(), callExp->type(), (j->second)->funcPointer->GetOriginal());
                                SgExpression* bufRef = new SgVarRefExp(buf);
                                SgStatement* bufAssign = new SgAssignStmt(*bufRef, *callExp);
-                                st->insertStmtBefore(*bufAssign,* (st->controlParent()));
+                                st->insertStmtBefore(*bufAssign, *(st->controlParent()));
                                replaceExprByExprInSt(st, callExp, bufRef);
                                makeDeclaration(hedrFrom, { buf });
                                for (int i = 0; i < callExp->numberOfArgs(); i++)
@@ -1044,11 +1217,11 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc

                                        }

-                                        SgSymbol* argBuf = new SgSymbol(VARIABLE_NAME, ("SPF_ARG_" + (j->first)->funcName+"_" + to_string(callNum) + "_" + to_string(i)).c_str(), s->type(), (j->second)->funcPointer->GetOriginal());
+                                        SgSymbol* argBuf = new SgSymbol(VARIABLE_NAME, ("SPF_ARG_" + (j->first)->funcName + "_" + to_string(callNum) + "_" + to_string(i)).c_str(), s->type(), (j->second)->funcPointer->GetOriginal());
                                        SgExpression* argBufRef = new SgVarRefExp(argBuf);
                                        SgStatement* argBufAssign = new SgAssignStmt(*argBufRef, *(callExp->arg(i)));
                                        bufAssign->insertStmtBefore(*argBufAssign, *(st->controlParent()));
-                                        SgStatement* decl = makeDeclaration(hedrFrom, {argBuf});
+                                        SgStatement* decl = makeDeclaration(hedrFrom, { argBuf });

                                        for (int i = 0; i < 3; i++)
                                        {
@@ -1096,7 +1269,7 @@ void createCheckpoints(SgFile *file, const map<string, CommonBlock*>& commonBloc
                            loadBlock->setLabel(*loadblockLab);

                            SgIfStmt* gotoIf = new SgIfStmt(*new SgVarRefExp(loadS[3]) == *new SgValueExp(labNum), *new SgGotoStmt(*loadblockLab));
-                            processedFrom[j->second]->insertStmtAfter(*gotoIf,*(processedFrom[j->second]->controlParent()));
+                            processedFrom[j->second]->insertStmtAfter(*gotoIf, *(processedFrom[j->second]->controlParent()));

                            storeBlock->addComment("! STORE CHECKPOINT\n");

@@ -1186,7 +1359,7 @@ static void createModule(SgStatement*& module, const string& name, bool withFile
 }

 static SgExpression* moveSaveAssignToMod(SgExpression* ex, SgStatement*& saveModule,
-                                         map<string, SgStatement*>& declLists, const string& procName, bool withInit)
+    map<string, SgStatement*>& declLists, const string& procName, bool withInit)
 {
    if (saveModule == NULL)
        createModule(saveModule, "spf_module_save_");