sapfor/experts/Sapfor_2017/_src/Sapfor.cpp

@@ -2541,7 +2541,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case LOOPS_SPLITTER:
     case LOOPS_COMBINER:
     case FIX_COMMON_BLOCKS:
-    //case SET_IMPLICIT_NONE:
     case TEST_PASS:
         runAnalysis(*project, curr_regime, false);
     case SUBST_EXPR_RD_AND_UNPARSE:

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

@@ -19,7 +19,6 @@ char AddLettersToMap(SgExpression* params, SgType* type);
 
 void ImplicitCheck(SgFile* file)
 {
-
 	for (int functionNumber = 0; functionNumber < file->numberOfFunctions(); functionNumber++)
 	{
 		InitTypes();
@@ -30,16 +29,14 @@ void ImplicitCheck(SgFile* file)
 
 		CleanTypes();
 	}
-
-	return;
 }
 
-void FunctionImplicitCheck(SgStatement* function)
+static void FunctionImplicitCheck(SgStatement* function)
 {
 	auto implicitNoneDeclaration = new SgStatement(IMPL_DECL);
 	auto hasImplicitNone = false;
 
-	for (SgStatement* statement = function; statement = statement->lexNext(); statement != NULL)
+	for (SgStatement* statement = function; statement != NULL; statement = statement->lexNext())
 	{
 		if (statement->variant() == IMPL_DECL)
 		{
@@ -59,24 +56,16 @@ void FunctionImplicitCheck(SgStatement* function)
 					}
 				}
 				else
-				{
 					hasImplicitNone = true;
 			}
 		}
-		}
 		else if (statement->variant() == CONTAINS_STMT || isSgExecutableStatement(statement) != NULL)
-		{
 			break;
 	}
-	}
 
 	for (SgStatement* statement = function; statement != function->lastExecutable(); statement = statement->lexNext())
-	{
 		for (int expressionNumber = 0; expressionNumber < 3; expressionNumber++)
-		{
 			FindAllVars(statement->expr(expressionNumber));
-		}
-	}
 
 	for (auto var : allVars)
 	{
@@ -87,9 +76,7 @@ void FunctionImplicitCheck(SgStatement* function)
 			char c = var->identifier()[0];
 
 			if (types.find(c) != types.end())
-			{
 				var->setType(types[c]);
-			}
 
 			varsWithoutDecl.push_back(var);
 		}
@@ -108,73 +95,55 @@ void FunctionImplicitCheck(SgStatement* function)
 				tmpStatement->deleteStmt();
 			}
 			else
-			{
 				statement = statement->lexNext();
 		}
+
+		function->insertStmtAfter(*implicitNoneDeclaration, *function);
 	}
 
-		function->insertStmtBefore(*implicitNoneDeclaration, *function);
+	printf("%s", function->unparse());
 }
 
-	return;
+static void InitTypes()
-}
-
-void InitTypes()
 {
 	for (char letter = 'a'; letter <= 'z'; letter++)
-	{
 		types[letter] = NULL;
 }
-}
 
-void FillCommonTypes()
+static void FillCommonTypes()
 {
 	for (char letter : commonIntLetters)
-	{
 		if (types[letter] == NULL)
-		{
 			types[letter] = new SgType(T_INT);
-		}
-	}
 
 	for (auto letter : types)
-	{
 		if (letter.second == NULL)
-		{
 			types[letter.first] = new SgType(T_FLOAT);
 }
-	}
-}
 
-void CleanTypes()
+static void CleanTypes()
 {
 	types.clear();
 	allVars.clear();
 	varsWithoutDecl.clear();
 }
 
-void FindAllVars(SgExpression* expr)
+static void FindAllVars(SgExpression* expr)
 {
 	if (expr == NULL)
-	{
 		return;
-	}
 
-	if (expr->symbol() != NULL)
+	if (expr->variant() == VAR_REF || expr->variant() == ARRAY_REF)
-	{
 		allVars.insert(expr->symbol());
-	}
 
 	FindAllVars(expr->lhs());
 	FindAllVars(expr->rhs());
 }
 
-char AddLettersToMap(SgExpression* expr, SgType* type)
+static char AddLettersToMap(SgExpression* expr, SgType* type)
 {
 	if (expr == NULL)
-	{
 		return NULL;
-	}
 
 	if (expr->variant() == CHAR_VAL)
 	{
@@ -186,25 +155,17 @@ char AddLettersToMap(SgExpression* expr, SgType* type)
 	char rightVal = AddLettersToMap(expr->rhs(), type);
 	
 	if (expr->variant() == DDOT)
-	{
 		if (leftVal != NULL && rightVal != NULL)
-		{
 			for (char letter = leftVal; letter <= rightVal; letter++)
-			{
 				types[letter] = type;
-			}
-		}
-	}
 
 	if (expr->variant() == EXPR_LIST)
 	{ 
-		if (leftVal != NULL) {
+		if (leftVal != NULL)
 			types[leftVal] = type;
-		}
+		if (rightVal != NULL)
-		if (rightVal != NULL) {
 			types[rightVal] = type;
 	}
-	}
 
 	return NULL;
 }