moved to transformations

.gitignore

@@ -78,3 +78,4 @@ Sapfor/Sapc++/x64/
 
 Sapfor/out/
 Sapfor/_bin/*
+_bin/*

CMakeLists.txt

@@ -27,13 +27,6 @@ set(libpred_sources projects/libpredictor/src/)
 set(libpred_include projects/libpredictor/include/)
 
 include_directories(src)
-include_directories(src/Utils)
-include_directories(src/SgUtils)
-include_directories(src/Distribution)
-include_directories(src/GraphCall)
-include_directories(src/GraphLoop)
-include_directories(src/Transformations/ExpressionSubstitution)
-
 #Sage lib includes
 include_directories(${fdvm_include})
 include_directories(${sage_include_1})
@@ -161,47 +154,42 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp
         src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
         src/ParallelizationRegions/resolve_par_reg_conflicts.h)
 
-set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp
-        src/Transformations/DeadCodeRemoving/dead_code.h)
-set(TR_CP src/Transformations/CheckPoints/checkpoints.cpp
-        src/Transformations/CheckPoints/checkpoints.h)
-set(TR_VECTOR src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp
-        src/Transformations/VectorAssignToLoop/array_assign_to_loop.h)
-set(TR_ENDDO_LOOP src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp
-        src/Transformations/LoopEndDoConverter/enddo_loop_converter.h)
-set(TR_LOOP_NEST src/Transformations/LoopNesting/loop_transform.cpp
-        src/Transformations/LoopNesting/loop_transform.h)
-set(TR_LOOP_COMB src/Transformations/LoopCombining/loops_combiner.cpp
-        src/Transformations/LoopCombining/loops_combiner.h)
-set(TR_LOOP_SPLIT src/Transformations/LoopSplitting/loops_splitter.cpp
-        src/Transformations/LoopSplitting/loops_splitter.h)
-set(TR_LOOP_UNROLL src/Transformations/LoopUnrolling/loops_unrolling.cpp
-        src/Transformations/LoopUnrolling/loops_unrolling.h)     
-set(TR_PRIV_BR src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp
-        src/Transformations/PrivateArrayResizing/private_arrays_resizing.h)
-set(TR_PRIV_DEL src/Transformations/PrivateArrayRemoving/private_removing.cpp
-        src/Transformations/PrivateArrayRemoving/private_removing.h)
-set(TR_SWAP_ARR_DIMS src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp
-        src/Transformations/ArrayDimsSwapping/swap_array_dims.h)
-set(TR_FUNC_DUP src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp
-        src/Transformations/FunctionDuplication/uniq_call_chain_dup.h)
-set(TR_FUNC_PURE src/Transformations/FunctionPurifying/function_purifying.cpp
-        src/Transformations/FunctionPurifying/function_purifying.h)  
-set(TR_GV src/Transformations/GlobalVariables/fix_common_blocks.cpp
-        src/Transformations/GlobalVariables/fix_common_blocks.h)
-set(TR_CONV src/Transformations/ConvertToC/convert_to_c.cpp
-        src/Transformations/ConvertToC/convert_to_c.h)
-set(TR_IMPLICIT_NONE src/Transformations/SetImplicitNone/set_implicit_none.cpp
-        src/Transformations/SetImplicitNone/set_implicit_none.h)
-set(TR_REPLACE_ARRAYS_IN_IO src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp
-        src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h)
-set(TR_EXPR_TRANSFORM src/Transformations/ExpressionSubstitution/control_flow_graph_part.cpp
-        src/Transformations/ExpressionSubstitution/expr_transform.cpp
-        src/Transformations/ExpressionSubstitution/expr_transform.h)        
-set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
-        src/Transformations/FunctionInlining/inliner.h)
-set(TR_RENAME_SYMBOLS  src/Transformations/RenameSymbols/rename_symbols.cpp
-                    src/Transformations/RenameSymbols/rename_symbols.h)
+set(TR_DEAD_CODE src/Transformations/dead_code.cpp
+        src/Transformations/dead_code.h)
+set(TR_CP src/Transformations/checkpoints.cpp
+        src/Transformations/checkpoints.h)
+set(TR_VECTOR src/Transformations/array_assign_to_loop.cpp
+        src/Transformations/array_assign_to_loop.h)
+set(TR_ENDDO_LOOP src/Transformations/enddo_loop_converter.cpp
+        src/Transformations/enddo_loop_converter.h)
+set(TR_LOOP_NEST src/Transformations/loop_transform.cpp
+        src/Transformations/loop_transform.h)
+set(TR_LOOP_COMB src/Transformations/loops_combiner.cpp
+        src/Transformations/loops_combiner.h)
+set(TR_LOOP_SPLIT src/Transformations/loops_splitter.cpp
+        src/Transformations/loops_splitter.h)
+set(TR_LOOP_UNROLL src/Transformations/loops_unrolling.cpp
+        src/Transformations/loops_unrolling.h)     
+set(TR_PRIV_BR src/Transformations/private_arrays_resizing.cpp
+        src/Transformations/private_arrays_resizing.h)
+set(TR_PRIV_DEL src/Transformations/private_removing.cpp
+        src/Transformations/private_removing.h)
+set(TR_SWAP_ARR_DIMS src/Transformations/swap_array_dims.cpp
+        src/Transformations/swap_array_dims.h)
+set(TR_FUNC_DUP src/Transformations/uniq_call_chain_dup.cpp
+        src/Transformations/uniq_call_chain_dup.h)
+set(TR_FUNC_PURE src/Transformations/function_purifying.cpp
+        src/Transformations/function_purifying.h)  
+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(TR_REPLACE_ARRAYS_IN_IO src/Transformations/replace_dist_arrays_in_io.cpp
+        src/Transformations/replace_dist_arrays_in_io.h)
+SET(TR_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp
+        src/Transformations/SwapOperators/swap_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -222,14 +210,10 @@ set(TRANSFORMS
         ${TR_PRIV_DEL}
         ${TR_IMPLICIT_NONE}
         ${TR_REPLACE_ARRAYS_IN_IO}
-        ${TR_EXPR_TRANSFORM}
-        ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS})
+        ${TR_SWAP_OPERATORS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
-        src/CFGraph/IR_domTree.cpp
-        src/CFGraph/IR_domTree.h
         src/CFGraph/CFGraph.cpp
         src/CFGraph/CFGraph.h
         src/CFGraph/RD_subst.cpp
@@ -238,14 +222,14 @@ set(CFG src/CFGraph/IR.cpp
         src/CFGraph/live_variable_analysis.h
         src/CFGraph/private_variables_analysis.cpp
         src/CFGraph/private_variables_analysis.h
-        src/CFGraph/IR_SSAForm.cpp
-        src/CFGraph/IR_SSAForm.h)
+        )
         
 set(DATA_FLOW
         src/CFGraph/DataFlow/data_flow.h
         src/CFGraph/DataFlow/data_flow_impl.h
         src/CFGraph/DataFlow/backward_data_flow.h
-        src/CFGraph/DataFlow/backward_data_flow_impl.h)
+        src/CFGraph/DataFlow/backward_data_flow_impl.h
+        )
 
 set(CREATE_INTER_T  src/CreateInterTree/CreateInterTree.cpp
         src/CreateInterTree/CreateInterTree.h)
@@ -308,6 +292,10 @@ set(DYNA src/DynamicAnalysis/createParallelRegions.cpp
         src/DynamicAnalysis/gCov_parser.cpp
         src/DynamicAnalysis/gCov_parser_func.h)
 
+set(EXPR_TRANSFORM src/ExpressionTransform/control_flow_graph_part.cpp
+        src/ExpressionTransform/expr_transform.cpp
+        src/ExpressionTransform/expr_transform.h)
+        
 set(GR_CALL src/GraphCall/graph_calls.cpp
         src/GraphCall/graph_calls.h
         src/GraphCall/graph_calls_base.cpp
@@ -318,12 +306,17 @@ set(GR_LOOP src/GraphLoop/graph_loops_base.cpp
         src/GraphLoop/graph_loops.h
         src/GraphLoop/graph_loops_func.h)
         
+set(INLINER src/Inliner/inliner.cpp
+        src/Inliner/inliner.h)
+        
 set(LOOP_ANALYZER  src/LoopAnalyzer/allocations_prepoc.cpp
         src/LoopAnalyzer/dep_analyzer.cpp        
         src/LoopAnalyzer/loop_analyzer.cpp
-        src/LoopAnalyzer/loop_analyzer.h
-        src/LoopAnalyzer/implicit_loops_analyzer.cpp
-        src/LoopAnalyzer/implicit_loops_analyzer.h)
+        src/LoopAnalyzer/loop_analyzer.h)
+
+set(RENAME_SYMBOLS  src/RenameSymbols/rename_symbols.cpp
+                    src/RenameSymbols/rename_symbols.h)
+
 
 set(MAIN src/Sapfor.cpp
         src/Sapfor.h
@@ -414,9 +407,12 @@ set(SOURCE_EXE
     ${DISTR}
     ${DVMH_REG}
     ${DYNA}
+    ${EXPR_TRANSFORM}
     ${GR_CALL}
     ${GR_LOOP}
+    ${INLINER}
     ${LOOP_ANALYZER}
+    ${RENAME_SYMBOLS}
     ${TRANSFORMS}
     ${PARALLEL_REG}
     ${PRIV}
@@ -440,7 +436,7 @@ source_group (CFGraph FILES ${CFG})
 source_group (CFGraph\\DataFlow FILES ${DATA_FLOW})
 
 source_group (Transformations\\DeadCodeRemoving FILES ${TR_DEAD_CODE})
-source_group (Transformations\\ExpressionSubstitution FILES ${TR_EXPR_TRANSFORM})
+source_group (Transformations\\ExpressionSubstitution FILES ${EXPR_TRANSFORM})
 source_group (Transformations\\CheckPoints FILES ${TR_CP})
 source_group (Transformations\\LoopEndDoConverter FILES ${TR_ENDDO_LOOP})
 source_group (Transformations\\LoopNesting FILES ${TR_LOOP_NEST})
@@ -448,17 +444,18 @@ source_group (Transformations\\LoopCombining FILES ${TR_LOOP_COMB})
 source_group (Transformations\\LoopSplitting FILES ${TR_LOOP_SPLIT})
 source_group (Transformations\\LoopUnrolling FILES ${TR_LOOP_UNROLL})
 source_group (Transformations\\FunctionDuplication FILES ${TR_FUNC_DUP})
-source_group (Transformations\\FunctionInlining FILES ${TR_INLINER})
+source_group (Transformations\\FunctionInlining FILES ${INLINER})
 source_group (Transformations\\FunctionPurifying FILES ${TR_FUNC_PURE})
 source_group (Transformations\\ArrayDimsSwapping FILES ${TR_SWAP_ARR_DIMS})
 source_group (Transformations\\PrivateArrayResizing FILES ${TR_PRIV_BR})
 source_group (Transformations\\PrivateArrayRemoving FILES ${TR_PRIV_DEL})
 source_group (Transformations\\VectorAssignToLoop FILES ${TR_VECTOR})
-source_group (Transformations\\RenameSymbols FILES ${TR_RENAME_SYMBOLS})
+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 (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
+source_group (Transformations\\SwapOperators FILES ${TR_SWAP_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})

src/CFGraph/CFGraph.cpp

@@ -1,5 +1,5 @@
 #define _LEAK_
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -8,9 +8,9 @@
 #include <chrono>
 #include <functional>
 
-#include "SgUtils.h"
-#include "CommonBlock.h"
-#include "graph_calls.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/CommonBlock.h"
+#include "../GraphCall/graph_calls.h"
 
 #include "dvm.h"
 #include "IR.h"
@@ -50,30 +50,12 @@ BBlock::BasicBlock(const BBlock& copyFrom)
     prev = copyFrom.prev;
 }
 
-void BBlock::addInstruction(IR_Block* item, bool pushFront)
+void BBlock::addInstruction(IR_Block* item)
 {
-    if (pushFront)
-        instructions.insert(instructions.begin(), item);
-    else
-        instructions.push_back(item);
+    instructions.push_back(item);
     item->setBasicBlock(this);
 }
 
-void BBlock::addInstructionBefore(IR_Block* item, Instruction* before)
-{
-    checkNull(before, convertFileName(__FILE__).c_str(), __LINE__);
-    checkNull(item, convertFileName(__FILE__).c_str(), __LINE__);
-
-    for (auto it = instructions.begin(); it != instructions.end(); ++it) {
-        if ((*it)->getInstruction() == before) {
-            instructions.insert(it, item);
-            item->setBasicBlock(this);
-            return;
-        }
-    }
-    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-}
-
 int BBlock::removePrev(BBlock* removed)
 {
     auto it = std::remove(prev.begin(), prev.end(), removed);
@@ -530,7 +512,7 @@ static int buildReachingDefs(const vector<BBlock*>& CFG, const FuncInfo* currF,
     return iter;
 }
 
-//Kosaraju-Sharir algorithm
+//Kosaraju<EFBFBD>Sharir algorithm
 static vector<int> getStronglyConnectedComps(vector<vector<int>>& g) {
     // 1. For each vertex u of the graph, mark u as unvisited. Let l be empty.
     auto size = g.size();
@@ -1167,22 +1149,9 @@ map<FuncInfo*, vector<BBlock*>> buildCFG(const map<string, CommonBlock*>& common
     if (settings.withRD)
         buildReachingDefs(result, settings);
 
-    if (settings.withDominators)
-    {
-        auto t = high_resolution_clock::now();
-        for (auto& [func, bblocks] : result)
-            SAPFOR::buildDominatorTree(bblocks);
-
-        auto msec = duration_cast<milliseconds>(high_resolution_clock::now() - t).count();
-        __spf_print(1, "    dominator build time is %.3f sec\n", msec / 1000.);
-    }
-
     if (SgFile::switchToFile(oldFile) == -1)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-    for (auto& [func, blocks] : result)
-        removedUnreachableBlocks(blocks);
-
     return result;
 }
 
@@ -1258,48 +1227,3 @@ map<FuncInfo*, vector<SAPFOR::BasicBlock*>>
 
     return buildCFG(commonBlocks, fileFuncInfoMap, settings);
 }
-
-
-void removedUnreachableBlocks(vector<SAPFOR::BasicBlock*>& blocks)
-{
-    set<SAPFOR::BasicBlock*> reachable;
-
-    for (auto& b : blocks)
-        if (b->getInstructions().front()->isHeader() ||
-            b->getInstructions().front()->getInstruction()->getOperation() == SAPFOR::CFG_OP::ENTRY)
-            reachable.insert(b);
-
-    set<SAPFOR::BasicBlock*> worklist = reachable;
-    while (worklist.size() != 0)
-    {
-        set<SAPFOR::BasicBlock*> to_insert;
-
-        for (auto& b : worklist)
-            for (auto& next : b->getNext())
-                if (reachable.insert(next).second)
-                    to_insert.insert(next);
-
-        worklist = to_insert;
-    }
-
-    auto remove_unreachable_it = remove_if(blocks.begin(), blocks.end(),
-        [&reachable](SAPFOR::BasicBlock* b)
-        {
-            if (reachable.find(b) == reachable.end())
-            {
-                for (auto& next : b->getNext())
-                    if (reachable.find(next) != reachable.end())
-                        next->removePrev(b);
-
-                delete b;
-                return true;
-            }
-
-            return false;
-        }
-    );
-
-    reachable.clear();
-
-    blocks.erase(remove_unreachable_it, blocks.end());
-}

src/CFGraph/CFGraph.h

@@ -6,11 +6,6 @@
 #include <vector>
 
 #include "IR.h"
-#include "../Utils/errors.h"
-#include "../Utils/utils.h"
-#include "../Utils/CommonBlock.h"
-#include "../GraphCall/graph_calls.h"
-#include "IR_domTree.h"
 
 namespace SAPFOR
 {
@@ -29,7 +24,7 @@ namespace SAPFOR
 
         std::vector<BasicBlock*> next;
         std::vector<BasicBlock*> prev;
-        BasicBlock* directDominator = NULL;
+        
         //reaching definition
         std::map<SAPFOR::Argument*, std::set<int>> RD_in, RD_out;
 
@@ -39,17 +34,14 @@ namespace SAPFOR
         bool addLive(const std::map<SAPFOR::Argument*, std::vector<SAPFOR::BasicBlock*>>& to_add, bool in);
         std::map<SAPFOR::Argument*, std::vector<SAPFOR::BasicBlock*>> getLive(bool in) const;
         bool removeLive(SAPFOR::Argument* to_remove, bool in);
-
     public:
         BasicBlock() { num = lastNumBlock++; }
         BasicBlock(IR_Block* item);
         BasicBlock(const BasicBlock& copyFrom);
 
-        void addInstructionBefore(IR_Block* item, Instruction* istruction);
-        void addInstruction(IR_Block* item, bool pushFront = false);
+        void addInstruction(IR_Block* item);
         void addPrev(BasicBlock* prev_) { prev.push_back(prev_); }
         void addNext(BasicBlock* next_) { next.push_back(next_); }
-        void setDom(BasicBlock* dom) { directDominator = dom; }
 
         int removePrev(BasicBlock* removed);
         int removeNext(BasicBlock* removed);
@@ -77,10 +69,6 @@ namespace SAPFOR
         const std::vector<IR_Block*>& getInstructions() const { return instructions; }
         const std::vector<BasicBlock*>& getNext() const { return next; }
         const std::vector<BasicBlock*>& getPrev() const { return prev; }
-        BasicBlock* getDom() const 
-        {
-            return directDominator; 
-        }
         
         /*
         *  FOR LIVE ANALYSIS
@@ -117,15 +105,13 @@ namespace SAPFOR
         bool withDVM = false;
         bool withCallsInBlocks = false; // separate each F_CALL to own BasicBlock
         bool withCallFrom = true;
-        bool withDominators = true;
 
         explicit CFG_Settings(int) { }
 
         explicit CFG_Settings(bool atLeastOneIterInLoop = false, bool withRD = true, bool withRegisters = false, 
-                              bool withDVM = false, bool withSPF = false, bool withCallsInBlocks = false, 
-                              bool withCallFrom = true, bool withDominators = true) :
+                              bool withDVM = false, bool withSPF = false, bool withCallsInBlocks = false, bool withCallFrom = true) :
             atLeastOneIterInLoop(atLeastOneIterInLoop), withRD(withRD), withRegisters(withRegisters), withDVM(withDVM), withSPF(withSPF), 
-            withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom), withDominators(withDominators)
+            withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom)
         { }
     };
 }
@@ -161,5 +147,3 @@ static inline void deleteCFG(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*
     }
     cfg.clear();
 }
-
-void removedUnreachableBlocks(std::vector<SAPFOR::BasicBlock*>& blocks);

src/CFGraph/DataFlow/backward_data_flow.h

@@ -5,7 +5,7 @@
 #include <set>
 #include <algorithm>
 
-#include "SgUtils.h"
+#include "../../Utils/SgUtils.h"
 #include "../CFGraph.h"
 #include "../IR.h"
 

src/CFGraph/DataFlow/backward_data_flow_impl.h

@@ -5,7 +5,7 @@
 #include <set>
 #include <algorithm>
 
-#include "SgUtils.h"
+#include "../../Utils/SgUtils.h"
 #include "../CFGraph.h"
 #include "../IR.h"
 #include "../RD_subst.h"

src/CFGraph/DataFlow/data_flow.h

@@ -2,7 +2,7 @@
 #include<vector>
 #include<set>
 
-#include "SgUtils.h"
+#include "../../Utils/SgUtils.h"
 #include "../CFGraph.h"
 #include "../IR.h"
 

src/CFGraph/DataFlow/data_flow_impl.h

@@ -4,7 +4,7 @@
 #include<vector>
 #include<set>
 
-#include "SgUtils.h"
+#include "../../Utils/SgUtils.h"
 #include "../CFGraph.h"
 #include "../IR.h"
 

src/CFGraph/IR.cpp

@@ -1,14 +1,14 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <vector>
 #include <set>
 
-#include "SgUtils.h"
-#include "CommonBlock.h"
-#include "graph_calls.h"
-#include "expr_transform.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/CommonBlock.h"
+#include "../GraphCall/graph_calls.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 #include "dvm.h"
 #include "IR.h"

src/CFGraph/IR.h

@@ -6,7 +6,7 @@
 #include <algorithm>
 
 #include "CFGraph.h"
-#include "CommonBlock.h"
+#include "../Utils/CommonBlock.h"
 
 namespace SAPFOR
 {
@@ -42,7 +42,6 @@ namespace SAPFOR
         Argument() : number(lastNumArg++), type(CFG_ARG_TYPE::NONE), value(""), mType(CFG_MEM_TYPE::NONE_) { }
         Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType) : number(lastNumArg++), type(type), mType(mType), value("") { }
         Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType, const std::string& value) : number(lastNumArg++), type(type), mType(mType), value(value) { }
-        Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType, const std::string& value, int num) : number(num), type(type), mType(mType), value(value) { }
         Argument(CFG_ARG_TYPE type, const std::string& value) : number(lastNumArg++), type(type), mType(CFG_MEM_TYPE::NONE_), value(value) 
         {
             if (type != CFG_ARG_TYPE::INSTR && type == CFG_ARG_TYPE::LAB &&
@@ -51,9 +50,6 @@ namespace SAPFOR
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
             }
         }
-        Argument(const Argument& other)
-            : number(other.number), type(other.type), mType(other.mType), value(other.value)
-        { }
 
         void setType(CFG_ARG_TYPE newType) { type = newType; }
         CFG_ARG_TYPE getType() const { return type; }

src/CFGraph/IR_SSAForm.cpp

@@ -1,386 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <vector>
-#include <set>
-
-#include "../Utils/SgUtils.h"
-#include "../Utils/CommonBlock.h"
-#include "../GraphCall/graph_calls.h"
-
-#include "dvm.h"
-#include "IR.h"
-#include "CFGraph.h"
-
-using namespace std;
-using namespace SAPFOR;
-
-static const SAPFOR::Argument CONST_UNDEFINED_ARG(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, "-1");
-
-template <typename T> static bool compareVectors(const vector<T>* vec1, const vector<T>* vec2)
-{
-    if (vec1 == vec2)
-        return true;
-    
-    if (!vec1 || !vec2)
-        return false;
-    
-    vector<T> sortedVec1 = *vec1;
-    vector<T> sortedVec2 = *vec2;
-
-    sort(sortedVec1.begin(), sortedVec1.end());
-    sort(sortedVec2.begin(), sortedVec2.end());
-
-    return sortedVec1 == sortedVec2;
-}
-
-template <typename T> static vector<T>* getCommonElements(const vector<vector<T>>* vectors)
-{
-    if (!vectors || vectors->empty())
-        return new vector<T>();
-    
-    vector<T>* commonElements = new vector<T>((*vectors)[0]);
-
-    for (size_t i = 1; i < vectors->size(); ++i) 
-    {
-        vector<T> tempCommon;
-
-        vector<T> sortedVec = (*vectors)[i];
-        sort(commonElements->begin(), commonElements->end());
-        sort(sortedVec.begin(), sortedVec.end());
-
-        set_intersection(
-            commonElements->begin(), commonElements->end(),
-            sortedVec.begin(), sortedVec.end(),
-            back_inserter(tempCommon)
-        );
-
-        *commonElements = tempCommon;
-
-        if (commonElements->empty())
-            break;
-    }
-
-    return commonElements;
-}
-
-
-static map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>> findDominators(const vector<SAPFOR::BasicBlock*>& blocks) 
-{
-    map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>> result;
-
-    bool changed = true;
-    while (changed)
-    {
-        changed = false;
-
-        for (auto& currentBlock : blocks) 
-        {
-            auto pred = currentBlock->getPrev();
-            auto prevDominators = new vector<vector<SAPFOR::BasicBlock*>>();
-
-            for (auto predBlock : pred)
-                prevDominators->push_back(result.find(predBlock) != result.end() ? result[predBlock] : blocks);
-
-            auto currentBlockResult = getCommonElements(prevDominators);
-            currentBlockResult->push_back(currentBlock);
-
-            if (result.find(currentBlock) == result.end() || !compareVectors(currentBlockResult, &result[currentBlock])) 
-            {
-                result[currentBlock] = *currentBlockResult;
-                changed = true;
-            }
-        }
-    }
-
-    return result;
-}
-
-static map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>> findDominatorBorders(const vector<SAPFOR::BasicBlock*>& blocks)
-{
-    map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>> result;
-
-    for (auto& block : blocks)
-        result[block] = *(new vector<SAPFOR::BasicBlock*>());
-
-    for (auto& block : blocks) 
-    {
-        if (block->getPrev().size() > 1) 
-        {
-            for (auto prev : block->getPrev()) 
-            {
-                auto tmpBlock = prev;
-
-                while (tmpBlock != block->getDom())
-                {
-                    result[tmpBlock].push_back(block);
-                    tmpBlock = tmpBlock->getDom();
-                }
-            }
-        }
-    }
-
-    return result;
-}
-
-static pair<set<SAPFOR::Argument*>, map<SAPFOR::Argument*, set<SAPFOR::BasicBlock*>>> getGlobalsAndVarBlocks(const vector<SAPFOR::BasicBlock*>& blocks)
-{
-    set<SAPFOR::Argument*> globals;
-    map<SAPFOR::Argument*, set<SAPFOR::BasicBlock*>> varBlocks;
-
-    for (auto& block : blocks) 
-    {
-        set<SAPFOR::Argument*> def;
-        const auto& instructions = block->getInstructions();
-
-        for (const auto& irBlock : instructions) 
-        {
-            if (irBlock) 
-            {
-                Instruction* instr = irBlock->getInstruction();
-
-                if (instr) 
-                {
-                    auto arg1 = instr->getArg1();
-                    auto arg2 = instr->getArg2();
-                    auto res = instr->getResult();
-
-                    if (arg1 && arg1->getType() == CFG_ARG_TYPE::VAR && find(def.begin(), def.end(), arg1) == def.end())
-                        globals.insert(arg1);
-
-                    if (arg2 && arg2->getType() == CFG_ARG_TYPE::VAR && find(def.begin(), def.end(), arg2) == def.end())
-                        globals.insert(arg2);
-
-                    if (res && res->getType() == CFG_ARG_TYPE::VAR) 
-                    {
-                        def.insert(res);
-                        varBlocks[res].insert(block);
-                    }
-                }
-            }
-        }
-    }
-
-    return make_pair(globals, varBlocks);
-}
-
-static void getBlocksWithFiFunctions(const vector<SAPFOR::BasicBlock*> blocks, set<SAPFOR::Argument*>& globals, 
-                                     map<SAPFOR::Argument*, set<SAPFOR::BasicBlock*>>& varBlocks, 
-                                     map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>>& dominatorBorders) 
-{
-    vector<SAPFOR::BasicBlock*> blocksWithFiFunctions;
-    auto fiFunc = new SAPFOR::Argument(CFG_ARG_TYPE::FUNC, CFG_MEM_TYPE::NONE_, "FI_FUNCTION");
-    auto paramCount = new SAPFOR::Argument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::LOCAL_, "0");
-
-    for (auto& var : globals)
-    {
-        auto worklist = varBlocks[var];
-        set<SAPFOR::BasicBlock*> hasFiFunction;
-
-        while (!worklist.empty()) 
-        {
-            auto block = *worklist.begin();
-            worklist.erase(block);
-
-            for (auto& dfBlock : dominatorBorders[block]) 
-            {
-                if (hasFiFunction.find(dfBlock) == hasFiFunction.end()) 
-                {
-                    hasFiFunction.insert(dfBlock);
-                    Instruction* phiInstruction = new Instruction(CFG_OP::F_CALL, new SAPFOR::Argument(*fiFunc), new SAPFOR::Argument(*paramCount), var, dfBlock->getInstructions()[0]->getInstruction()->getOperator());
-
-                    IR_Block* phiBlock = new IR_Block(phiInstruction);
-                    dfBlock->addInstruction(phiBlock, true);
-                }
-            }
-        }
-    }
-}
-
-static void restoreConnections(const vector<SAPFOR::BasicBlock*>& originalBlocks, vector<SAPFOR::BasicBlock*>& copiedBlocks) 
-{
-    map<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*> blockMapping;
-    for (size_t i = 0; i < originalBlocks.size(); ++i)
-        blockMapping[originalBlocks[i]] = copiedBlocks[i];
-
-    for (size_t i = 0; i < originalBlocks.size(); ++i) 
-    {
-        SAPFOR::BasicBlock* originalBlock = originalBlocks[i];
-        SAPFOR::BasicBlock* copiedBlock = copiedBlocks[i];
-
-        auto prevCopy = copiedBlock->getPrev();
-        for (auto j : prevCopy)
-            copiedBlock->removePrev(j);
-        
-        auto nextCopy = copiedBlock->getNext();
-        for (auto j : nextCopy)
-            copiedBlock->removeNext(j);
-        
-        for (auto* succ : originalBlock->getNext())
-            copiedBlock->addNext(blockMapping[succ]);
-        
-        for (auto* prev : originalBlock->getPrev())
-            copiedBlock->addPrev(blockMapping[prev]);
-    }
-}
-
-
-static SAPFOR::Argument* newName(SAPFOR::Argument* var, map<string, int>& counter, map<string, stack<SAPFOR::Argument*>>& stack, int number) {
-    counter[var->getValue()]++;
-
-    SAPFOR::Argument* newName = new SAPFOR::Argument(var->getType(), var->getMemType(), var->getValue(), number);
-    stack[var->getValue()].push(newName);
-    return newName;
-}
-
-static void renameFiFunctionResultVar(SAPFOR::BasicBlock* block, map<string, int>& counter, map<string, stack<SAPFOR::Argument*>>& stack) {
-    for (auto& irBlock : block->getInstructions()) 
-    {
-        auto instruction = irBlock->getInstruction();
-        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != NULL &&
-            instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != NULL)
-        {
-            instruction->setResult(newName(instruction->getResult(), counter, stack, instruction->getNumber()));
-        }
-    }
-}
-
-static void renameInstructionVars(SAPFOR::BasicBlock* block, map<string, int>& counter, map<string, stack<SAPFOR::Argument*>>& stack) 
-{
-    for (auto& irBlock : block->getInstructions()) 
-    {
-        auto instruction = irBlock->getInstruction();
-
-        if (instruction->getArg1() != NULL && instruction->getArg1()->getType() == CFG_ARG_TYPE::VAR)
-            instruction->setArg1(stack[instruction->getArg1()->getValue()].top());
-
-        if (instruction->getArg2() != NULL && instruction->getArg2()->getType() == CFG_ARG_TYPE::VAR)
-            instruction->setArg2(stack[instruction->getArg2()->getValue()].top());
-
-        if (instruction->getResult() != NULL && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR)
-            instruction->setResult(newName(instruction->getResult(), counter, stack, instruction->getNumber()));
-    }
-}
-
-static void renameFiFunctionArgsVar(SAPFOR::BasicBlock* block, map<string, stack<SAPFOR::Argument*>>& stack) 
-{
-    auto size = block->getInstructions().size();
-    auto& instructions = block->getInstructions();
-
-    for (size_t i = 0; i < size; ++i) 
-    {
-        auto irBlock = instructions[i];
-        auto instruction = irBlock->getInstruction();
-        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != NULL && 
-            instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != NULL && 
-            instruction->getArg2() != NULL) 
-        {
-            Instruction* paramInstruction;
-            
-            if (stack[instruction->getResult()->getValue()].size() > 0) 
-            {
-                SAPFOR::Argument* tmp = new SAPFOR::Argument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, to_string(stack[instruction->getResult()->getValue()].top()->getNumber()));
-                paramInstruction = new Instruction(CFG_OP::PARAM, tmp);
-            }
-            else 
-            {
-                SAPFOR::Argument* tmp = new SAPFOR::Argument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, "-1");
-                paramInstruction = new Instruction(CFG_OP::PARAM, tmp);
-            }
-
-            paramInstruction->setOperator(block->getInstructions()[0]->getInstruction()->getOperator());
-            block->addInstructionBefore(new IR_Block(paramInstruction), instruction);
-
-            instruction->getArg2()->setValue(to_string(stoi(instruction->getArg2()->getValue()) + 1));
-            i++;
-        }
-    }
-}
-
-static vector<SAPFOR::BasicBlock*> findBlocksWithValue(vector<SAPFOR::BasicBlock*>& blocks, SAPFOR::BasicBlock* x) 
-{
-    vector<SAPFOR::BasicBlock*> result;
-
-    for (auto& block : blocks)
-        if (block->getDom() == x)
-            result.push_back(block);
-
-    return result;
-}
-
-static void renameIR(SAPFOR::BasicBlock* block, vector<SAPFOR::BasicBlock*>& blocks, map<string, int>& counter, map<string, stack<SAPFOR::Argument*>>& stack)
-{
-    renameFiFunctionResultVar(block, counter, stack);
-    renameInstructionVars(block, counter, stack);
-
-    for (auto& successor : block->getNext())
-        renameFiFunctionArgsVar(successor, stack);
-    
-    for (auto& child : findBlocksWithValue(blocks, block))
-        renameIR(child, blocks, counter, stack);
-
-    for (auto& irBlock : block->getInstructions())
-    {
-        auto instruction = irBlock->getInstruction();
-        if (instruction->getResult() != NULL && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR) 
-        {
-            string varName = instruction->getResult()->getValue();
-            stack[varName].pop();
-        }
-    }
-
-    for (auto& irBlock : block->getInstructions()) 
-    {
-        auto instruction = irBlock->getInstruction();
-        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != NULL && 
-            instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != NULL) 
-        {
-            string varName = instruction->getResult()->getValue();
-            stack[varName].pop();
-        }
-    }
-}
-
-void buildFuncIRSSAForm(FuncInfo* funcInfo, const std::vector<SAPFOR::BasicBlock*>& funcIRConst, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& result)
-{
-    vector<SAPFOR::BasicBlock*> funcIR;
-
-    for (auto& i : funcIRConst)
-        funcIR.push_back(new SAPFOR::BasicBlock(*i));
-
-    restoreConnections(funcIRConst, funcIR);
-
-    SAPFOR::buildDominatorTree(funcIR);
-
-    auto dominatorBorders = findDominatorBorders(funcIR);
-
-    auto globalsAndVarBlocks = getGlobalsAndVarBlocks(funcIR);
-    auto globals = globalsAndVarBlocks.first;
-    auto varBlocks = globalsAndVarBlocks.second;
-
-    getBlocksWithFiFunctions(funcIR, globals, varBlocks, dominatorBorders);
-
-    map<string, int> count;
-    map<string, stack<SAPFOR::Argument*>> varStack;
-
-    for (auto& var : globals)
-    {
-        count[var->getValue()] = 0;
-
-        stack<SAPFOR::Argument*> tmp;
-        tmp.push(new SAPFOR::Argument(CONST_UNDEFINED_ARG));
-        varStack[var->getValue()] = tmp;
-    }
-
-    renameIR(funcIR[0], funcIR, count, varStack);
-
-    result[funcInfo] = funcIR;
-}
-
-FuncInfo* getIRByFilename(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR, const char* filename)
-{
-    for (auto ir : fullIR)
-        if (ir.first->fileName == filename)
-            return ir.first;
-
-    return nullptr;
-}

src/CFGraph/IR_SSAForm.h

@@ -1,8 +0,0 @@
-#pragma once
-
-#include "CFGraph.h"
-#include "IR.h"
-
-void buildFuncIRSSAForm(FuncInfo* funcInfo, const std::vector<SAPFOR::BasicBlock*>& fullIR, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& result);
-
-FuncInfo* getIRByFilename(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR, const char* filename);

src/CFGraph/IR_domTree.cpp

@@ -1,102 +0,0 @@
-#include "dvm.h"
-#include "IR_domTree.h"
-
-namespace SAPFOR {
-    void DominatorFinder::DFS(BasicBlock* v, int parent_num) {
-        dfs_num[v] = n;
-        vertex[n] = n;
-        semi[n] = n;
-        label[n] = n;
-        ancestor[n] = -1;
-        parent[n] = parent_num;
-        vertices[n++] = v;
-
-        for (const auto& w : v->getNext()) {
-            if (dfs_num[w] == -1)
-                DFS(w, dfs_num[v]);
-        }
-    }
-
-    void DominatorFinder::Compress(int v) {
-        if (ancestor[ancestor[v]] != -1) {
-            Compress(ancestor[v]);
-
-            if (semi[label[ancestor[v]]] < semi[label[v]])
-                label[v] = label[ancestor[v]];
-            ancestor[v] = ancestor[ancestor[v]];
-        }
-    }
-
-    int DominatorFinder::Eval(int v) {
-        if (ancestor[v] == -1) 
-            return v;
-
-        Compress(v);
-        return label[v];
-    }
-
-    void DominatorFinder::Link(int v, int w) {
-        ancestor[w] = v;
-    }
-
-    DominatorFinder::DominatorFinder(std::vector<BasicBlock*>& blocks) {
-        if (blocks.empty()) 
-            return;
-
-        entry = blocks[0];
-        n = 0;
-
-        for (auto block : blocks) 
-            dfs_num[block] = -1;
-
-        int max_size = blocks.size();
-        vertices.resize(max_size);
-        parent.assign(max_size, -1);
-        semi.assign(max_size, -1);
-        vertex.assign(max_size, -1);
-        ancestor.assign(max_size, -1);
-        label.assign(max_size, -1);
-        bucket.resize(max_size);
-
-        DFS(entry, -1);
-
-        for (int i = n - 1; i > 0; --i) {
-            int w = vertex[i];
-
-            for (BasicBlock* v : vertices[w]->getPrev()) {
-                if (dfs_num[v] == -1)
-                    continue;
-                int u = Eval(dfs_num[v]);
-
-                if (semi[u] < semi[w])
-                    semi[w] = semi[u];
-            }
-
-            bucket[vertex[semi[w]]].push_back(w);
-            Link(parent[w], w);
-
-            for (int v : bucket[parent[w]])
-            {
-                int u = Eval(v);
-                if (semi[u] < semi[v])
-                    vertices[v]->setDom(vertices[u]);
-                else
-                    vertices[v]->setDom(vertices[parent[w]]);
-            }
-            bucket[parent[w]].clear();
-        }
-
-        for (int i = 1; i < n; ++i) {
-            int w = vertex[i];
-
-            if (vertices[w]->getDom() != vertices[vertex[semi[w]]])
-                vertices[w]->setDom(vertices[w]->getDom()->getDom());
-        }
-
-        entry->setDom(nullptr);
-    }
-
-    void buildDominatorTree(std::vector<BasicBlock*>& blocks) {
-        DominatorFinder finder(blocks);
-    }
-}

src/CFGraph/IR_domTree.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <map>
-#include <unordered_map>
-
-#include "CFGraph.h"
-
-// Lengauer, Thomas. A fast algorithm for finding dominators in a flowgraph / Thomas Lengauer, Robert Endre Tarjan 
-// ACM Transactions on Programming Languages and Systems (TOPLAS). <20> 1979. <20> Vol. 1, no. 1. <20> Pp. 121<32>141.
-
-namespace SAPFOR {
-
-class BasicBlock;
-
-class DominatorFinder {
-private:
-    BasicBlock* entry;
-    std::vector<BasicBlock*> vertices;
-    std::unordered_map<BasicBlock*, int> dfs_num;
-    std::vector<int> parent, semi, vertex, ancestor, label;
-    std::vector<std::vector<int>> bucket;
-    int n;
-
-    void DFS(BasicBlock* v, int parent_num);
-    void Compress(int v);
-    int  Eval(int v);
-    void Link(int v, int w);
-
-public:
-    DominatorFinder(std::vector<BasicBlock*>& blocks);
-};
-
-void buildDominatorTree(std::vector<BasicBlock*>& blocks);
-}

src/CFGraph/RD_subst.cpp

@@ -8,10 +8,10 @@
 #include <unordered_map>
 #include <unordered_set>
 
-#include "SgUtils.h"
-#include "CommonBlock.h"
-#include "graph_calls.h"
-#include "expr_transform.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/CommonBlock.h"
+#include "../GraphCall/graph_calls.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 #define PRINT_PROF_INFO 0
 #define DEBUG_CHECKS 0

src/CFGraph/RD_subst.h

@@ -2,9 +2,9 @@
 
 #include<unordered_map>
 
-#include "SgUtils.h"
-#include "CommonBlock.h"
-#include "graph_calls.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/CommonBlock.h"
+#include "../GraphCall/graph_calls.h"
 
 #include "CFGraph.h"
 #include "IR.h"

src/CFGraph/live_variable_analysis.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "CFGraph.h"
 
 namespace LIVE_VARIABLES

src/CFGraph/private_variables_analysis.cpp

@@ -1,6 +1,6 @@
-#include "errors.h"
+#include "../Utils/errors.h"
 #include "private_variables_analysis.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../SageAnalysisTool/depGraph.h"
 #include "../DirectiveProcessing/directive_parser.h"
@@ -250,7 +250,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
                                             const map<string, SgSymbol*>& commonArgs, FuncInfo* func,
                                             map<string, vector<Messages>>& messages)
 {
-    if (!loop->isFor())
+    if (!loop->isFor)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__); //should be called only with FOR loops
 
     SgStatement* loop_operator = loop->loop->GetOriginal();
@@ -450,7 +450,7 @@ static void recAnalyzeLoop(LoopGraph* loop, const set<SAPFOR::BasicBlock*>& bloc
                            const map<string, SgSymbol*>& commonArgs,
                            FuncInfo* func, map<string, vector<Messages>>& messages)
 {
-    const auto& loop_body = loop->isFor() ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
+    const auto& loop_body = loop->isFor ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
     
     for (const auto& inner_loop : loop->children)
         recAnalyzeLoop(inner_loop, loop_body, commonVars, commonArgs, func, messages);

src/CFGraph/private_variables_analysis.h

@@ -1,5 +1,5 @@
-#include "SgUtils.h"
-#include "graph_loops.h"
+#include "../Utils/SgUtils.h"
+#include "../GraphLoop/graph_loops.h"
 #include "CFGraph.h"
 
 #include <string>

src/CreateInterTree/CreateInterTree.cpp

@@ -1,7 +1,7 @@
 #include "CreateInterTree.h"
-#include "SgUtils.h"
-#include "utils.h"
-#include "graph_calls_func.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/utils.h"
+#include "../GraphCall/graph_calls_func.h"
 
 using std::string;
 using std::wstring;

src/CreateInterTree/CreateInterTree.h

@@ -8,7 +8,7 @@
 
 #include "dvm.h"
 
-#include "graph_loops_func.h"
+#include "../GraphLoop/graph_loops_func.h"
 
 struct SpfInterval
 {

src/DirectiveProcessing/directive_analyzer.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -16,9 +16,9 @@
 #include <assert.h>
 
 #include "../Distribution/DvmhDirective.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "directive_analyzer.h"
-#include "utils.h"
+#include "../Utils/utils.h"
 
 using std::vector;
 using std::map;

src/DirectiveProcessing/directive_analyzer.h

@@ -1,6 +1,6 @@
 #pragma once
 
 #include <vector>
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 
 void UniteNestedDirectives(std::vector<LoopGraph*> &loopGraph);

src/DirectiveProcessing/directive_creator.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -15,18 +15,18 @@
 #include "../Distribution/Distribution.h"
 #include "../Distribution/DvmhDirective_func.h"
 
-#include "errors.h"
+#include "../Utils/errors.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "directive_parser.h"
 #include "directive_creator.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "../Sapfor.h"
-#include "graph_loops_func.h"
-#include "../Transformations/LoopNesting/loop_transform.h"
-#include "expr_transform.h"
-#include "graph_calls_func.h"
+#include "../GraphLoop/graph_loops_func.h"
+#include "../Transformations/loop_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
+#include "../GraphCall/graph_calls_func.h"
 
-#include "AstWrapper.h"
+#include "../Utils/AstWrapper.h"
 
 #define PRINT_DIR_RESULT 0
 

src/DirectiveProcessing/directive_creator.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include "../Distribution/Distribution.h"
-#include "errors.h"
-#include "graph_loops.h"
-#include "types.h"
+#include "../Utils/errors.h"
+#include "../GraphLoop/graph_loops.h"
+#include "../Utils/types.h"
 
 void createParallelDirectives(const std::map<LoopGraph*, std::map<DIST::Array*, ArrayInfo*>> &loopInfo,
                               const std::vector<ParallelRegion*>& regions, 

src/DirectiveProcessing/directive_creator_base.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -10,9 +10,9 @@
 
 #include "../ParallelizationRegions/ParRegions.h"
 #include "../Distribution/Arrays.h"
-#include "../Transformations/LoopNesting/loop_transform.h"
+#include "../Transformations/loop_transform.h"
 
-#include "errors.h"
+#include "../Utils/errors.h"
 #include "directive_parser.h"
 #include "directive_creator.h"
 
@@ -75,7 +75,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
         }
     }
 
-    directive->parallel.push_back(currentLoop->loopSymbol());
+    directive->parallel.push_back(currentLoop->loopSymbol);
     directive->arrayRef = mainArray.arrayRef;
 
     DIST::Array *tmp = mainArray.arrayRef;
@@ -84,7 +84,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
         for (int i = 0; i < tmp->GetDimSize(); ++i)
         {
             if (i == pos)
-                directive->on.push_back(make_pair(currentLoop->loopSymbol(), mainAccess));
+                directive->on.push_back(make_pair(currentLoop->loopSymbol, mainAccess));
             else
                 directive->on.push_back(make_pair("*", make_pair(0, 0)));
         }
@@ -808,7 +808,7 @@ void createParallelDirectives(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*
                             for (int i = 0; i < mainArrayOfLoop->GetDimSize(); ++i)
                             {
                                 if (i == dimPos)
-                                    parDir->on2.push_back(make_pair(currLoop->loopSymbol(), mainAccess));
+                                    parDir->on2.push_back(make_pair(currLoop->loopSymbol, mainAccess));
                                 else
                                     parDir->on2.push_back(make_pair("*", make_pair(0, 0)));
                             }
@@ -1100,7 +1100,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
     LoopGraph* tmpL = loop;
     for (int z = 0; z < nested; ++z)
     {
-        deprecateToMatch.insert(tmpL->loopSymbol());
+        deprecateToMatch.insert(tmpL->loopSymbol);
         if (tmpL->children.size())
             tmpL = tmpL->children[0];
         else if (z != nested - 1)
@@ -1113,7 +1113,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
     tmpL = loop->parent;
     while (tmpL)
     {
-        if (tmpL->isWhile()) // TODO: need to add all inductive variables!
+        if (!tmpL->isFor) // TODO: need to add all inductive variables!
         {
             SgWhileStmt* dow = isSgWhileStmt(tmpL->loop->GetOriginal());
             if (dow->conditional())
@@ -1124,7 +1124,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
             }
         }
         else
-            deprecateToMatch.insert(tmpL->loopSymbol());
+            deprecateToMatch.insert(tmpL->loopSymbol);
         tmpL = tmpL->parent;
     }
 

src/DirectiveProcessing/directive_omp_parser.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -9,7 +9,7 @@
 #include "directive_omp_parser.h"
 #include "directive_parser.h"
 
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 
 using std::vector;
 using std::map;

src/DirectiveProcessing/directive_omp_parser.h

@@ -4,7 +4,7 @@
 #include <map>
 #include <vector>
 
-#include "errors.h"
+#include "../Utils/errors.h"
 
 #define SPF_USER_DIR 777
 #define SPF_USER_DIR_COPY 999

src/DirectiveProcessing/directive_parser.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstring>
@@ -12,10 +12,10 @@
 #include <assert.h>
 
 #include "directive_parser.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "AstWrapper.h"
-#include "errors.h"
+#include "../Utils/AstWrapper.h"
+#include "../Utils/errors.h"
 
 using std::string;
 using std::vector;

src/DirectiveProcessing/directive_parser.h

@@ -4,8 +4,8 @@
 #include <set>
 #include <map>
 
-#include "AstWrapper.h"
-#include "graph_loops.h"
+#include "../Utils/AstWrapper.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../Distribution/DvmhDirective.h"
 
 struct DvmDirective

src/DirectiveProcessing/insert_directive.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -16,13 +16,13 @@
 #include "../Distribution/Arrays.h"
 #include "../Distribution/Distribution.h"
 #include "../Distribution/DvmhDirective_func.h"
-#include "graph_loops_func.h"
-#include "graph_calls_func.h"
+#include "../GraphLoop/graph_loops_func.h"
+#include "../GraphCall/graph_calls_func.h"
 
-#include "errors.h"
+#include "../Utils/errors.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "directive_parser.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "../Sapfor.h"
 #include "directive_creator.h"
 #include "insert_directive.h"

src/DirectiveProcessing/remote_access.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -18,13 +18,13 @@
 
 #include "dvm.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "types.h"
-#include "errors.h"
-#include "SgUtils.h"
+#include "../Utils/types.h"
+#include "../Utils/errors.h"
+#include "../Utils/SgUtils.h"
 #include "../Distribution/Arrays.h"
-#include "graph_calls.h"
-#include "graph_calls_func.h"
-#include "graph_loops_func.h"
+#include "../GraphCall/graph_calls.h"
+#include "../GraphCall/graph_calls_func.h"
+#include "../GraphLoop/graph_loops_func.h"
 #include "remote_access.h"
 
 using std::vector;

src/DirectiveProcessing/remote_access_base.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -17,8 +17,8 @@
 #include <assert.h>
 
 #include "../Distribution/Arrays.h"
-#include "graph_calls.h"
-#include "graph_loops.h"
+#include "../GraphCall/graph_calls.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../ParallelizationRegions/ParRegions.h"
 #include "remote_access.h"
 

src/DirectiveProcessing/shadow.cpp

@@ -1,19 +1,19 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <set>
 #include <map>
 #include <string>
 #include <vector>
 
-#include "errors.h"
-#include "utils.h"
-#include "graph_loops_func.h"
-#include "graph_calls.h"
-#include "graph_calls_func.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+#include "../GraphLoop/graph_loops_func.h"
+#include "../GraphCall/graph_calls.h"
+#include "../GraphCall/graph_calls_func.h"
 #include "directive_parser.h"
 #include "../Distribution/DvmhDirective_func.h"
-#include "SgUtils.h"
-#include "expr_transform.h"
+#include "../Utils/SgUtils.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 #include "../CFGraph/CFGraph.h"
 

src/DirectiveProcessing/spf_directive_preproc.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -12,13 +12,13 @@
 
 #include "dvm.h"
 #include "../Sapfor.h"
-#include "graph_loops.h"
-#include "graph_calls_func.h"
+#include "../GraphLoop/graph_loops.h"
+#include "../GraphCall/graph_calls_func.h"
 #include "../SageAnalysisTool/depInterfaceExt.h"
-#include "SgUtils.h"
-#include "errors.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/errors.h"
 #include "directive_parser.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
 

src/Distribution/Array.cpp

@@ -1,7 +1,7 @@
 #include "Array.h"
-#include "errors.h"
-#include "utils.h"
-#include "graph_calls.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+#include "../GraphCall/graph_calls.h"
 
 using namespace std;
 

src/Distribution/Array.h

@@ -7,9 +7,9 @@
 #include <algorithm>
 #include <climits>
 #include "DvmhDirectiveBase.h"
-#include "utils.h"
-#include "errors.h"
-#include "json.hpp"
+#include "../Utils/utils.h"
+#include "../Utils/errors.h"
+#include "../Utils/json.hpp"
 
 class Symbol;
 class Expression;

src/Distribution/ArrayAnalysis.cpp

@@ -1,8 +1,8 @@
 #include "Array.h"
-#include "errors.h"
-#include "utils.h"
-#include "graph_calls.h"
-#include "SgUtils.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+#include "../GraphCall/graph_calls.h"
+#include "../Utils/SgUtils.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
 #include "../LoopAnalyzer/loop_analyzer.h"

src/Distribution/CreateDistributionDirs.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -14,9 +14,9 @@
 #include "GraphCSR.h"
 #include "Arrays.h"
 
-#include "errors.h"
-#include "utils.h"
-#include "graph_loops.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+#include "../GraphLoop/graph_loops.h"
 
 using std::vector;
 using std::set;

src/Distribution/CreateDistributionDirs.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "graph_loops.h"
-#include "errors.h"
+#include "../GraphLoop/graph_loops.h"
+#include "../Utils/errors.h"
 
 void createDistributionDirs(DIST::GraphCSR<int, double, attrType> &reducedG, DIST::Arrays<int> &allArrays, 
                             DataDirective &dataDirectives, std::map<std::string, std::vector<Messages>> &allMessages, 

src/Distribution/Cycle.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <vector>
 #include <algorithm>

src/Distribution/Cycle.h

@@ -3,7 +3,7 @@
 #include <vector>
 #include <algorithm>
 
-#include "types.h"
+#include "../Utils/types.h"
 
 namespace Distribution
 {

src/Distribution/Distribution.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -30,9 +30,9 @@ using namespace std::chrono;
 #include "Arrays.h"
 #include "Array.h"
 #include "Distribution.h"
-#include "utils.h"
-#include "errors.h"
-#include "types.h"
+#include "../Utils/utils.h"
+#include "../Utils/errors.h"
+#include "../Utils/types.h"
 #include "../Distribution/Cycle.h"
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
@@ -455,7 +455,15 @@ namespace Distribution
             }
 
             if (needPrint)
-                sendMessage_2lvl(4, k, (int)AllCycles.size());
+            {
+#if _WIN32
+                wstring treeM = L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + std::to_wstring(k + 1) + L"/" + std::to_wstring(AllCycles.size());
+#else
+                wstring treeM = L"conflict resolution, processing group " + std::to_wstring(k + 1) + L"/" + std::to_wstring(AllCycles.size());
+#endif
+                sendMessage_2lvl(treeM);
+
+            }
 
             auto timeR = steady_clock::now();
             if (countConflicts != 0)
@@ -508,7 +516,7 @@ namespace Distribution
         }
 
         if (needPrint)
-            sendMessage_2lvl(2);
+            sendMessage_2lvl(L"");
 
         return make_pair(allOnlySecondType, globalSum);
     }
@@ -564,7 +572,13 @@ namespace Distribution
             for (int z = 0; z < arraysV.size(); ++z)
             {
                 const DIST::Array *array = arraysV[z];
-                sendMessage_2lvl(5, z, (int)arrays.size());
+
+#ifdef _WIN32
+                wstring treeM = L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + std::to_wstring(z + 1) + L"/" + std::to_wstring(arrays.size());
+#else
+                wstring treeM = L"conflict resolution, processing array " + std::to_wstring(z + 1) + L"/" + std::to_wstring(arrays.size());
+#endif
+                sendMessage_2lvl(treeM);
 
                 vector<vType> verts;
 
@@ -591,7 +605,7 @@ namespace Distribution
                     }
                 }
             }
-            sendMessage_2lvl(2);
+            sendMessage_2lvl(L"");
         }
         else
         {

src/Distribution/DvmhDirective.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -7,12 +7,12 @@
 #include <string>
 #include <algorithm>
 
-#include "types.h"
+#include "../Utils/types.h"
 #include "DvmhDirective.h"
-#include "errors.h"
-#include "SgUtils.h"
+#include "../Utils/errors.h"
+#include "../Utils/SgUtils.h"
 #include "../Sapfor.h"
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
 
 #include "dvm.h"
 
@@ -346,7 +346,7 @@ static vector<SgExpression*>
                             {
                                 needToAdd = true;
                                 dim_found = true;
-                                subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol()));
+                                subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol));
                                 break;
                             }
                         }

src/Distribution/DvmhDirective.h

@@ -7,9 +7,9 @@
 
 #include "Array.h"
 #include "DvmhDirectiveBase.h"
-#include "AstWrapper.h"
-#include "types.h"
-#include "utils.h"
+#include "../Utils/AstWrapper.h"
+#include "../Utils/types.h"
+#include "../Utils/utils.h"
 
 extern int sharedMemoryParallelization;
 

src/Distribution/DvmhDirectiveBase.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,11 +10,11 @@
 #include "../Distribution/Array.h"
 #include "../Distribution/Arrays.h"
 #include "../Distribution/GraphCSR.h"
-#include "errors.h"
-#include "utils.h"
-#include "json.hpp"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+#include "../Utils/json.hpp"
 
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
 
 using std::vector;
 using std::tuple;

src/Distribution/DvmhDirectiveBase.h

@@ -3,7 +3,7 @@
 #include <vector>
 #include <string>
 
-#include "json.hpp"
+#include "../Utils/json.hpp"
 
 typedef enum lang : int { LANG_C, LANG_F } language;
 typedef enum dist : int { BLOCK, NONE } distType;

src/Distribution/DvmhDirective_func.h

@@ -4,7 +4,7 @@
 #include <string>
 #include <set>
 #include "dvm.h"
-#include "types.h"
+#include "../Utils/types.h"
 
 SgExpression* createAndSetNext(const int side, const int variant, SgExpression *p);
 std::vector<SgExpression*> genSubscripts(const std::vector<std::pair<int, int>> &shadowRenew, const std::vector<std::pair<int, int>> &shadowRenewShifts);

src/Distribution/GraphCSR.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <algorithm>
 #include <string>
@@ -19,8 +19,8 @@ extern int passDone;
 #include "Cycle.h"
 #include "Arrays.h"
 #include "Array.h"
-#include "errors.h"
-#include "utils.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
@@ -830,13 +830,13 @@ namespace Distribution
                         color[k] = WHITE;
 
                     findFrom = currentV;
-/*#ifdef _WIN32
+#ifdef _WIN32
                     if (needPrint)
                     {
                         wstring vertexM = std::to_wstring(k + 1) + L"/" + std::to_wstring(vertByTrees[t].size());
                         sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ") + wstring(treeM.begin(), treeM.end()) + L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + wstring(vertexM.begin(), vertexM.end()));
                     }
-#endif*/
+#endif
                     __spf_print(PRINT_TIMES && needPrint, "v (tree %d) = %d (with neighb %d) ", t, i, neighbors[i + 1] - neighbors[i]);
                     activeV[activeCounter++] = currentV;
                     FindLoop(cyclesTmp[t], currentV, currentV, numbers);
@@ -847,8 +847,8 @@ namespace Distribution
                 maxLoopDim = wasMaxLoopDim;
             }
 
-            /*if (needPrint)
-                sendMessage_2lvl(2);*/
+            if (needPrint)
+                sendMessage_2lvl(L"");
         }
         catch (int code)
         {

src/Distribution/GraphCSR.h

@@ -5,7 +5,7 @@
 #include <set>
 #include <tuple>
 
-#include "RationalNum.h"
+#include "../Utils/RationalNum.h"
 
 typedef enum links { RR_link, WR_link, WW_link } LinkType;
 

src/DvmhRegions/DvmhRegion.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "graph_loops_func.h"
+#include "../GraphLoop/graph_loops_func.h"
 
 #include <string>
 

src/DvmhRegions/DvmhRegionInserter.cpp

@@ -11,7 +11,7 @@
 #include "DvmhRegionInserter.h"
 #include "DvmhRegions/RegionsMerger.h"
 #include "../VerificationCode/verifications.h"
-#include "../Transformations/FunctionPurifying/function_purifying.h"
+#include "../Transformations/function_purifying.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../DirectiveProcessing/directive_parser.h"
 

src/DvmhRegions/DvmhRegionInserter.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "graph_calls_func.h"
-#include "graph_loops_func.h"
-#include "expr_transform.h"
+#include "../GraphCall/graph_calls_func.h"
+#include "../GraphLoop/graph_loops_func.h"
+#include "../ExpressionTransform/expr_transform.h"
 #include "../ParallelizationRegions/ParRegions.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "ReadWriteAnalyzer.h"
 #include "DvmhRegion.h"
 

src/DvmhRegions/LoopChecker.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "graph_loops_func.h"
-#include "graph_calls_func.h"
+#include "../GraphLoop/graph_loops_func.h"
+#include "../GraphCall/graph_calls_func.h"
 
 #include <vector>
 #include <string>

src/DvmhRegions/ReadWriteAnalyzer.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "dvm.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "VarUsages.h"
 #include <set>
 #include <tuple>

src/DvmhRegions/TypedSymbol.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "dvm.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include <string>
 
 enum class VAR_TYPE { VAR_ARR, VAR_DISTR_ARR, VAR_SCALAR, VAR_ANY, VAR_UNDEFINED };

src/DynamicAnalysis/createParallelRegions.cpp

@@ -5,10 +5,10 @@
 #include "./createParallelRegions.h"
 
 #include "../CreateInterTree/CreateInterTree.h"
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
 #include "./gcov_info.h"
 #include "./gCov_parser_func.h"
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <map>
 #include <vector>

src/DynamicAnalysis/createParallelRegions.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "utils.h"
+#include "../Utils/utils.h"
 
 #include "./gcov_info.h"
 #include "../CreateInterTree/CreateInterTree.h"
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
 
 #include <map>
 #include <vector>

src/DynamicAnalysis/gCov_parser.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdio.h>
 #include <fstream>
@@ -8,7 +8,7 @@
 
 #include "dvm.h"
 #include "gCov_parser_func.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 
 using namespace std;
 

src/DynamicAnalysis/gCov_parser_func.h

@@ -5,7 +5,7 @@
 #include <vector>
 
 #include "dvm.h"
-#include "errors.h"
+#include "../Utils/errors.h"
 #include "gcov_info.h"
 #include "../CreateInterTree/CreateInterTree.h"
 

src/DynamicAnalysis/gcov_info.cpp

@@ -1,10 +1,10 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <iostream>
 #include <map>
 #include <algorithm>
 
-#include "errors.h"
+#include "../Utils/errors.h"
 
 #include "gcov_info.h"
 

src/DynamicAnalysis/gcov_info.h

@@ -5,7 +5,7 @@
 #include <map>
 #include <stdint.h>
 
-#include "utils.h"
+#include "../Utils/utils.h"
 
 //make 'class' - need friend for Gcov_info
 struct Perform

src/ExpressionTransform/control_flow_graph_part.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include "dvm.h"
 #include "acc_analyzer.h"

src/ExpressionTransform/expr_transform.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #if _WIN32 && NDEBUG && __SPF && __BOOST
 #include <boost/thread.hpp>
@@ -19,11 +19,11 @@ extern int passDone;
 
 #include "../ParallelizationRegions/ParRegions.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
-#include "graph_loops.h"
-#include "graph_calls.h"
-#include "graph_calls_func.h"
-#include "utils.h"
-#include "SgUtils.h"
+#include "../GraphLoop/graph_loops.h"
+#include "../GraphCall/graph_calls.h"
+#include "../GraphCall/graph_calls_func.h"
+#include "../Utils/utils.h"
+#include "../Utils/SgUtils.h"
 #include "../Distribution/Distribution.h"
 #include "../VisualizerCalls/get_information.h"
 #include "expr_transform.h"

src/ExpressionTransform/expr_transform.h

@@ -5,10 +5,10 @@
 #include <string>
 #include "dvm.h"
 #include "../Distribution/Distribution.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../ParallelizationRegions/ParRegions.h"
-#include "graph_calls.h"
-#include "SgUtils.h"
+#include "../GraphCall/graph_calls.h"
+#include "../Utils/SgUtils.h"
 
 #include "acc_analyzer.h"
 

src/GraphCall/graph_calls.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -15,13 +15,13 @@
 #include "graph_calls_func.h"
 
 #include "../CFGraph/CFGraph.h"
-#include "graph_loops_func.h"
+#include "../GraphLoop/graph_loops_func.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "SgUtils.h"
-#include "json.hpp"
+#include "../Utils/SgUtils.h"
+#include "../Utils/json.hpp"
 #include "../ParallelizationRegions/ParRegions_func.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../VerificationCode/verifications.h"
 

src/GraphCall/graph_calls.h

@@ -3,10 +3,10 @@
 #include <string>
 #include <set>
 
-#include "AstWrapper.h"
-#include "utils.h"
+#include "../Utils/AstWrapper.h"
+#include "../Utils/utils.h"
 #include "../DirectiveProcessing/shadow.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 
 static const char* paramNames[] = 
 { "NONE_T", "ARRAY_T", "STRING_ARRAY_T", "STRING_T", "SCALAR_CHAR_T", "SCALAR_BOOL_T", "SCALAR_SHORT_T", "SCALAR_INT_T", "SCALAR_LONG_INT_T",

src/GraphCall/graph_calls_base.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -10,10 +10,10 @@
 #include <set>
 #include <string>
 
-#include "errors.h"
+#include "../Utils/errors.h"
 #include "graph_calls.h"
 #include "../Distribution/Distribution.h"
-#include "utils.h"
+#include "../Utils/utils.h"
 #include "../ParallelizationRegions/ParRegions.h"
 
 using std::vector;

src/GraphCall/graph_calls_func.h

@@ -5,7 +5,7 @@
 #include <set>
 
 #include "graph_calls.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../ParallelizationRegions/ParRegions.h"
 #include "Utils/json.hpp"
 

src/GraphLoop/graph_loops.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -12,26 +12,26 @@
 
 #include "dvm.h"
 #include "../Sapfor.h"
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 #include "../Distribution/GraphCSR.h"
 #include "../Distribution/Arrays.h"
 #include "../Distribution/Distribution.h"
 
 #include "graph_loops.h"
-#include "utils.h"
-#include "SgUtils.h"
+#include "../Utils/utils.h"
+#include "../Utils/SgUtils.h"
 
-#include "errors.h"
-#include "AstWrapper.h"
-#include "json.hpp"
+#include "../Utils/errors.h"
+#include "../Utils/AstWrapper.h"
+#include "../Utils/json.hpp"
 
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 
-#include "../Transformations/VectorAssignToLoop/array_assign_to_loop.h"
+#include "../Transformations/array_assign_to_loop.h"
 
 using std::vector;
 using std::map;
@@ -520,7 +520,7 @@ static void findArrayRef(SgExpression *exp, bool isWirte, set<DIST::Array*>& use
 {
     if (exp)
     {
-        if (isArrayRef(exp))
+        if (exp->variant() == ARRAY_REF)
         {
             DIST::Array *arrayRef = NULL;
             SgSymbol *symbS = OriginalSymbol(exp->symbol());
@@ -699,12 +699,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
                 newLoop->hasPrints = hasThisIds(st, newLoop->linesOfIO, { WRITE_STAT, READ_STAT, OPEN_STAT, CLOSE_STAT, PRINT_STAT } ); // FORMAT_STAT
                 newLoop->hasStops = hasThisIds(st, newLoop->linesOfStop, { STOP_STAT, PAUSE_NODE });
                 newLoop->hasDvmIntervals = hasThisIds(st, tmpLines, { DVM_INTERVAL_DIR, DVM_ENDINTERVAL_DIR, DVM_EXIT_INTERVAL_DIR });
-                if (isSgForStmt(st))
-                    newLoop->loopType = LoopType::FOR;
-                else if (isSgWhileStmt(st))
-                    newLoop->loopType = LoopType::WHILE;
-                else 
-                    newLoop->loopType = LoopType::NONE;
+                newLoop->isFor = isSgForStmt(st) ? true : false;
                 newLoop->inCanonicalFrom = isSgForStmt(st) ? true : false;
                 newLoop->hasSubstringRefs = hasSubstringRef(st);
 
@@ -782,7 +777,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
                     newLoop->startEndExpr = std::make_pair((Expression*)NULL, (Expression*)NULL);
 
                 newLoop->loop = new Statement(st);
-                newLoop->loopSymbols.addMainVar(st->symbol() ? st->symbol()->identifier() : "unknown");
+                newLoop->loopSymbol = st->symbol() ? st->symbol()->identifier() : "unknown";
                 findArrayRefs(newLoop);
 
                 SgStatement *lexPrev = st->lexPrev();

src/GraphLoop/graph_loops.h

@@ -5,8 +5,8 @@
 #include <map>
 #include <set>
 
-#include "errors.h"
-#include "types.h"
+#include "../Utils/errors.h"
+#include "../Utils/types.h"
 #include "../Distribution/DvmhDirective.h"
 #include "../Distribution/Distribution.h"
 
@@ -25,33 +25,6 @@ namespace DIST = Distribution;
 void getRealArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
 void getAllArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
 
-enum class LoopType { NONE, FOR, WHILE, IMPLICIT };
-
-struct InductiveVariables
-{
-private:
-    std::string mainVar;
-    std::set<std::string> allVars;
-
-public:
-    InductiveVariables() { }
-
-    explicit InductiveVariables(const std::string& mainVar, const std::set<std::string>& allVars) : mainVar(mainVar), allVars(allVars) { };
-
-    std::string getMainVar() const { return mainVar; }
-    std::set<std::string> getAllVars() const { return allVars; }
-
-    void addVar(const std::string& var) { allVars.insert(var); }
-    void addMainVar(const std::string& var) { mainVar = var; allVars.insert(var); }
-
-    void replaceMainVar(const std::string& var) 
-    {
-        allVars.erase(mainVar);
-
-        addMainVar(var);
-    }
-};
-
 struct LoopGraph
 {
 private:
@@ -97,7 +70,7 @@ public:
         calculatedCountOfIters = 0;
         executionTimeInSec = -1.0;
         inDvmhRegion = 0;
-        loopType = LoopType::NONE;
+        isFor = false;
         inCanonicalFrom = false;
         hasAccessToSubArray = false;
         hasSubstringRefs = false;
@@ -140,24 +113,21 @@ public:
     {
         return hasUnknownArrayDep || hasUnknownScalarDep || hasGoto || hasPrints || (hasConflicts.size() != 0) || hasStops || hasNonPureProcedures ||
                hasUnknownArrayAssigns || hasNonRectangularBounds || hasIndirectAccess || hasWritesToNonDistribute || hasDifferentAlignRules || hasDvmIntervals ||
-               !isFor() || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
+               !isFor || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
     }
     
     bool hasLimitsToSplit() const
     {
-        return hasGoto || hasStops || !isFor() || hasPrints;
+        return hasGoto || hasStops || !isFor || hasPrints;
     }
 
     bool hasLimitsToCombine() const
     {
-        return hasGoto || hasStops || !isFor() || hasPrints || linesOfCycle.size();
+        return hasGoto || hasStops || !isFor || hasPrints || linesOfCycle.size();
     }
 
     void addConflictMessages(std::vector<Messages> *messages)
     {
-        if (messages == NULL)
-            return;
-
         const int line = altLineNum > 0 ? altLineNum : lineNum;
         if (hasUnknownArrayDep)
             messages->push_back(Messages(NOTE, line, R113, L"unknown array dependency prevents parallelization of this loop", 3006));
@@ -198,7 +168,7 @@ public:
         if (hasDvmIntervals)
             messages->push_back(Messages(NOTE, line, R145, L"DVM intervals prevent parallelization of this loop", 3006));
 
-        if (!isFor() || !inCanonicalFrom)
+        if (!isFor || !inCanonicalFrom)
             messages->push_back(Messages(NOTE, line, R178, L"This type of loop is not supported by the system", 3006));
 
         if (lastprivateScalars.size())
@@ -423,14 +393,6 @@ public:
 
     void* getRealStat(const char* file) const;
 
-    bool isFor() const { return loopType == LoopType::FOR; }
-
-    bool isWhile() const { return loopType == LoopType::WHILE; }
-
-    bool isImplicit() const { return loopType == LoopType::IMPLICIT; }
-
-    std::string loopSymbol() const { return loopSymbols.getMainVar(); }
-
 public:
     int lineNum;
     int altLineNum;
@@ -445,7 +407,7 @@ public:
     int startVal, endVal, stepVal;
     std::tuple<Expression*, Expression*, Expression*> startEndStepVals;
 
-    InductiveVariables loopSymbols;
+    std::string loopSymbol;
     std::pair<Expression*, Expression*> startEndExpr;
 
     bool hasGoto;
@@ -486,7 +448,7 @@ public:
 
     bool hasSubstringRefs;
 
-    LoopType loopType;
+    bool isFor;
 
     bool inCanonicalFrom;
     

src/GraphLoop/graph_loops_base.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -23,8 +23,8 @@ using std::make_pair;
 using std::get;
 
 #include "graph_loops.h"
-#include "graph_calls_func.h"
-#include "errors.h"
+#include "../GraphCall/graph_calls_func.h"
+#include "../Utils/errors.h"
 #include "../Distribution/Distribution.h"
 #include "../Distribution/CreateDistributionDirs.h"
 #include "../ParallelizationRegions/ParRegions.h"
@@ -551,7 +551,7 @@ void addToDistributionGraph(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*>>
             continue;
         }
 
-        if (!loopAccess.first->isFor())
+        if (!loopAccess.first->isFor)
             continue;
 
         DIST::GraphCSR<int, double, attrType>& G = currReg->GetGraphToModify();
@@ -775,7 +775,7 @@ static void isAllOk(const vector<LoopGraph*> &loops, vector<Messages> &currMessa
     {
         if (loops[i]->region)
         {            
-            if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor())
+            if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor)
             {
                 wstring bufE, bufR;
                 __spf_printToLongBuf(bufE, L"  Can not calculate count of iterations for this loop, information about iterations in all loops in parallel regions '%s' will be ignored", 

src/Inliner/inliner.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -8,13 +8,13 @@
 #include <algorithm>
 
 #include "dvm.h"
-#include "errors.h"
-#include "utils.h"
-#include "SgUtils.h"
-#include "graph_calls_func.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+#include "../Utils/SgUtils.h"
+#include "../GraphCall/graph_calls_func.h"
 #include "inliner.h"
 #include "../VisualizerCalls/SendMessage.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 using std::set;
 using std::map;
@@ -1776,8 +1776,11 @@ static bool inliner(const string& fileName_in, const string& funcName, const int
         point.currCall = func->funcName;
 
         __spf_print(1, "  INLINE %s - ", func->funcName.c_str());
-        sendMessage_2lvl(6, func->funcName);
-
+#ifdef _WIN32
+        sendMessage_2lvl(wstring(L"ïîäñòàíîâêà ôóíêöèè '") + wstring(func->funcName.begin(), func->funcName.end()) + L"'");
+#else 
+        sendMessage_2lvl(wstring(L"inlinig of function '") + wstring(func->funcName.begin(), func->funcName.end()) + L"'");
+#endif
         //1 level
         bool isInlined = run_inliner(funcMap, toInsert, SPF_messages, fileName, func, newSymbsToDeclare, point, commonBlocks);
         __spf_print(1, "%s\n", isInlined ? "done" : "fault");

src/LoopAnalyzer/allocations_prepoc.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -8,8 +8,8 @@
 #include <set>
 
 #include "dvm.h"
-#include "SgUtils.h"
-#include "errors.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/errors.h"
 
 using std::set;
 using std::pair;

src/LoopAnalyzer/dep_analyzer.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -20,8 +20,8 @@
 #include "dvm.h"
 #include "loop_analyzer.h"
 
-#include "utils.h"
-#include "SgUtils.h"
+#include "../Utils/utils.h"
+#include "../Utils/SgUtils.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
 #include "../SageAnalysisTool/depGraph.h"
 #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h"

src/LoopAnalyzer/implicit_loops_analyzer.cpp

@@ -1,281 +0,0 @@
-#include <map>
-#include <set>
-#include <vector>
-#include <string>
-#include <iostream>
-#include <stack>
-
-#include "../CFGraph/IR.h"
-#include "GraphCall/graph_calls.h"
-#include "implicit_loops_analyzer.h"
-
-using namespace std;
-using namespace SAPFOR;
-
-using std::map;
-using std::set;
-using std::vector;
-using std::pair;
-using std::string;
-using std::cout;
-using std::endl;
-using std::make_pair;
-using std::to_string;
-
-enum VisitState { UNVISITED = 0, VISITING = 1, VISITED = 2 };
-
-void dfs(SAPFOR::BasicBlock* block,
-    std::map<int, int>& visit,
-    std::vector<std::pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>>& startAndEnd,
-    SAPFOR::BasicBlock* prev)
-{
-    if (!block)
-        return;
-
-    int id = block->getNumber();
-
-    if (visit[id] == VISITING) {
-        startAndEnd.emplace_back(prev, block);
-        return;
-    }
-
-    if (visit[id] == VISITED)
-        return;
-
-    visit[id] = VISITING;
-
-    for (auto next : block->getNext())
-        dfs(next, visit, startAndEnd, block);
-
-    visit[id] = VISITED;
-}
-
-void getLoopBody(SAPFOR::BasicBlock* loopHeader, const std::set<SAPFOR::BasicBlock*>& loopExits, std::vector<SAPFOR::BasicBlock*>& loopBody)
-{
-    std::set<SAPFOR::BasicBlock*> visited;
-    std::stack<SAPFOR::BasicBlock*> stack;
-
-    stack.push(loopHeader);
-
-    while (!stack.empty())
-    {
-        auto block = stack.top();
-        stack.pop();
-
-        if (visited.count(block))
-            continue;
-        visited.insert(block);
-
-        for (auto succ : block->getNext())
-        {
-            if (loopExits.count(succ))
-                continue;
-            if (!visited.count(succ))
-                stack.push(succ);
-        }
-    }
-
-    std::set<SAPFOR::BasicBlock*> backReachable;
-    std::stack<SAPFOR::BasicBlock*> reverseStack;
-    reverseStack.push(loopHeader);
-
-    while (!reverseStack.empty())
-    {
-        auto block = reverseStack.top();
-        reverseStack.pop();
-
-        if (backReachable.count(block))
-            continue;
-        backReachable.insert(block);
-
-        for (auto pred : block->getPrev())
-            if (visited.count(pred) && !backReachable.count(pred))
-                reverseStack.push(pred);
-    }
-
-    for (auto block : visited)
-        if (backReachable.count(block))
-            loopBody.push_back(block);
-}
-
-SAPFOR::Instruction* findDef(const SAPFOR::Argument* arg,
-    const std::vector<SAPFOR::BasicBlock*>& blocks)
-{
-    if (!arg)
-        return nullptr;
-    std::string argName = arg->getValue();
-
-    for (auto block : blocks) {
-        for (auto instrWrapper : block->getInstructions()) {
-            auto instr = instrWrapper->getInstruction();
-            if (!instr)
-                continue;
-
-            auto res = instr->getResult();
-            if (!res)
-                continue;
-
-            if (res->getValue() == argName)
-                return instr;
-        }
-    }
-
-    return nullptr;
-}
-
-const SAPFOR::Argument* getBaseSource(const SAPFOR::Argument* arg, const std::vector<SAPFOR::BasicBlock*>& blocks)
-{
-    while (arg && arg->getType() == CFG_ARG_TYPE::REG)
-    {
-        auto defInstr = findDef(arg, blocks);
-        if (!defInstr)
-            break;
-        auto defOp = defInstr->getOperation();
-
-        if (defOp == CFG_OP::ASSIGN)
-            arg = defInstr->getArg1();
-        else
-            break;
-    }
-    return arg;
-}
-
-void findInductiveVars(const std::vector<SAPFOR::BasicBlock*>& Loopblocks, const std::vector<SAPFOR::BasicBlock*>& blocks)
-{
-    std::set<std::string> inductiveVars;
-
-    for (auto block : Loopblocks)
-    {
-        for (auto instrWrapper : block->getInstructions())
-        {
-            auto instr = instrWrapper->getInstruction();
-            if (!instr)
-                continue;
-
-            auto res = instr->getResult();
-            if (!res || res->getType() != SAPFOR::CFG_ARG_TYPE::VAR)
-                continue;
-
-            while (instr && instr->getOperation() == CFG_OP::ASSIGN)
-                instr = findDef(instr->getArg1(), blocks);
-
-            if (!instr || instr->getOperation() != CFG_OP::ADD && instr->getOperation() != CFG_OP::SUBT)
-                continue;
-
-            auto arg1 = getBaseSource(instr->getArg1(), blocks);
-            auto arg2 = getBaseSource(instr->getArg2(), blocks);
-
-            bool ok = false;
-            if (res->getValue() == arg1->getValue() && arg2->getType() == CFG_ARG_TYPE::CONST)
-                ok = true;
-            else if (res->getValue() == arg2->getValue() && arg1->getType() == CFG_ARG_TYPE::CONST)
-                ok = true;
-
-            if (ok)
-                inductiveVars.insert(res->getValue());
-        }
-    }
-
-    if (inductiveVars.empty())
-        std::cout << "No inductive variables found." << std::endl;
-    else
-        for (const auto& var : inductiveVars)
-            std::cout << "Inductive variable: " << var << std::endl;
-}
-
-Instruction* findInstructionAfterLoop(const std::vector<SAPFOR::BasicBlock*>& loopBody)
-{
-    std::set<SAPFOR::BasicBlock*> loopSet(loopBody.begin(), loopBody.end());
-
-    for (auto block : loopBody)
-    {
-        for (auto succ : block->getNext())
-        {
-            if (!loopSet.count(succ))
-            {
-                auto instructions = succ->getInstructions();
-                if (instructions.empty())
-                    std::cout << "Exit block has no instructions." << std::endl;
-
-                for (auto wrapper : instructions)
-                    if (auto instr = wrapper->getInstruction())
-                        return instr;
-            }
-        }
-    }
-
-    return nullptr;
-}
-
-void findImplicitLoops(const std::vector<SAPFOR::BasicBlock*>& irSSA, const std::vector<LoopGraph*> loopGraph)
-{
-    map<int, int> visited;
-    for (auto i : irSSA)
-        visited[i->getNumber()] = UNVISITED;
-
-    vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>> startAndEnd;
-    dfs(irSSA[0], visited, startAndEnd, NULL);
-
-    vector<LoopGraph*> loops;
-
-    for (auto& [tail, header] : startAndEnd)
-    {
-        set<SAPFOR::BasicBlock*> loopExits;
-
-        for (auto succ : tail->getNext())
-            if (succ != header)
-                loopExits.insert(succ);
-
-        vector<SAPFOR::BasicBlock*> loopBody;
-        getLoopBody(header, loopExits, loopBody);
-
-        findInductiveVars(loopBody, irSSA);
-
-        Instruction* instructionAfterLoop = findInstructionAfterLoop(loopBody);
-
-        if (instructionAfterLoop == NULL)
-        {
-            cout << "Warning: instruction after loop not found!" << endl;
-            continue;
-        }
-
-        auto firstInstruction = header->getInstructions()[0]->getInstruction();
-        auto lastInstruction = tail->getInstructions().back()->getInstruction();
-        auto tmpLoop = new LoopGraph();
-        tmpLoop->lineNum = firstInstruction->getOperator()->lineNumber();
-        tmpLoop->lineNumAfterLoop = instructionAfterLoop->getOperator()->lineNumber();
-
-
-        if (firstInstruction->getOperator()->variant() == FOR_NODE) 
-        {
-            SgForStmt* stmt = isSgForStmt(firstInstruction->getOperator());
-
-            cout << "for loop" << endl;
-        }
-        else if (firstInstruction->getOperator()->variant() == WHILE_NODE) 
-        {
-            SgWhileStmt* stmt = isSgWhileStmt(firstInstruction->getOperator());
-
-            cout << (stmt->conditional() == NULL ? "infinit" : "") << "while loop" << endl;
-        }
-        else if (firstInstruction->getOperator()->variant() == DO_WHILE_NODE) 
-        {
-            SgWhileStmt* stmt = isSgDoWhileStmt(firstInstruction->getOperator());
-
-            cout << "do while loop" << endl;
-        }
-        else if (firstInstruction->getOperator()->variant() == LOOP_NODE) 
-        {
-            cout << "not known loop" << endl;
-        }
-        else
-        {
-            cout << "goto loop" << endl;
-        }
-
-        cout << "loop start line " << tmpLoop->lineNum << endl;
-        cout << "after loop line " << tmpLoop->lineNumAfterLoop << endl << endl;
-
-        loops.push_back(tmpLoop);
-    }
-}

src/LoopAnalyzer/implicit_loops_analyzer.h

@@ -1,7 +0,0 @@
-#pragma once
-
-#include <map>
-#include "../CFGraph/CFGraph.h"
-#include "../GraphCall/graph_calls.h"
-
-void findImplicitLoops(const std::vector<SAPFOR::BasicBlock*>& fullIR_SSA, const std::vector<LoopGraph*> loopGraph);

src/LoopAnalyzer/loop_analyzer.cpp

@@ -18,7 +18,7 @@
 #include <tuple>
 #include <stack>
 
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #if _WIN32 && NDEBUG && __BOOST
 #include <boost/thread.hpp>
@@ -30,25 +30,25 @@ extern int passDone;
 #include "../Distribution/Arrays.h"
 #include "../ParallelizationRegions/ParRegions.h"
 
-#include "errors.h"
+#include "../Utils/errors.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_creator.h"
 
-#include "SgUtils.h"
-#include "AstWrapper.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/AstWrapper.h"
 
-#include "graph_calls_func.h"
-#include "graph_loops_func.h"
+#include "../GraphCall/graph_calls_func.h"
+#include "../GraphLoop/graph_loops_func.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 #include "../SageAnalysisTool/depInterfaceExt.h"
 
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
-#include "../Transformations/LoopEndDoConverter/enddo_loop_converter.h"
+#include "../Transformations/enddo_loop_converter.h"
 
 #include "../DirectiveProcessing/remote_access.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
@@ -1633,7 +1633,17 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
         createNeededException();
 
         string fName = file->functions(i)->symbol()->identifier();
-        sendMessage_2lvl(0, (file->functions(i)->variant() != MODULE_STMT), fName);
+#if _WIN32
+        if (file->functions(i)->variant() != MODULE_STMT)
+            sendMessage_2lvl(wstring(L"обработка функции '") + wstring(fName.begin(), fName.end()) + L"'");
+        else
+            sendMessage_2lvl(wstring(L"обработка модуля '") + wstring(fName.begin(), fName.end()) + L"'");
+#else
+        if (file->functions(i)->variant() != MODULE_STMT)
+            sendMessage_2lvl(wstring(L"processing function '") + wstring(fName.begin(), fName.end()) + L"'");
+        else
+            sendMessage_2lvl(wstring(L"processing module '") + wstring(fName.begin(), fName.end()) + L"'");
+#endif
 
         set<SgSymbol*> delcsSymbViewed;
         set<SgStatement*> delcsStatViewed;
@@ -2178,8 +2188,11 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                 if (!skipDeps)
                 {
                     string fName = file->functions(i)->symbol()->identifier();
-                    sendMessage_2lvl(1, idx, (int)convertedLoopInfo.size());
-
+#ifdef _WIN32
+                    sendMessage_2lvl(wstring(L"обработка цикла ") + std::to_wstring(idx) + L"/" + std::to_wstring(convertedLoopInfo.size()));
+#else
+                    sendMessage_2lvl(wstring(L"processing loop ") + std::to_wstring(idx) + L"/" + std::to_wstring(convertedLoopInfo.size()));
+#endif
                     tryToFindDependencies(loop.first, allLoops, funcWasInit, file, regions, currMessages, collection, funcByName, defUseByPlace);
                 }
             }
@@ -2199,7 +2212,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                             LoopGraph *tmpLoop = new LoopGraph();
 
                             tmpLoop->region = reg;
-                            tmpLoop->loopType = LoopType::FOR;
+                            tmpLoop->isFor = true;
 
                             tmpLoops.push_back(tmpLoop);
 
@@ -2327,7 +2340,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                 if (parallizeFreeLoops)
                     selectFreeLoopsForParallelization(loopsForFunction, funcName, (regime == DATA_DISTR), regions, messagesForFile);
             }
-            sendMessage_2lvl(2);
+            sendMessage_2lvl(L"");
         }
         else if (regime == COMP_DISTR)
         {

src/LoopAnalyzer/loop_analyzer.h

@@ -5,12 +5,12 @@
 #include <tuple>
 #include <vector>
 #include <set>
-#include "graph_loops.h"
-#include "graph_calls.h"
+#include "../GraphLoop/graph_loops.h"
+#include "../GraphCall/graph_calls.h"
 #include "../ParallelizationRegions/ParRegions.h"
 #include "../SageAnalysisTool/depInterfaceExt.h"
-#include "AstWrapper.h"
-#include "SgUtils.h"
+#include "../Utils/AstWrapper.h"
+#include "../Utils/SgUtils.h"
 
 #include "dvm.h"
 

src/ParallelizationRegions/ParRegions.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,12 +10,12 @@
 
 #include "dvm.h"
 #include "ParRegions.h"
-#include "utils.h"
-#include "SgUtils.h"
-#include "graph_calls_func.h"
-#include "graph_loops.h"
+#include "../Utils/utils.h"
+#include "../Utils/SgUtils.h"
+#include "../GraphCall/graph_calls_func.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../Distribution/Distribution.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 using std::vector;
 using std::string;

src/ParallelizationRegions/ParRegions.h

@@ -9,12 +9,12 @@
 #include "../Distribution/DvmhDirective.h"
 #include "../Distribution/GraphCSR.h"
 #include "../Distribution/Distribution.h"
-#include "AstWrapper.h"
+#include "../Utils/AstWrapper.h"
 
-#include "json.hpp"
+#include "../Utils/json.hpp"
 
 #if __SPF
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #endif
 
 struct ParallelRegionLines

src/ParallelizationRegions/ParRegions_func.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "ParRegions.h"
-#include "graph_calls.h"
-#include "graph_loops.h"
+#include "../GraphCall/graph_calls.h"
+#include "../GraphLoop/graph_loops.h"
 
 void fillRegionLines(SgFile *file, std::vector<ParallelRegion*> &regions, std::vector<Messages>& messagesForFile, std::vector<LoopGraph*> *loops = NULL, std::vector<FuncInfo*> *funcs = NULL);
 void fillRegionLinesStep2(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo, std::map<std::string, std::vector<LoopGraph*>> *loopGraph = NULL);

src/ParallelizationRegions/expand_extract_reg.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <map>
 #include <string>

src/ParallelizationRegions/expand_extract_reg.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "ParRegions.h"
-#include "SgUtils.h"
-#include "errors.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/errors.h"
 
 bool expandExtractReg(const std::string &fileName, const int startLine, const int endLine, const std::vector<ParallelRegion*> &regions, std::vector<Messages> &messagesForFile, const bool toDelete = false);

src/ParallelizationRegions/resolve_par_reg_conflicts.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <string>
 #include <vector>
@@ -11,14 +11,14 @@
 #include "ParRegions_func.h"
 #include "resolve_par_reg_conflicts.h"
 
-#include "graph_calls_func.h"
-#include "graph_loops_func.h"
+#include "../GraphCall/graph_calls_func.h"
+#include "../GraphLoop/graph_loops_func.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../DirectiveProcessing/directive_creator.h"
 #include "../DirectiveProcessing/insert_directive.h"
-#include "SgUtils.h"
-#include "expr_transform.h"
-#include "../Transformations/FunctionPurifying/function_purifying.h"
+#include "../Utils/SgUtils.h"
+#include "../ExpressionTransform/expr_transform.h"
+#include "../Transformations/function_purifying.h"
 
 using std::map;
 using std::pair;

src/ParallelizationRegions/resolve_par_reg_conflicts.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include "ParRegions.h"
-#include "SgUtils.h"
-#include "errors.h"
-#include "graph_calls.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/errors.h"
+#include "../GraphCall/graph_calls.h"
 
 void fillRegionIntervals(std::vector<ParallelRegion*> &regions);
 void fillRegionArrays(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo, const std::map<std::string, CommonBlock*> &commonBlocks);

src/Predictor/PredictScheme.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -16,11 +16,11 @@
 #include "../DynamicAnalysis/gcov_info.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 #include "PredictScheme.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../Distribution/DvmhDirective.h"
-#include "graph_loops_func.h"
-#include "expr_transform.h"
+#include "../GraphLoop/graph_loops_func.h"
+#include "../ExpressionTransform/expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../CFGraph/CFGraph.h"
 

src/Predictor/PredictScheme.h

@@ -1,8 +1,8 @@
 #pragma once
 #include <vector>
 #include "dvm.h"
-#include "graph_calls.h"
-#include "json.hpp"
+#include "../GraphCall/graph_calls.h"
+#include "../Utils/json.hpp"
 
 class ParallelStats
 {

src/PrivateAnalyzer/private_analyzer.cpp

@@ -1,5 +1,5 @@
 #define _LEAK_
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstring>
@@ -9,7 +9,7 @@
 #include <vector>
 #include <fstream>
 
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
 #include "private_analyzer.h"
 #include "dvm.h"
 #include "../CFGraph/CFGraph.h"

src/PrivateAnalyzer/private_analyzer.h

@@ -3,7 +3,7 @@
 #include <vector>
 
 #include "dvm.h"
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
 
 extern void Private_Vars_Analyzer(SgStatement* start);
 void PrivateAnalyzer(SgFile *file, std::vector<FuncInfo*> &funcs);

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -9,8 +9,8 @@
 #include "private_arrays_search.h"
 #include "range_structures.h"
 #include "region.h"
-#include "SgUtils.h"
-#include "graph_loops.h"
+#include "../Utils/SgUtils.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../CFGraph/CFGraph.h"
 
 using namespace std;
@@ -121,7 +121,7 @@ static void SolveDataFlow(Region* DFG)
     Collapse(DFG);
 }
 
-map<LoopGraph*, ArrayAccessingIndexes>  findPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
+map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
     for (const auto& [loopName, loops] : loopGraph)

src/PrivateAnalyzer/private_arrays_search.h

@@ -6,9 +6,9 @@
 
 #include "range_structures.h"
 #include "region.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../CFGraph/CFGraph.h"
 
 void Collapse(Region* region);
-std::map<LoopGraph*, ArrayAccessingIndexes> findPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
+std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
 std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);

src/PrivateAnalyzer/range_structures.cpp

@@ -2,8 +2,8 @@
 #include <map>
 #include <unordered_set>
 #include <string>
+#include <numeric>
 
-#include "utils.h"
 #include "range_structures.h"
 
 using namespace std;

src/PrivateAnalyzer/region.cpp

@@ -8,7 +8,7 @@
 #include "range_structures.h"
 #include "region.h"
 
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 
 using namespace std;
 
@@ -51,7 +51,7 @@ pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForL
 }
 
 static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loop) {
-    string index = loop->loopSymbol();
+    string index = loop->loopSymbol;
     loopForIndex[index] = loop;
 
     for (const auto& childLoop : loop->children)
@@ -146,7 +146,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
             {
                 auto var = index_vars.back();
                 int currentVarPos = refPos.back();
-                pair<int, int> currentCoefs = coefsForDims.back();
+                pair currentCoefs = coefsForDims.back();
                 ArrayDimension current_dim;
                 if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
                     current_dim = { stoul(var->getValue()), 1, 1 };

src/PrivateAnalyzer/region.h

@@ -5,7 +5,7 @@
 #include <unordered_set>
 #include <string>
 
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../CFGraph/CFGraph.h"
 
 class Region : public SAPFOR::BasicBlock {

src/ProjectManipulation/ConvertFiles.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -6,9 +6,9 @@
 #include <string>
 #include <vector>
 
-#include "errors.h"
-#include "SgUtils.h"
-#include "utils.h"
+#include "../Utils/errors.h"
+#include "../Utils/SgUtils.h"
+#include "../Utils/utils.h"
 
 #include "../VerificationCode/verifications.h"
 

src/ProjectManipulation/FileInfo.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -7,8 +7,8 @@
 #include <vector>
 
 #include "FileInfo.h"
-#include "utils.h"
-#include "errors.h"
+#include "../Utils/utils.h"
+#include "../Utils/errors.h"
 
 using namespace std;
 

src/ProjectManipulation/ParseFiles.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -22,8 +22,8 @@
 #include <thread>
 #include <stack>
 
-#include "errors.h"
-#include "SgUtils.h"
+#include "../Utils/errors.h"
+#include "../Utils/SgUtils.h"
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
@@ -34,7 +34,6 @@
 using namespace std;
 
 extern "C" int parse_file(int argc, char* argv[], char* proj_name);
-extern const char* VISUALIZER_DATA_PATH;
 
 static void findModuleDeclInProject(const string& name, const vector<string>& files, map<string, string>& modDecls)
 {
@@ -294,8 +293,11 @@ static vector<string> parseList(vector<FileInfo>& listOfProject,
             }
         }
 
-        sendMessage_2lvl(3, file);
-
+#ifdef _WIN32
+        sendMessage_2lvl(L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> '" + to_wstring(file) + L"'");
+#else 
+        sendMessage_2lvl(L" processing file '" + to_wstring(file) + L"'");
+#endif        
         StdCapture::Init();
         string errorMessage = "";
         try
@@ -441,12 +443,20 @@ static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string
         if (errors[z] == "")
         {
             FILE* ferr = fopen(file.errPath.c_str(), "w");
-            if (ferr)
-                fclose(ferr);
+            if (!ferr)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+            fclose(ferr);
             ++z;
             continue;
         }
 
+        FILE* ferr = fopen(file.errPath.c_str(), "w");
+        FILE* fout = fopen(file.outPath.c_str(), "w");
+        if (!ferr)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+        if (!fout)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
         string errS = "", outS = "";
         vector<string> splited;
         splitString(errors[z], '\n', splited);
@@ -465,22 +475,13 @@ static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string
             }
         }
 
-
-        FILE* ferr = fopen(file.errPath.c_str(), "w");
-        FILE* fout = fopen(file.outPath.c_str(), "w");
-        if (ferr)
-        {
-            fprintf(ferr, "%s", errS.c_str());
-            fclose(ferr);
-        }
-
-        if (fout)
-        {
-            fprintf(fout, "%s", outS.c_str());
-            fclose(fout);
-        }
+        fprintf(fout, "%s", outS.c_str());
+        fprintf(ferr, "%s", errS.c_str());
 
         fflush(NULL);
+
+        fclose(fout);
+        fclose(ferr);
         ++z;
     }
 
@@ -575,8 +576,11 @@ static void parseFiles(int& iters, vector<string>& errors, vector<FileInfo>& lis
 
     do
     {
-        sendMessage_1lvl(0, iters + 1);
-
+#ifdef _WIN32
+        sendMessage_1lvl(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + std::to_wstring((iters + 1)) + L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
+#else
+        sendMessage_1lvl(L"running " + std::to_wstring((iters + 1)) + L" iteration of syntax analisys");
+#endif
         errors = parseList(listOfProject, iters != 0, parseForInlining, mapModuleDeps, moduleDelc, modDirectOrder, isFromConsole);
         changed = createMapOfUse(errors, listOfProject, mapModuleDeps);
         if (iters != 0)
@@ -709,7 +713,7 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
 
     if (pathSplit.size() < 2)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-    if (pathSplit[pathSplit.size() - 2] != VISUALIZER_DATA_PATH)
+    if (pathSplit[pathSplit.size() - 2] != "visualiser_data")
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
     string fullPath = "";
     for (int z = 0; z < pathSplit.size() - 2; ++z)
@@ -741,9 +745,9 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
         else
             fileNameFixed = (toAdd.substr(0, 2) == "./") ? toAdd.substr(2) : toAdd;
 
-        const string optPath = fullPath + VISUALIZER_DATA_PATH  + "/options/" + fileNameFixed + ".opt";
-        const string errPath = fullPath + VISUALIZER_DATA_PATH  + "/options/" + fileNameFixed + ".err";
-        const string outPath = fullPath + VISUALIZER_DATA_PATH  + "/options/" + fileNameFixed + ".out";
+        const string optPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".opt";
+        const string errPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".err";
+        const string outPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".out";
 
         const string fileText = readFileToStr(toAdd);
 
@@ -805,8 +809,6 @@ void parseFiles(int argc, char** argv)
         printf("  run parsing for inlining\n");
 
     int rethrow = parseFiles(errors, listOfProject, filesCompilationOrder, isInline, true);
-    int errCount = dumpErrors(listOfProject, errors, messages);
-
     if (rethrow == 0)
     {
         for (auto& err : errors)
@@ -836,7 +838,5 @@ void parseFiles(int argc, char** argv)
     }
     else
         printf("Parsing was completed with errors, throw code %d, errors count %d\n", rethrow, code);
-
-    dumpMessages(false, messages, VISUALIZER_DATA_PATH);
     exit(0);
 }