sapfor/experts/Sapfor_2017/CMakeLists.txt

@@ -191,6 +191,8 @@ set(TR_GV _src/Transformations/fix_common_blocks.cpp
 		_src/Transformations/fix_common_blocks.h)
 set(TR_CONV _src/Transformations/convert_to_c.cpp
 		_src/Transformations/convert_to_c.h)
+set(TR_IMPLICIT_NONE _src/Transformations/set_implicit_none.cpp
+		_src/Transformations/set_implicit_none.h)
 
 set(TRANSFORMS 
 		${TR_DEAD_CODE}
@@ -207,7 +209,9 @@ set(TRANSFORMS
 		${TR_LOOP_UNROLL}
 		${TR_GV}
 		${TR_PRIV_DEL}
-        ${TR_CONV})
+        ${TR_CONV}
+		${TR_PRIV_DEL}
+		${TR_IMPLICIT_NONE})
 		
 set(CFG _src/CFGraph/IR.cpp
 		_src/CFGraph/IR.h
@@ -448,6 +452,7 @@ source_group (Transformations\\VectorAssignToLoop FILES ${TR_VECTOR})
 source_group (Transformations\\RenameSymbols FILES ${RENAME_SYMBOLS})
 source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
+source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})

sapfor/experts/Sapfor_2017/_src/Sapfor.cpp

@@ -83,6 +83,7 @@
 #include "Transformations/private_removing.h"
 #include "Transformations/fix_common_blocks.h"
 #include "Transformations/convert_to_c.h"
+#include "Transformations/set_implicit_none.h"
 #include "Transformations/dead_code.h"
 
 #include "RenameSymbols/rename_symbols.h"
@@ -1173,6 +1174,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
             getMaxMinBlockDistribution(file, min_max_block);
         else if (curr_regime == CONVERT_TO_C)
             covertToC(file);
+        else if (curr_regime == SET_IMPLICIT_NONE)
+            ImplicitCheck(file);
         else if (curr_regime == INSERT_NO_DISTR_FLAGS_FROM_GUI)
             addPrivatesToArraysFromGUI(file, declaredArrays, distrStateFromGUI);
         else if (curr_regime == REMOVE_DEAD_CODE)
@@ -2534,6 +2537,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case LOOPS_COMBINER:
     case FIX_COMMON_BLOCKS:
     case TEST_PASS:
+    case SET_IMPLICIT_NONE:
         runAnalysis(*project, curr_regime, false);
     case SUBST_EXPR_RD_AND_UNPARSE:
     case SUBST_EXPR_AND_UNPARSE:

sapfor/experts/Sapfor_2017/_src/Sapfor.h

@@ -176,6 +176,8 @@ enum passes {
     CONVERT_TO_C,
     INSERT_NO_DISTR_FLAGS_FROM_GUI,
 
+    SET_IMPLICIT_NONE,
+
     TEST_PASS,
     EMPTY_PASS
 };
@@ -354,6 +356,7 @@ static void setPassValues()
     passNames[REMOVE_COMMENTS] = "REMOVE_COMMENTS";
     passNames[GET_MIN_MAX_BLOCK_DIST] = "GET_MIN_MAX_BLOCK_DIST";
     passNames[CONVERT_TO_C] = "CONVERT_TO_C";
+    passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE";
     passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI";
 
     passNames[TEST_PASS] = "TEST_PASS";

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

@@ -0,0 +1,193 @@
+#include "../Utils/leak_detector.h"
+
+#include <string>
+#include <map>
+
+#include "Utils/SgUtils.h"
+#include "set_implicit_none.h"
+
+using std::vector;
+using std::map;
+using std::set;
+using std::string;
+
+static const char commonIntLetters[6] = { 'i', 'j', 'k', 'm', 'n', 'l' };
+
+static void InitTypes(map<char, SgType*>& types)
+{
+	for (char letter = 'a'; letter <= 'z'; letter++)
+		types[letter] = 0;
+}
+
+static void FillCommonTypes(map<char, SgType*>& types)
+{
+	for (char letter : commonIntLetters)
+		if (types[letter] == 0)
+			types[letter] = new SgType(T_INT);
+
+	for (auto letter : types)
+		if (letter.second == NULL)
+			types[letter.first] = new SgType(T_FLOAT);
+}
+
+static void FindAllVars(SgExpression* expr, set<SgSymbol*>& allVars)
+{
+	if (expr == NULL)
+		return;
+
+	if (expr->variant() == VAR_REF || expr->variant() == ARRAY_REF)
+		allVars.insert(expr->symbol());
+
+	FindAllVars(expr->lhs(), allVars);
+	FindAllVars(expr->rhs(), allVars);
+}
+
+static char getValue(SgExpression* ex)
+{
+	char charVal = 0;
+	if (ex && ex->variant() == CHAR_VAL)
+		charVal = isSgValueExp(ex)->charValue();
+	return charVal;
+}
+
+static void AddLettersToMap(SgExpression* expr, SgType* type, map<char, SgType*>& types)
+{
+	while (expr)
+	{
+		if (expr->variant() != EXPR_LIST)
+			printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+		SgExpression* val = expr->lhs();
+		if (val->variant() == DDOT)
+		{
+			char leftVal = getValue(val->lhs());
+			char rightVal = getValue(val->rhs());
+
+			if (leftVal == 0 || rightVal == 0)
+				printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+			for (char letter = leftVal; letter <= rightVal; letter++)
+				types[letter] = type;
+		}
+		else
+		{
+			char charVal = getValue(val);
+			if (charVal == 0)
+				printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+			types[charVal] = type;
+		}
+
+		expr = expr->rhs();
+	}
+}
+
+static map<char, SgType*> FunctionImplicitCheck(SgStatement* function, const map<SgStatement*, map<char, SgType*>>& typesByFunctions)
+{
+	set<SgSymbol*> allVars;
+	map<char, SgType*> types;
+	vector<SgSymbol*> varsWithoutDecl;
+	 
+	InitTypes(types);
+	FillCommonTypes(types);
+
+	auto cp = function->controlParent();
+	if (isSgProgHedrStmt(cp))
+		if (typesByFunctions.find(cp) != typesByFunctions.end())
+			for (auto& parentType : typesByFunctions.at(cp))
+				types[parentType.first] = parentType.second;
+
+	auto hasImplicitNone = false;
+	auto endOfFunc = function->lastNodeOfStmt();
+	for (auto st = function; st != endOfFunc; st = st->lexNext())
+	{
+		if (st->variant() == IMPL_DECL)
+		{
+			SgImplicitStmt* implicitStatement = isSgImplicitStmt(st);
+			if (implicitStatement != NULL)
+			{
+				const int numberOfTypes = implicitStatement->numberOfImplicitTypes();
+
+				if (numberOfTypes > 0)
+				{
+					for (int j = 0; j < numberOfTypes; ++j)
+					{
+						SgType* type = implicitStatement->implicitType(j);
+						SgExpression* lettersExpression = implicitStatement->implicitRangeList(j);
+
+						AddLettersToMap(lettersExpression, type, types);
+				 	}
+				}
+				else
+					hasImplicitNone = true;
+			}
+		}
+		else if (st->variant() == CONTAINS_STMT || isSgExecutableStatement(st) != NULL)
+			break;
+	}
+
+	for (auto st = function; st != endOfFunc && st->variant() != CONTAINS_STMT; st = st->lexNext())
+		for (int i = 0; i < 3; ++i)
+			FindAllVars(st->expr(i), allVars);
+
+	for (auto& var : allVars)
+	{
+		if (string(var->identifier()) == function->symbol()->identifier())
+			continue;
+
+		vector<SgStatement*> _;
+		SgStatement* declaredInStatement = declaratedInStmt(var, &_, false);
+		if (declaredInStatement == NULL)
+		{
+			 const char c = var->identifier()[0];
+
+			if (types.find(c) != types.end())
+				var->setType(types[c]);
+
+			varsWithoutDecl.push_back(var);
+		}
+	}
+
+	makeDeclaration(varsWithoutDecl, function, NULL);
+
+	if (!hasImplicitNone)
+	{
+		for (auto st = function->lexNext(); 
+			 st != endOfFunc && st->variant() != CONTAINS_STMT && isSgExecutableStatement(st) == NULL; 
+			 )
+		{
+			if (st->variant() == IMPL_DECL)
+			{
+				auto tmpStatement = st;
+				st = st->lexNext();
+				tmpStatement->deleteStmt();
+			}
+			else
+				st = st->lexNext();
+		}
+
+		auto implNone = new SgStatement(IMPL_DECL);
+		implNone->setlineNumber(function->lineNumber());
+		implNone->setFileName(function->fileName());
+
+		function->insertStmtAfter(*implNone, *function);
+	}
+
+	allVars.clear();
+	varsWithoutDecl.clear();
+
+	return types;
+}
+
+void ImplicitCheck(SgFile* file)
+{
+	map<SgStatement*, map<char, SgType*>> typesByFunctions;
+
+	for (int func = 0; func < file->numberOfFunctions(); ++func)
+	{
+		SgStatement* function = file->functions(func);
+		typesByFunctions[function] = FunctionImplicitCheck(function, typesByFunctions);
+	}
+
+	typesByFunctions.clear();
+}

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

@@ -0,0 +1,3 @@
+#pragma once
+
+void ImplicitCheck(SgFile* file);

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

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2290"
+#define VERSION_SPF "2291"