Merge branch 'master' into CP_new_blocks

.gitignore

@@ -74,3 +74,5 @@ sapfor/experts/Sapfor_2017/Sapc++/Sapc++/x64/
 sapfor/experts/Sapfor_2017/Sapc++/x64/
 
 /build
+
+sapfor/experts/Sapfor_2017/out/

sapfor/experts/Sapfor_2017/_src/Sapfor.cpp

@@ -2432,7 +2432,7 @@ int main(int argc, char **argv)
         int numVar = 0;
 
         out_free_form = 0; // F90 style out
-        out_upper_case = 1;
+        out_upper_case = 0;
         out_line_unlimit = 0;
 
         bool printText = false;

sapfor/experts/Sapfor_2017/_src/Transformations/function_purifying.cpp

@@ -1010,7 +1010,7 @@ void commonTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo, const map
     }
 }
 
-static string changeData(const string data, const map<string, string>& constSymVars, const map<string, string>& locVars)
+static string changeData(const string& data, const map<string, string>& constSymVars, const map<string, string>& locVars)
 {
     int curChar = 0;
     string ident = "";

sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp

@@ -30,7 +30,7 @@ static void FillCommonTypes(map<char, SgType*>& types)
             types[letter.first] = new SgType(T_FLOAT);
 }
 
-static void FindAllVars(SgExpression* expr, set<SgSymbol*>& allVars, set<SgSymbol*>& allVarsConst)
+static void FindAllVars(SgExpression* expr, set<SgSymbol*>& allVars, set<SgSymbol*>& allVarsConst, SgStatement* scope)
 {
     if (expr == NULL)
         return;
@@ -39,14 +39,24 @@ static void FindAllVars(SgExpression* expr, set<SgSymbol*>& allVars, set<SgSymbo
     if (var == VAR_REF || var == ARRAY_REF || var == FUNC_CALL)
     {
         auto s = expr->symbol();
-        if ((s->attributes() & EXTERNAL_BIT) == 0)
+        if ((s->attributes() & EXTERNAL_BIT))
-            allVars.insert(s);
+        {
+            if (var == FUNC_CALL && !IS_BY_USE(s) && s->scope() == scope)
+                allVars.insert(s);
+        }
+        else
+        {
+            if (!IS_BY_USE(s) && s->scope() == scope)
+            {
+                allVars.insert(s);
+            }
+        }
     }
     else if (var == CONST_REF)
         allVarsConst.insert(expr->symbol());
 
-    FindAllVars(expr->lhs(), allVars, allVarsConst);
+    FindAllVars(expr->lhs(), allVars, allVarsConst, scope);
-    FindAllVars(expr->rhs(), allVars, allVarsConst);
+    FindAllVars(expr->rhs(), allVars, allVarsConst, scope);
 }
 
 static char getValue(SgExpression* ex)
@@ -89,7 +99,7 @@ static void AddLettersToMap(SgExpression* expr, SgType* type, map<char, SgType*>
     }
 }
 
-static vector<SgSymbol*> getVars(const char* funcSymbol, set<SgSymbol*>& toRename, 
+static vector<SgSymbol*> getVars(const set<string>& functionSymbs, set<SgSymbol*>& toRename,
                                  const set<SgSymbol*>& allVars, const map<char, SgType*>& types)
 {
     vector<SgSymbol*> varsWithoutDecl;
@@ -103,7 +113,7 @@ static vector<SgSymbol*> getVars(const char* funcSymbol, set<SgSymbol*>& toRenam
 
     for (auto& var : allVars)
     {
-        if (string(var->identifier()) == funcSymbol)
+        if (functionSymbs.count(var->identifier()))
             continue;
 
         vector<SgStatement*> allDecls;
@@ -187,18 +197,55 @@ static map<char, SgType*> FunctionImplicitCheck(SgStatement* function, const map
     
     set<int> skip = { EXTERN_STAT };
 
+    set<SgSymbol*> allDataSymbols;
+    for (auto s = function->symbol()->next(); s; s = s->next())
+        if ((s->attributes() & DATA_BIT) && s->scope() == function)
+            allDataSymbols.insert(s);
+
+    set<string> functionSymbs = { function->symbol()->identifier() };
+    if (isSgFuncHedrStmt(function))
+    {
+        SgFuncHedrStmt* hedr = isSgFuncHedrStmt(function);
+        if (hedr->resultName())
+            functionSymbs.insert(hedr->resultName()->identifier());
+    }
+
     for (auto st = function->lexNext(); st != endOfFunc && st->variant() != CONTAINS_STMT; st = st->lexNext())
     {
         if (skip.count(st->variant()))
             continue;
 
+        if (isDVM_stat(st) || isSPF_stat(st))
+            continue;
+
+        if (st->variant() == INTERFACE_STMT)
+        {
+            st = st->lastNodeOfStmt();
+            continue;
+        }
+
+        if (st->variant() == DATA_DECL)
+        {
+            const string str = st->expr(0)->thellnd->entry.string_val;
+            
+            for (auto& data : allDataSymbols)
+            {
+                if (str.find(data->identifier()) != string::npos)
+                    allVars.insert(data);
+            }
+        }
+
         for (int i = 0; i < 3; ++i)
-            FindAllVars(st->expr(i), allVars, allVarsConst);
+            FindAllVars(st->expr(i), allVars, allVarsConst, function);
 
         if (st->variant() == FOR_NODE)
-            allVars.insert(isSgForStmt(st)->doName());
+        {
+            auto s = isSgForStmt(st)->doName();
+            if (!IS_BY_USE(s) && s->scope() == function)
+                allVars.insert(s);
+        }
     }
-
+    
     //add parameters
     auto prog = isSgProgHedrStmt(function);
     if (prog)
@@ -211,11 +258,13 @@ static map<char, SgType*> FunctionImplicitCheck(SgStatement* function, const map
         }
     }
 
-    varsWithoutDecl = getVars(function->symbol()->identifier(), toRename, allVars, types);
+    varsWithoutDecl = getVars(functionSymbs, toRename, allVars, types);
-    varsWithoutDeclConst = getVars(function->symbol()->identifier(), toRename, allVarsConst, types);
+    varsWithoutDeclConst = getVars(functionSymbs, toRename, allVarsConst, types);
     
     if (!hasImplicitNone)
     {
+        vector<SgStatement*> macro;
+
         for (auto st = function->lexNext(); 
              st != endOfFunc && st->variant() != CONTAINS_STMT && isSgExecutableStatement(st) == NULL; 
              )
@@ -226,6 +275,12 @@ static map<char, SgType*> FunctionImplicitCheck(SgStatement* function, const map
                 st = st->lexNext();
                 tmpStatement->deleteStmt();
             }
+            else if (st->variant() == STMTFN_STAT)
+            {
+                auto stat = st;
+                st = st->lexNext();
+                macro.push_back(stat->extractStmt());
+            }
             else
                 st = st->lexNext();
         }
@@ -243,9 +298,16 @@ static map<char, SgType*> FunctionImplicitCheck(SgStatement* function, const map
 
         if (function->variant() == FUNC_HEDR)
         {
+            SgFuncHedrStmt* hedr = isSgFuncHedrStmt(function);
+
             auto type_op = function->expr(1);
             if (type_op == NULL)
-                varsWithoutDecl.push_back(function->symbol());
+            {
+                if (hedr->resultName())
+                    varsWithoutDecl.push_back(hedr->resultName());
+                else
+                    varsWithoutDecl.push_back(function->symbol());
+            }
         }
 
         makeDeclaration(varsWithoutDecl, function);
@@ -253,6 +315,18 @@ static map<char, SgType*> FunctionImplicitCheck(SgStatement* function, const map
         auto declList = makeDeclaration(varsWithoutDeclConst, NULL);
         for (auto& decl : declList)
             insertPlace->insertStmtAfter(*decl, *function);
+
+        if (macro.size())
+        {
+            while (!isSgExecutableStatement(insertPlace) && insertPlace != NULL)
+                insertPlace = insertPlace->lexNext();
+
+            if (insertPlace == NULL)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            for (auto& elem : macro)
+                insertPlace->insertStmtBefore(*elem, *function);
+        }
     }
 
     for (auto& s : toRename)
@@ -265,9 +339,12 @@ void implicitCheck(SgFile* file)
 {
     map<SgStatement*, map<char, SgType*>> typesByFunctions;
 
-    for (int func = 0; func < file->numberOfFunctions(); ++func)
+    vector<SgStatement*> modulesAndFunctions;
+    getModulesAndFunctions(file, modulesAndFunctions);
+
+    for (int func = 0; func < modulesAndFunctions.size(); ++func)
     {
-        SgStatement* function = file->functions(func);
+        SgStatement* function = modulesAndFunctions[func];
         typesByFunctions[function] = FunctionImplicitCheck(function, typesByFunctions);
     }
 

sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h

@@ -310,6 +310,8 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
     list({ CALL_GRAPH2, REVERT_SUBST_EXPR_RD }) <= Pass(REMOVE_DEAD_CODE);
     list({ REMOVE_DEAD_CODE, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN }) <= Pass(REMOVE_DEAD_CODE_AND_UNPARSE);
 
+    Pass(CORRECT_VAR_DECL) <= Pass(SET_IMPLICIT_NONE);
+
     passesIgnoreStateDone.insert({ CREATE_PARALLEL_DIRS, INSERT_PARALLEL_DIRS, INSERT_SHADOW_DIRS, EXTRACT_PARALLEL_DIRS, 
                                    EXTRACT_SHADOW_DIRS, CREATE_REMOTES, UNPARSE_FILE, REMOVE_AND_CALC_SHADOW,
                                    REVERSE_CREATED_NESTED_LOOPS, PREDICT_SCHEME, CALCULATE_STATS_SCHEME, REVERT_SPF_DIRS, CLEAR_SPF_DIRS, TRANSFORM_SHADOW_IF_FULL,

sapfor/experts/Sapfor_2017/_src/Utils/SgUtils.cpp

@@ -997,17 +997,19 @@ static bool findSymbol(SgExpression *declLst, const string &toFind)
         SgExpression* ex = exs.top();
         exs.pop();
 
-        if (ex->variant() == ARRAY_REF || ex->variant() == VAR_REF)
+        if (ex->variant() == ARRAY_REF || ex->variant() == VAR_REF || ex->variant() == CONST_REF)
         {
             if (ex->symbol()->identifier() == toFind)
                 return true;
         }
+        else
+        {
+            if (ex->lhs())
+                exs.push(ex->lhs());
 
-        if (ex->lhs())
+            if (ex->rhs())
-            exs.push(ex->lhs());
+                exs.push(ex->rhs());
-        
+        }
-        if (ex->rhs())
-            exs.push(ex->rhs());
     }
     return false;
 }

sapfor/experts/Sapfor_2017/_src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2336"
+#define VERSION_SPF "2339"

sapfor/experts/Sapfor_2017/_src/VerificationCode/StructureChecker.cpp

@@ -590,7 +590,6 @@ bool checkAndMoveFormatOperators(SgFile* file, vector<Messages>& currMessages, b
         SgStatement* lastNode = st->lastNodeOfStmt();
 
         vector<SgStatement*> toMove;
-        SgStatement* firstExec = NULL;
         while (st != lastNode)
         {
             if (st == NULL)
@@ -602,11 +601,8 @@ bool checkAndMoveFormatOperators(SgFile* file, vector<Messages>& currMessages, b
             if (st->variant() == CONTAINS_STMT)
                 break;
 
-            if (isSgExecutableStatement(st) && !isDVM_stat(st) && !isSPF_stat(st))
+            if (isSgExecutableStatement(st) && !isDVM_stat(st) && !isSPF_stat(st))                
-            {
-                firstExec = st;
                 break;
-            }
 
             if (st->variant() == FORMAT_STAT)
             {
@@ -630,9 +626,8 @@ bool checkAndMoveFormatOperators(SgFile* file, vector<Messages>& currMessages, b
         {
             if (!withError)
             {
-                checkNull(firstExec, convertFileName(__FILE__).c_str(), __LINE__);
                 for (auto& format : toMove)
-                    firstExec->insertStmtBefore(*format, *firstExec->controlParent());
+                    lastNode->insertStmtBefore(*format, *lastNode->controlParent());
             }
             else
             {