1526 lines
64 KiB
Java
1526 lines
64 KiB
Java
package _VisualDVM.ProjectData.Project;
|
||
import Common.CommonConstants;
|
||
import Common.Database.Objects.DBObject;
|
||
import Common.Passes.PassException;
|
||
import Common.Utils.Index;
|
||
import Common.Utils.TextLog;
|
||
import Common.Utils.Utils_;
|
||
import Common.Visual.UI;
|
||
import _VisualDVM.Constants;
|
||
import _VisualDVM.Current;
|
||
import _VisualDVM.Global;
|
||
import _VisualDVM.GlobalData.DBLastProject.DBLastProject;
|
||
import _VisualDVM.GlobalData.Settings.SettingName;
|
||
import _VisualDVM.Passes.PassCode;
|
||
import _VisualDVM.ProjectData.DBArray.DBArray;
|
||
import _VisualDVM.ProjectData.Files.DBProjectFile;
|
||
import _VisualDVM.ProjectData.Files.FileState;
|
||
import _VisualDVM.ProjectData.Files.FileType;
|
||
import _VisualDVM.ProjectData.Files.LanguageStyle;
|
||
import _VisualDVM.ProjectData.LanguageName;
|
||
import _VisualDVM.ProjectData.Messages.Errors.MessageError;
|
||
import _VisualDVM.ProjectData.Messages.Notes.MessageNote;
|
||
import _VisualDVM.ProjectData.Messages.Recommendations.MessageRecommendation;
|
||
import _VisualDVM.ProjectData.Messages.Warnings.MessageWarning;
|
||
import _VisualDVM.ProjectData.ProjectDatabase;
|
||
import _VisualDVM.ProjectData.SapforData.Arrays.ProjectArraysSet;
|
||
import _VisualDVM.ProjectData.SapforData.Arrays.ProjectArray;
|
||
import _VisualDVM.ProjectData.SapforData.Functions.FuncCall;
|
||
import _VisualDVM.ProjectData.SapforData.Functions.FuncCallH;
|
||
import _VisualDVM.ProjectData.SapforData.Functions.FuncInfo;
|
||
import _VisualDVM.ProjectData.SapforData.Functions.UI.Graph.GraphInfo;
|
||
import _VisualDVM.ProjectData.SapforData.Includes.FileInfo;
|
||
import _VisualDVM.ProjectData.SapforData.Regions.ParallelRegion;
|
||
import _VisualDVM.ProjectData.SapforData.Regions.ParallelRegionsSet;
|
||
import _VisualDVM.ProjectData.SapforData.Variants.ParallelVariant;
|
||
import _VisualDVM.ProjectData.SapforData.Variants.ParallelVariantsSet;
|
||
import _VisualDVM.TestingSystem.Common.Test.ProjectFiles_json;
|
||
import _VisualDVM.Utils;
|
||
import com.mxgraph.swing.mxGraphComponent;
|
||
import com.sun.org.glassfish.gmbal.Description;
|
||
import javafx.util.Pair;
|
||
import org.apache.commons.io.FileUtils;
|
||
|
||
import javax.swing.tree.DefaultMutableTreeNode;
|
||
import java.io.File;
|
||
import java.math.BigInteger;
|
||
import java.nio.file.Files;
|
||
import java.nio.file.Paths;
|
||
import java.util.*;
|
||
import java.util.stream.Collectors;
|
||
public class db_project_info extends DBObject {
|
||
public static Vector<db_project_info> newVersions = new Vector<>();
|
||
//--
|
||
public DefaultMutableTreeNode align_rules_root = new DefaultMutableTreeNode("");
|
||
public DefaultMutableTreeNode includes_root = new DefaultMutableTreeNode("");
|
||
//-
|
||
public DefaultMutableTreeNode inline_root = new DefaultMutableTreeNode("");
|
||
public DefaultMutableTreeNode inline_root2 = new DefaultMutableTreeNode("");
|
||
//<editor-fold desc="Хранимые в бд поля">
|
||
@Description("PRIMARY KEY,NOT NULL")
|
||
public String name = "";
|
||
public String original = "";
|
||
public String description = "";
|
||
public LanguageName languageName = LanguageName.fortran;
|
||
@Description("DEFAULT 'fixed'")
|
||
public LanguageStyle style = LanguageStyle.fixed;
|
||
public String Log = "";//текст выдаваемый сапфором
|
||
//-----------------------------------------------
|
||
@Description("DEFAULT -1")
|
||
public long creationDate = CommonConstants.Nan; //--------------------------------------------------NEW.
|
||
@Description("DEFAULT ''")
|
||
public String compilation_output = "";
|
||
@Description("DEFAULT ''")
|
||
public String compilation_errors = "";
|
||
@Description("DEFAULT ''")
|
||
public String run_output = "";
|
||
@Description("DEFAULT ''")
|
||
public String run_errors = "";
|
||
@Description("DEFAULT ''")
|
||
public String Scenario = "";//трассировка вызываемых визуализатором проходов.
|
||
@Description("DEFAULT ''")
|
||
public String VersionBuilding = "";
|
||
public int filter_distributed = 0;
|
||
public int filter_multiplied = 0;
|
||
@Description("DEFAULT 40")
|
||
public int compilation_maxtime = 40;
|
||
@Description("DEFAULT 120")
|
||
public int run_maxtime = 120;
|
||
@Description("DEFAULT 0")
|
||
public int maxdim = 0;
|
||
//<editor-fold desc="Метрика">
|
||
@Description("DEFAULT -1")
|
||
public int numLines = CommonConstants.Nan;
|
||
@Description("DEFAULT -1")
|
||
public int numSPF = CommonConstants.Nan;
|
||
@Description("DEFAULT -1")
|
||
public int numDVM = CommonConstants.Nan;
|
||
@Description("DEFAULT -1")
|
||
public int numArrays = CommonConstants.Nan;
|
||
@Description("DEFAULT -1")
|
||
public int numLoops = CommonConstants.Nan;
|
||
@Description("DEFAULT -1")
|
||
public int numFunctions = CommonConstants.Nan;
|
||
@Description("DEFAULT -1")
|
||
public int numAddicted = CommonConstants.Nan;
|
||
//-------------------------------------
|
||
//параметры графа функций. храним для каждого проекта.
|
||
@Description("DEFAULT 500")
|
||
public int fgIterations = 500;
|
||
@Description("DEFAULT 300")
|
||
public int fgResistance = 300;
|
||
@Description("DEFAULT 1.0")
|
||
public double fgScreen = 1.0;
|
||
//------------------------------------
|
||
@Description("IGNORE")
|
||
public int testMaxDim = 0;
|
||
@Description("IGNORE")
|
||
public boolean isNew = false; //для выделения только что построенных версий.
|
||
//------------------------------------
|
||
//тут ключ - идентификатор. не меняем.
|
||
public ProjectArraysSet declaratedArrays = new ProjectArraysSet();
|
||
//new - все объявленные в проекте функции.
|
||
public FuncInfo main_function = null;
|
||
public FuncCallH main_functionH = null;
|
||
//-
|
||
public LinkedHashMap<String, FuncInfo> allFunctions = new LinkedHashMap<>();
|
||
//-
|
||
public LinkedHashMap<String, FileInfo> addictedFiles = new LinkedHashMap<>();
|
||
//тут ключ -адрес. меняем
|
||
public Vector<ProjectArray> templates = new Vector<>();
|
||
public ParallelRegionsSet parallelRegions = new ParallelRegionsSet();
|
||
public ParallelVariantsSet parallelVariants = new ParallelVariantsSet();
|
||
public GraphInfo functionsGraph = new GraphInfo();
|
||
public Vector<String> files_order = new Vector<>();
|
||
public db_project_info last_modification = null;
|
||
public db_project_info last_version = null;
|
||
//-------------------------------------------------------------------------------------->>>>>
|
||
public DefaultMutableTreeNode node = null;
|
||
public db_project_info parent = null; //родительская версия.
|
||
public LinkedHashMap<String, db_project_info> versions = new LinkedHashMap<>(); //подверсии.
|
||
public Vector<File> subdirectories = new Vector();///подпапки.
|
||
public File Home = null;
|
||
public DefaultMutableTreeNode filesTreeRoot = null;
|
||
public ProjectDatabase db = null;
|
||
public LinkedHashMap<String, DBProjectFile> allIncludes = new LinkedHashMap<>();
|
||
DBLastProject info = null; //обновляется при открытии проекта.
|
||
public db_project_info() {
|
||
}
|
||
//----------------------------------
|
||
// в случае восстановления после полной очистки
|
||
//восстановление при полной очистке.
|
||
public db_project_info(db_project_info to_restore) throws Exception {
|
||
Home = to_restore.Home;
|
||
name = to_restore.name;
|
||
description = to_restore.description;
|
||
original = to_restore.original;
|
||
fgIterations = to_restore.fgIterations;
|
||
fgResistance = to_restore.fgResistance;
|
||
fgScreen = to_restore.fgScreen;
|
||
creationDate = to_restore.creationDate;
|
||
//-
|
||
CreateVisualiserData();
|
||
}
|
||
//конструктор для пустой версии (cо структурой папок)
|
||
public db_project_info(db_project_info parent_in,
|
||
String letter_in,
|
||
String description_in,
|
||
String original_in) throws Exception {
|
||
parent = parent_in;
|
||
name = parent.GenerateVersionName(letter_in);
|
||
languageName = parent.languageName;
|
||
style = ((Global.mainModule.getDb()).settings.get(SettingName.FREE_FORM).toBoolean() ? LanguageStyle.free : LanguageStyle.fixed);
|
||
description = description_in;
|
||
original = original_in;
|
||
Home = Paths.get(parent_in.Home.getAbsolutePath(), name).toFile();
|
||
parent.SaveVersionToBuild(name);
|
||
if (!Home.mkdir()) throw new PassException("Не удалось создать папку для версии");
|
||
creationDate = Utils_.getDateNumber(); //----------------------------------------------------------------------------->>>
|
||
CreateVisualiserData();
|
||
parent.AddVersion(this);
|
||
//если это делать раньше, папка версии учтется как подпапка.
|
||
parent.CopySubdirectories(Home);
|
||
}
|
||
//------------------------------
|
||
//если бд не существует. только для конверсии тестов на корректность.
|
||
public db_project_info(File Directory, String description_, boolean create_data) throws Exception {
|
||
Home = Directory;
|
||
name = Home.getName();
|
||
description = description_;
|
||
if (create_data) {
|
||
creationDate = Utils_.getDateNumber(); //----------------------------------------------------------------------------->>>
|
||
CreateVisualiserData();
|
||
}
|
||
}
|
||
//обычное открытие.
|
||
public db_project_info(File dir) throws Exception {
|
||
Home = dir;
|
||
//-
|
||
CheckVisualiserDirectories();
|
||
db = new ProjectDatabase(this);
|
||
db.Connect();
|
||
db.CreateAllTables();
|
||
db.prepareTablesStatements();
|
||
db_project_info stored_info = db.LoadOnlyProjectInfo();
|
||
if (stored_info == null) {
|
||
name = Home.getName();
|
||
description = "";
|
||
creationDate = Utils_.getDateNumber(); //----------------------------------------------------------------------------->>>
|
||
db.Insert(this);
|
||
} else
|
||
ExtractStoredInfo(stored_info);
|
||
db.Disconnect();
|
||
}
|
||
//-
|
||
public static File get_db_file(File project_home) {
|
||
return new File(Paths.get(project_home.toString(), Constants.data,
|
||
Global.properties.ProjectDBName).toString());
|
||
}
|
||
public static String recommendAnalysis(PassCode code_in) {
|
||
return Constants.unknown_metric + " примените анализатор \"" + code_in.getDescription() + "\"";
|
||
}
|
||
public static void ResetNewVersions() {
|
||
for (db_project_info version : newVersions) {
|
||
version.isNew = false;
|
||
}
|
||
newVersions.clear();
|
||
}
|
||
public static int extractVersionNumber(db_project_info version) {
|
||
int res = 0;
|
||
try {
|
||
res = Integer.parseInt(version.name.substring(1));
|
||
} catch (Exception ex) {
|
||
ex.printStackTrace();
|
||
}
|
||
return res;
|
||
}
|
||
public static void sortVersionsByNumber(Vector<db_project_info> versions) {
|
||
versions.sort(Comparator.comparingInt(db_project_info::extractVersionNumber));
|
||
}
|
||
//-
|
||
public void Open() throws Exception {
|
||
db.Connect();
|
||
db.prepareTablesStatements();
|
||
db.Synchronize();
|
||
}
|
||
public void Close() throws Exception {
|
||
db.Disconnect();
|
||
dropLastModification();
|
||
}
|
||
//-исходная
|
||
public void CreateVisualiserData() throws Exception {
|
||
CheckVisualiserDirectories();
|
||
db = new ProjectDatabase(this);
|
||
db.Connect();
|
||
db.CreateAllTables();
|
||
db.prepareTablesStatements();
|
||
db.Insert(this);
|
||
db.Disconnect();
|
||
}
|
||
/*
|
||
public boolean isGCOVDone() {
|
||
return gcov_is_done != 0;
|
||
}*/
|
||
//------------------------------------
|
||
public void UpdatefgIterations(int iterations_in) {
|
||
fgIterations = iterations_in;
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
}
|
||
public void UpdatefgResistance(int resistance_in) {
|
||
fgResistance = resistance_in;
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
}
|
||
public void UpdatefgScreen(double screen_in) {
|
||
fgScreen = screen_in;
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
}
|
||
public void UpdateCompilationMaxtime(int ct_in) {
|
||
compilation_maxtime = ct_in;
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
}
|
||
public void UpdateRunMaxtime(int rt_in) {
|
||
run_maxtime = rt_in;
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
}
|
||
//</editor-fold>
|
||
//</editor-fold>
|
||
//-----------------------------------
|
||
public boolean f_distributed() {
|
||
return filter_distributed != 0;
|
||
}
|
||
public boolean f_multiplied() {
|
||
return filter_multiplied != 0;
|
||
}
|
||
public void SwitchFilterDistributed() {
|
||
filter_distributed = f_distributed() ? 0 : 1;
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
}
|
||
public void SwitchFilterMultiplied() {
|
||
filter_multiplied = f_multiplied() ? 0 : 1;
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
}
|
||
public boolean IsMCopy() {
|
||
String lname = name.toLowerCase();
|
||
return (lname.startsWith("m") && Utils_.isIntegerValue(lname.substring(1)));
|
||
}
|
||
public String getTitle() {
|
||
return name + " " + Utils_.DQuotes(description);
|
||
}
|
||
public File getProjFile() {
|
||
return Paths.get(Home.getAbsolutePath(), Constants.data, Constants.spf).toFile();
|
||
}
|
||
public File getDataDirectory() {
|
||
return Paths.get(Home.getAbsolutePath(), Constants.data).toFile();
|
||
}
|
||
public File getOptionsDirectory() {
|
||
return Paths.get(Home.getAbsolutePath(), Constants.data, Constants.options).toFile();
|
||
}
|
||
public File getGCOVDirectory() {
|
||
return Paths.get(Home.getAbsolutePath(), Constants.data, Constants.gcov).toFile();
|
||
}
|
||
public File getAttachmentsDirectory() {
|
||
return Paths.get(Home.getAbsolutePath(), Constants.data, Constants.attachments).toFile();
|
||
}
|
||
public File getAnalyzerDirectory() {
|
||
return Paths.get(Home.getAbsolutePath(), Constants.data, Constants.PerformanceAnalyzerDirectoryName).toFile();
|
||
}
|
||
public Vector<File> getScreenShots() {
|
||
Vector<File> res = new Vector<>();
|
||
File[] files = getAttachmentsDirectory().listFiles();
|
||
if (files != null) {
|
||
for (File file : files) {
|
||
if (!file.isDirectory() && file.getName().startsWith("screenshot"))
|
||
res.add(file);
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
public File getStatisticDirectory() {
|
||
return Paths.get(Home.getAbsolutePath(), Constants.data, Constants.statistic).toFile();
|
||
}
|
||
public db_project_info find_version_r(File v_home) {
|
||
if (Home.equals(v_home)) return this;
|
||
for (db_project_info version : versions.values())
|
||
if (version.Home.equals(v_home)) return version;
|
||
for (db_project_info version : versions.values()) {
|
||
db_project_info res = version.find_version_r(v_home);
|
||
if (res != null) return res;
|
||
}
|
||
return null;
|
||
}
|
||
public DBProjectFile getLastOpenedFile() {
|
||
long max = 0;
|
||
DBProjectFile res = null;
|
||
for (DBProjectFile f : db.files.Data.values()) {
|
||
if (!f.state.equals(FileState.Excluded)) {
|
||
if (f.file.lastModified() > max) {
|
||
res = f;
|
||
max = f.file.lastModified();
|
||
}
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
public void CreateParserOptionsDirs() throws Exception {
|
||
Utils_.forceDeleteWithCheck(getOptionsDirectory());
|
||
FileUtils.forceMkdir(getOptionsDirectory());
|
||
CopySubdirectories(getOptionsDirectory());
|
||
}
|
||
public void CreateGCOVDirs() throws Exception {
|
||
Utils_.forceDeleteWithCheck(getGCOVDirectory());
|
||
FileUtils.forceMkdir(getGCOVDirectory());
|
||
CopySubdirectories(getGCOVDirectory());
|
||
}
|
||
public void ClearGCOV() throws Exception {
|
||
CreateGCOVDirs();
|
||
//updateGCOV_status(0);
|
||
for (DBProjectFile file : db.files.Data.values()) {
|
||
file.GCOVLog = "";
|
||
db.Update(file);
|
||
}
|
||
}
|
||
public DBProjectFile getFirstBadFile() {
|
||
for (DBProjectFile f : db.files.Data.values()) {
|
||
if (f.state.equals(FileState.HasErrors))
|
||
return f;
|
||
}
|
||
return null;
|
||
}
|
||
public void CleanAnalyses() throws Exception {
|
||
allIncludes.clear();
|
||
files_order.clear();
|
||
functionsGraph.Clear();
|
||
numLines = CommonConstants.Nan;
|
||
numSPF = CommonConstants.Nan;
|
||
numDVM = CommonConstants.Nan;
|
||
numArrays = CommonConstants.Nan;
|
||
numFunctions = CommonConstants.Nan;
|
||
numAddicted = CommonConstants.Nan;
|
||
numLoops = CommonConstants.Nan;
|
||
Log = "";
|
||
Scenario = "";
|
||
declaratedArrays.clear();
|
||
main_function = null;
|
||
main_functionH = null;
|
||
allFunctions.clear();
|
||
RefreshInlineRoot();
|
||
parallelRegions.clear();
|
||
addictedFiles.clear();
|
||
templates.clear();
|
||
parallelVariants.clear();
|
||
align_rules_root.removeAllChildren();
|
||
inline_root.removeAllChildren();
|
||
inline_root2.removeAllChildren();
|
||
includes_root.removeAllChildren();
|
||
Update();
|
||
for (DBProjectFile file : db.files.Data.values())
|
||
file.CleanAll();
|
||
db.DeleteAll(MessageRecommendation.class);
|
||
//в таблице сообщений скинуть счетчик.
|
||
db.ResetAI(MessageNote.class);
|
||
db.ResetAI(MessageError.class);
|
||
db.ResetAI(MessageWarning.class);
|
||
db.ResetAI(MessageRecommendation.class);
|
||
//-
|
||
Global.mainModule.set(Current.Function, null);
|
||
Global.mainModule.set(Current.SelectedFunction, null);
|
||
}
|
||
public void CleanVersions() throws Exception {
|
||
node.removeAllChildren();
|
||
for (db_project_info v : versions.values())
|
||
Utils_.forceDeleteWithCheck(v.Home);
|
||
versions.clear();
|
||
dropLastModification();
|
||
}
|
||
public void dropLastModification() {
|
||
last_modification = null;
|
||
}
|
||
public void Update() {
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception ex) {
|
||
Utils_.MainLog.PrintException(ex);
|
||
}
|
||
}
|
||
public boolean UpdateLanguage(LanguageName lang_in) {
|
||
if (!languageName.equals(lang_in)) {
|
||
languageName = lang_in;
|
||
Update();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
public boolean UpdateStyle(LanguageStyle s) {
|
||
if (!style.equals(s)) {
|
||
style = s;
|
||
Update();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
public void UpdateMaxDim() {
|
||
Update();
|
||
}
|
||
public void GenRules() {
|
||
align_rules_root.removeAllChildren();
|
||
maxdim = 0;
|
||
UpdateMaxDim();
|
||
if (templates.size() > 0) {
|
||
for (ParallelRegion p : parallelRegions.Data.values()) {
|
||
DefaultMutableTreeNode pn = new DefaultMutableTreeNode(p);
|
||
p.dataDirectives.genRules(p.arrays);
|
||
for (String r : p.dataDirectives.rules)
|
||
pn.add(new DefaultMutableTreeNode(r));
|
||
maxdim = Math.max(maxdim, p.maxdim);
|
||
align_rules_root.add(pn);
|
||
}
|
||
UpdateMaxDim();
|
||
for (ProjectArray t : templates)
|
||
t.CreateDimensions();
|
||
}
|
||
}
|
||
public void gen_rec(Vector<ProjectArray> templates, Vector<Vector<BigInteger>> res, int index) {
|
||
if (index >= 0) {
|
||
ProjectArray current = templates.get(index);
|
||
Vector<Vector<BigInteger>> old = new Vector<>();
|
||
for (Vector<BigInteger> L : res)
|
||
old.add(L);
|
||
res.clear();
|
||
Vector<Long> varIDs = current.get_varIDs();
|
||
for (Long varID : varIDs) {
|
||
for (Vector<BigInteger> L : old) {
|
||
for (BigInteger regID : current.regIDs) //тройки для всех областей.
|
||
{
|
||
Vector<BigInteger> buf = new Vector<>();
|
||
buf.add(current.address);
|
||
buf.add(BigInteger.valueOf(varID));
|
||
buf.add(regID);
|
||
for (BigInteger l : L)
|
||
buf.add(l);
|
||
res.add(buf);
|
||
}
|
||
}
|
||
}
|
||
gen_rec(templates, res, index - 1);
|
||
}
|
||
}
|
||
public String LinesCount() {
|
||
return numLines == ParallelVariant.statNaN ? recommendAnalysis(PassCode.SPF_GetFileLineInfo) : String.valueOf(numLines);
|
||
}
|
||
public String SPFCount() {
|
||
return numSPF == ParallelVariant.statNaN ? recommendAnalysis(PassCode.SPF_GetFileLineInfo) : String.valueOf(numSPF);
|
||
}
|
||
public String DVMCount() {
|
||
return numDVM == ParallelVariant.statNaN ? recommendAnalysis(PassCode.SPF_GetFileLineInfo) : String.valueOf(numDVM);
|
||
}
|
||
public String ArraysCount() {
|
||
return numArrays == ParallelVariant.statNaN ? recommendAnalysis(PassCode.SPF_GetAllDeclaratedArrays) : String.valueOf(numArrays);
|
||
}
|
||
public String LoopsCount() {
|
||
return numLoops == ParallelVariant.statNaN ? recommendAnalysis(PassCode.SPF_GetGraphLoops) : String.valueOf(numLoops);
|
||
}
|
||
public String FunctionsCount() {
|
||
return numFunctions == CommonConstants.Nan ? recommendAnalysis(PassCode.SPF_GetGraphFunctions) : String.valueOf(numFunctions);
|
||
}
|
||
public String AddictedCount() {
|
||
return numAddicted == CommonConstants.Nan ? recommendAnalysis(PassCode.SPF_GetIncludeDependencies) : String.valueOf(numAddicted);
|
||
}
|
||
public boolean UpdateLinesCount() {
|
||
try {
|
||
db.Update(this);
|
||
return true;
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
return false;
|
||
}
|
||
public void UpdateSPFCount() {
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
}
|
||
public void UpdateDVMCount() {
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
}
|
||
public boolean UpdateAddictedCount() {
|
||
try {
|
||
db.Update(this);
|
||
return true;
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
return false;
|
||
}
|
||
// https://javarush.ru/groups/posts/2274-kak-ispoljhzovatjh-bigdecimal-v-java
|
||
public BigInteger getFilteredVariantsCount() {
|
||
if (templates.isEmpty()) return BigInteger.ZERO;
|
||
BigInteger amount = BigInteger.ONE;
|
||
for (ProjectArray template : templates)
|
||
amount = amount.multiply(BigInteger.valueOf(template.get_varIDs().size()));
|
||
return amount;
|
||
}
|
||
public BigInteger getTotalVariantsCount() {
|
||
if (templates.isEmpty()) return BigInteger.ZERO;
|
||
BigInteger amount = BigInteger.ONE;
|
||
for (ProjectArray template : templates)
|
||
amount = amount.multiply(BigInteger.valueOf(template.get_varIDs(false).size()));
|
||
return amount;
|
||
}
|
||
//получить имя относительно папки проекта.
|
||
public String getInnerName(File file) {
|
||
return file.getAbsolutePath().substring(Home.getAbsolutePath().length() + 1).replace('/', '\\');
|
||
}
|
||
public LinkedHashMap<LanguageName, Vector<DBProjectFile>> getPrograms() {
|
||
LinkedHashMap<LanguageName, Vector<DBProjectFile>> res = new LinkedHashMap<>();
|
||
//-----------------------------------------------
|
||
res.put(LanguageName.fortran, new Vector<>());
|
||
res.put(LanguageName.c, new Vector<>());
|
||
res.put(LanguageName.cpp, new Vector<>());
|
||
for (DBProjectFile file : db.files.Data.values()) {
|
||
if (!file.state.equals(FileState.Excluded) && file.fileType.equals(FileType.program) && (!file.languageName.equals(LanguageName.n)))
|
||
res.get(file.languageName).add(file);
|
||
}
|
||
return res;
|
||
}
|
||
public String getUniqKey() {
|
||
return Home.getAbsolutePath().replace("\\", "").replace(":", "").replace("/", "");
|
||
}
|
||
//получить все подпапки проекта на указанном уровне.
|
||
public Vector<File> getSubdirectoriesSimple(File dir) {
|
||
Vector<File> res = new Vector<>();
|
||
for (File d : Objects.requireNonNull(dir.listFiles())) {
|
||
if (isProjectDirectory(d))
|
||
res.add(d);
|
||
}
|
||
return res;
|
||
}
|
||
//получить файлы относящиеся к проекту, лежащие в данной папке.
|
||
public Vector<File> getFiles(File dir) {
|
||
Vector<File> res = new Vector<>();
|
||
for (DBProjectFile file : db.files.Data.values()) {
|
||
if (file.file.getParentFile().getAbsolutePath().equals(dir.getAbsolutePath()))
|
||
res.add(file.file);
|
||
}
|
||
return res;
|
||
}
|
||
public Vector<File> getActiveFilesForSynchronization(File dir, boolean data) {
|
||
Vector<File> res = new Vector<>();
|
||
for (DBProjectFile file : db.files.Data.values()) {
|
||
if (file.file.getParentFile().getAbsolutePath().equals(dir.getAbsolutePath())
|
||
&& (!file.state.equals(FileState.Excluded)) &&
|
||
!file.file.getName().equalsIgnoreCase("MAKEFILE") &&
|
||
(!data || file.fileType.equals(FileType.data))
|
||
)
|
||
res.add(file.file);
|
||
//мейкфайлы если они есть все будут игнорироваться. имеет право на существование на машине
|
||
//только технический мейкфайл.
|
||
}
|
||
return res;
|
||
}
|
||
public DBLastProject getInfo() {
|
||
return info;
|
||
}
|
||
public void setInfo(DBLastProject info_in) {
|
||
info = info_in;
|
||
}
|
||
public File getStsFile() {
|
||
return Paths.get(getStatisticDirectory().getAbsolutePath(), "statistic.txt").toFile();
|
||
}
|
||
public String getStsText() {
|
||
return getStsFile().exists() ? Utils.ReadAllText(getStsFile()) : "файла статистики не существует.\nЗапустите проект на DVM системе, чтобы его получить";
|
||
}
|
||
public void check_files_r(File file, Vector<DBProjectFile> res) {
|
||
if (isProjectDirectory(file)) {
|
||
for (File f : Objects.requireNonNull(file.listFiles()))
|
||
check_files_r(f, res);
|
||
} else if (file.isFile()) {
|
||
DBProjectFile pf = new DBProjectFile(file, this);
|
||
if (pf.fileType != FileType.forbidden)
|
||
res.add(pf);
|
||
}
|
||
}
|
||
public Vector<DBProjectFile> getFilesForComparsion() {
|
||
Vector<DBProjectFile> res = new Vector<>();
|
||
if (Global.mainModule.HasProject() && this.Home.equals(Global.mainModule.getProject().Home)) {
|
||
//
|
||
res = db.files.Data.values().stream().filter(file -> !file.state.equals(FileState.Excluded)).collect(Collectors.toCollection(Vector::new));
|
||
} else {
|
||
try {
|
||
//версия для сравнения - не текущий проект. придется лезть в ее бд. Предполагаем что она всегда есть.
|
||
Open();
|
||
res = db.files.Data.values().stream().filter(file -> !file.state.equals(FileState.Excluded)).collect(Collectors.toCollection(Vector::new));
|
||
Close();
|
||
} catch (Exception ex) {
|
||
ex.printStackTrace();
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
public boolean FolderNotExists(File new_directory, File subdir, TextLog passLog) {
|
||
for (File pf : getSubdirectoriesSimple(subdir)) {
|
||
if (pf.getName().equals(new_directory.getName())) {
|
||
passLog.Writeln("В папке " + Utils_.Brackets(subdir.getAbsolutePath()) + "\n" +
|
||
"уже существует папка с именем " + Utils_.Brackets(new_directory.getName()));
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
public File getInterruptFile() {
|
||
return Paths.get(getDataDirectory().getAbsolutePath(), CommonConstants.INTERRUPT).toFile();
|
||
}
|
||
public void CleanInterruptFile() throws Exception {
|
||
File file = getInterruptFile();
|
||
Utils_.forceDeleteWithCheck(file);
|
||
}
|
||
public void CreateInterruptFile() throws Exception {
|
||
FileUtils.write(getInterruptFile(), Global.mode.toString());
|
||
}
|
||
public void AppendScenario(String line_in) {
|
||
Scenario += (line_in + "\n");
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception ex) {
|
||
Utils_.MainLog.PrintException(ex);
|
||
}
|
||
}
|
||
public mxGraphComponent DrawFunctionsGraph() {
|
||
return functionsGraph.Draw();
|
||
}
|
||
public DefaultMutableTreeNode getAttachmentsTree() {
|
||
File[] attachments = getAttachmentsDirectory().listFiles();
|
||
DefaultMutableTreeNode root = new DefaultMutableTreeNode(
|
||
(attachments != null) ? ("Файлов: " + attachments.length) : "Файлов: 0");
|
||
if (attachments != null) {
|
||
for (File a : attachments)
|
||
root.add(new DefaultMutableTreeNode(a));
|
||
}
|
||
return root;
|
||
}
|
||
public boolean CheckAttachmentFile(File f, TextLog Log) {
|
||
Utils.validateFileShortNewName(f.getName(), Log);
|
||
if (Utils_.getFileSizeMegaBytes(f) > 2)
|
||
Log.Writeln_("Размер вложения " + Utils_.Brackets(f.getName()) + " превышает 2 Мb");
|
||
return Log.isEmpty();
|
||
}
|
||
public boolean CheckAllAttachments(TextLog Log) {
|
||
File[] attachments = getAttachmentsDirectory().listFiles();
|
||
if (attachments != null) {
|
||
for (File a : attachments)
|
||
CheckAttachmentFile(a, Log);
|
||
}
|
||
return Log.isEmpty();
|
||
}
|
||
public void RefreshInlineRoot() {
|
||
inline_root.setUserObject("Отметьте вызовы для подстановки");
|
||
}
|
||
public void RefreshInlineRoot2() {
|
||
inline_root2.setUserObject("Отметьте полные цепочки вызовов для подстановки");
|
||
}
|
||
public void BuildInlineGraph() {
|
||
Vector<FuncInfo> sortedFunctions = new Vector<>(allFunctions.values());
|
||
sortedFunctions.sort(Comparator.comparing(o -> o.funcName));
|
||
for (FuncInfo decl1 : sortedFunctions) {
|
||
if (decl1.isDeclared()) {
|
||
DefaultMutableTreeNode node = new DefaultMutableTreeNode(decl1);
|
||
inline_root.add(node);
|
||
//-
|
||
for (FuncInfo decl2 : allFunctions.values()) {
|
||
for (FuncCall call : decl2.calls) {
|
||
if (call.funcName.equals(decl1.funcName)) {
|
||
if (!decl1.own_calls.containsKey(call.file))
|
||
decl1.own_calls.put(call.file, new Vector<>());
|
||
if (decl1.needToInline) call.Select(true);
|
||
call.canBeInlined = !decl1.doNotInline;
|
||
decl1.own_calls.get(call.file).add(call);
|
||
node.add(new DefaultMutableTreeNode(call));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
public void BuildInlineGraph2() {
|
||
if (main_function != null) {
|
||
//особый случай.
|
||
main_functionH = new FuncCallH(main_function);
|
||
DefaultMutableTreeNode main_node = new DefaultMutableTreeNode(main_functionH);
|
||
for (FuncCall call : main_function.calls) {
|
||
Vector<String> chain = new Vector<>();
|
||
chain.add(main_functionH.funcName);
|
||
// UI.Info("start new chain");
|
||
DefaultMutableTreeNode node = BuildInlineGraph2_r(call, chain);
|
||
if (node != null) {
|
||
main_node.add(node);
|
||
main_functionH.calls.add((FuncCallH) node.getUserObject());
|
||
}
|
||
}
|
||
inline_root2.add(main_node);
|
||
}
|
||
}
|
||
public DefaultMutableTreeNode BuildInlineGraph2_r(FuncCall funcCall, Vector<String> chain) {
|
||
chain.add(funcCall.funcName);
|
||
//--
|
||
FuncCallH funcCallH = new FuncCallH(funcCall);
|
||
DefaultMutableTreeNode res = null;
|
||
FuncInfo funcInfo = allFunctions.get(funcCall.funcName);
|
||
res = new DefaultMutableTreeNode(funcCallH);
|
||
for (FuncCall call : funcInfo.calls) {
|
||
if (!chain.contains(call.funcName)) {
|
||
DefaultMutableTreeNode node = BuildInlineGraph2_r(call, chain);
|
||
if (node != null) {
|
||
res.add(node);
|
||
funcCallH.calls.add((FuncCallH) node.getUserObject());
|
||
}
|
||
} else System.out.println("RECURSION " + String.join("->", chain) + "->" + call.funcName);
|
||
}
|
||
return res;
|
||
}
|
||
@Override
|
||
public Object getPK() {
|
||
return name;
|
||
}
|
||
//----------------------------------------------------
|
||
private void CheckVisualiserDirectories() {
|
||
Utils_.CheckDirectory(getDataDirectory());
|
||
Utils_.CheckDirectory(getOptionsDirectory());
|
||
Utils_.CheckDirectory(getStatisticDirectory());
|
||
Utils_.CheckDirectory(getAttachmentsDirectory());
|
||
Utils_.CheckDirectory(getGCOVDirectory());
|
||
Utils_.CheckDirectory(getAnalyzerDirectory());
|
||
}
|
||
//загрузка инфы из бд проекта.
|
||
private void ExtractStoredInfo(db_project_info to_restore) {
|
||
name = to_restore.name;
|
||
original = to_restore.original;
|
||
description = to_restore.description;
|
||
languageName = to_restore.languageName;
|
||
style = to_restore.style;
|
||
Log = to_restore.Log;
|
||
creationDate = to_restore.creationDate;
|
||
Scenario = to_restore.Scenario;
|
||
filter_distributed = to_restore.filter_distributed;
|
||
filter_multiplied = to_restore.filter_multiplied;
|
||
compilation_maxtime = to_restore.compilation_maxtime;
|
||
run_maxtime = to_restore.run_maxtime;
|
||
compilation_output = to_restore.compilation_output;
|
||
compilation_errors = to_restore.compilation_errors;
|
||
run_output = to_restore.run_output;
|
||
run_errors = to_restore.run_errors;
|
||
//----------------------------------
|
||
numLines = to_restore.numLines;
|
||
numArrays = to_restore.numArrays;
|
||
numFunctions = to_restore.numFunctions;
|
||
numAddicted = to_restore.numAddicted;
|
||
numLoops = to_restore.numLoops;
|
||
numSPF = to_restore.numSPF;
|
||
numDVM = to_restore.numDVM;
|
||
///--
|
||
fgIterations = to_restore.fgIterations;
|
||
fgResistance = to_restore.fgResistance;
|
||
fgScreen = to_restore.fgScreen;
|
||
maxdim = to_restore.maxdim;
|
||
}
|
||
//-
|
||
public String GenerateVersionName(String letter) {
|
||
String res = "";
|
||
int max_vn = 0;
|
||
if (versions.keySet().size() > 0) {
|
||
for (String key_ : versions.keySet()) {
|
||
String[] data_ = key_.split(letter);
|
||
String last = data_[data_.length - 1];
|
||
if (Utils_.isIntegerValue(last)) {
|
||
int vn = Integer.parseInt(last);
|
||
if (vn > max_vn)
|
||
max_vn = vn;
|
||
}
|
||
}
|
||
}
|
||
File version_folder = null;
|
||
do {
|
||
res = letter + ++max_vn;
|
||
version_folder = Paths.get(Home.getAbsolutePath(), res).toFile();
|
||
} while (version_folder.exists());
|
||
return res;
|
||
}
|
||
public void CloneParent() throws Exception {
|
||
for (DBProjectFile file : parent.db.files.Data.values()) {
|
||
Files.copy(file.file.toPath(),
|
||
Paths.get(Home.getAbsolutePath(),
|
||
Utils_.isWindows() ? file.name :
|
||
file.name.replace('\\', '/')));
|
||
}
|
||
}
|
||
public void AddVersion(db_project_info version) throws Exception {
|
||
version.isNew = true;
|
||
newVersions.add(version);
|
||
//--->>
|
||
versions.put(version.name, version);
|
||
Global.mainModule.getUI().getVersionsWindow().getVersionsForm().getTree().AddNode(node, version.node = new DefaultMutableTreeNode(version));
|
||
SaveVersionToBuild("");
|
||
}
|
||
public void SaveVersionToBuild(String v_name) throws Exception {
|
||
if (!v_name.equalsIgnoreCase(VersionBuilding)) {
|
||
VersionBuilding = v_name;
|
||
db.Update(this);
|
||
}
|
||
}
|
||
public void DeleteCrushedVersionIfNeed() throws Exception {
|
||
if (!VersionBuilding.equals("")) {
|
||
Utils_.forceDeleteWithCheck(Paths.get(Home.getAbsolutePath(), VersionBuilding).toFile());
|
||
SaveVersionToBuild("");
|
||
}
|
||
}
|
||
public void createModification() throws Exception {
|
||
if (last_modification == null) {
|
||
last_modification = new db_project_info(this,
|
||
"m",
|
||
"копия от " + new Date(),
|
||
"");
|
||
last_modification.CloneParent();
|
||
}
|
||
}
|
||
public void createEmptyVersion(String versionLetter, String versionDescription) throws Exception {
|
||
boolean needsM = (Global.mainModule.getDb()).settings.get(SettingName.SaveModifications).toBoolean();
|
||
if (needsM)
|
||
createModification();
|
||
last_version = new db_project_info(
|
||
this,
|
||
versionLetter,
|
||
versionDescription,
|
||
needsM ? last_modification.name : ""
|
||
);
|
||
}
|
||
public void joinExistingVersion(File versionDirectory, String description_in) throws Exception {
|
||
last_version = new db_project_info();
|
||
last_version.parent = this;
|
||
last_version.name = versionDirectory.getName();
|
||
last_version.languageName = this.languageName;
|
||
last_version.description = description_in;
|
||
last_version.original = last_modification.name;
|
||
last_version.Home = versionDirectory;
|
||
last_version.creationDate = Utils_.getDateNumber(); //----------------------------------------------------------------------------->>>
|
||
last_version.CreateVisualiserData();
|
||
this.AddVersion(last_version);
|
||
}
|
||
//не является ли текущая версия последней модификацией
|
||
public void checkLastModification(db_project_info version) {
|
||
if ((last_modification != null) && version.Home.equals(last_modification.Home))
|
||
last_modification = null;
|
||
}
|
||
public boolean isProjectDirectory(File dir) {
|
||
if (!dir.isDirectory()) return false;
|
||
if (dir.getName().equals(Constants.data)) return false;
|
||
for (db_project_info version : versions.values()) {
|
||
if (version.Home.equals(dir)) return false;
|
||
}
|
||
return true;
|
||
}
|
||
private void getSubdirectoriesR(File dir) {
|
||
File[] files_ = dir.listFiles();
|
||
if (files_ != null)
|
||
for (File d : files_) {
|
||
if (isProjectDirectory(d)) {
|
||
subdirectories.add(d);
|
||
getSubdirectoriesR(d);
|
||
}
|
||
}
|
||
}
|
||
public void CopySubdirectories(File dir) throws Exception {
|
||
subdirectories.clear();
|
||
getSubdirectoriesR(Home);
|
||
for (File d : subdirectories) {
|
||
String path = d.getAbsolutePath().substring(Home.getAbsolutePath().length());
|
||
File cd = Paths.get(dir.getAbsolutePath(), path).toFile();
|
||
FileUtils.forceMkdir(cd);
|
||
}
|
||
}
|
||
//--
|
||
private void getLonelyM_r(Vector<db_project_info> res) {
|
||
Vector<db_project_info> ms = new Vector<>();
|
||
Vector<db_project_info> vs = new Vector<>();
|
||
for (db_project_info version : versions.values()) {
|
||
if (version.IsMCopy())
|
||
ms.add(version);
|
||
else vs.add(version);
|
||
}
|
||
for (db_project_info m : ms) {
|
||
boolean lonely = true;
|
||
for (db_project_info v : vs) {
|
||
if (v.original.equalsIgnoreCase(m.name)) {
|
||
lonely = false;
|
||
break;
|
||
}
|
||
}
|
||
if (lonely) {
|
||
res.add(m);
|
||
}
|
||
}
|
||
for (db_project_info version : vs) {
|
||
version.getLonelyM_r(res);
|
||
}
|
||
}
|
||
public Vector<db_project_info> getLonelyM() {
|
||
Vector<db_project_info> res = new Vector<>();
|
||
this.getLonelyM_r(res);
|
||
return res;
|
||
}
|
||
public void cleanDepAndGCOVR() throws Exception {
|
||
Utils_.forceDeleteWithCheck(getOptionsDirectory());
|
||
Utils_.forceDeleteWithCheck(getGCOVDirectory());
|
||
Utils_.forceDeleteWithCheck(getStatisticDirectory());
|
||
for (db_project_info version : versions.values())
|
||
version.cleanDepAndGCOVR();
|
||
}
|
||
//---
|
||
public Pair<LinkedHashMap<String, DBProjectFile>, LinkedHashMap<String, DBProjectFile>> sortFiles() {
|
||
LinkedHashMap<String, DBProjectFile> active_programs = new LinkedHashMap<>();
|
||
LinkedHashMap<String, DBProjectFile> others = new LinkedHashMap<>();
|
||
//---
|
||
for (DBProjectFile file : db.files.Data.values()) {
|
||
if (file.isActiveProgram())
|
||
active_programs.put(file.name, file);
|
||
else
|
||
others.put(file.name, file);
|
||
}
|
||
//---
|
||
return new Pair<>(active_programs, others);
|
||
}
|
||
public DBProjectFile getFileByNameIgnoreCase(String name_in) {
|
||
for (DBProjectFile file : db.files.Data.values()) {
|
||
if (file.name.equalsIgnoreCase(name_in)) {
|
||
return file;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
public void migrateFilesSettings(db_project_info target, boolean migrate_arrays, boolean sapforStyle) throws Exception {
|
||
Pair<LinkedHashMap<String, DBProjectFile>, LinkedHashMap<String, DBProjectFile>> sortedFiles = sortFiles();
|
||
//--
|
||
LinkedHashMap<String, DBProjectFile> programs = sortedFiles.getKey();
|
||
LinkedHashMap<String, DBProjectFile> files = sortedFiles.getValue();
|
||
//--
|
||
target.Open();
|
||
target.db.BeginTransaction();
|
||
Pair<LinkedHashMap<String, DBProjectFile>, LinkedHashMap<String, DBProjectFile>> sortedVersionFiles = target.sortFiles();
|
||
LinkedHashMap<String, DBProjectFile> version_programs = sortedVersionFiles.getKey();
|
||
//--
|
||
for (DBProjectFile program : programs.values()) {
|
||
for (DBProjectFile version_program : version_programs.values()) {
|
||
boolean same_names = program.getProjectNameWithoutExtension().equals(version_program.getProjectNameWithoutExtension());
|
||
if (same_names) {
|
||
version_program.importSettings(program, sapforStyle);
|
||
target.db.Update(version_program);
|
||
}
|
||
}
|
||
}
|
||
for (DBProjectFile file : files.values()) {
|
||
DBProjectFile version_file = target.getFileByNameIgnoreCase(file.name);
|
||
if (version_file != null) {
|
||
version_file.importSettings(file, sapforStyle);
|
||
target.db.Update(version_file);
|
||
} else {
|
||
File toCopy = Paths.get(target.Home.getAbsolutePath(), file.name).toFile();
|
||
if (!toCopy.exists())
|
||
Files.copy(file.file.toPath(), toCopy.toPath());
|
||
//--
|
||
DBProjectFile new_version_file = new DBProjectFile(toCopy, target);
|
||
new_version_file.importSettings(file, sapforStyle);
|
||
target.db.Insert(new_version_file);
|
||
}
|
||
}
|
||
//---
|
||
target.languageName = this.languageName;
|
||
target.maxdim = this.maxdim;
|
||
target.db.Update(target);
|
||
//------------------------
|
||
if (migrate_arrays) {
|
||
//миграция массивов.
|
||
for (DBArray a : db.savedArrays.Data.values())
|
||
target.db.Insert(a);
|
||
}
|
||
//---
|
||
target.db.Commit();
|
||
target.Close();
|
||
}
|
||
public void undoLastTransformation() throws Exception {
|
||
Global.mainModule.set(Current.Version, null);
|
||
//---
|
||
Global.mainModule.getUI().getVersionsWindow().getVersionsForm().getTree().RemoveNode(last_version.node);
|
||
Utils_.forceDeleteWithCheck(last_version.Home);
|
||
versions.remove(last_version.name);
|
||
last_version = null;
|
||
//---
|
||
if (last_modification != null) {
|
||
Utils_.forceDeleteWithCheck(last_modification.Home);
|
||
Global.mainModule.getUI().getVersionsWindow().getVersionsForm().getTree().RemoveNode(last_modification.node);
|
||
versions.remove(last_modification.name);
|
||
last_modification = null;
|
||
}
|
||
//---
|
||
}
|
||
public void Clone(File dst, boolean cloneData) throws Exception {
|
||
CopySubdirectories(dst);
|
||
//->
|
||
for (DBProjectFile file : db.files.Data.values()) {
|
||
File src_file = file.file;
|
||
File dst_file = Paths.get(dst.getAbsolutePath(),
|
||
Utils_.isWindows() ? file.name :
|
||
file.name.replace('\\', '/')).toFile();
|
||
Files.copy(src_file.toPath(), dst_file.toPath());
|
||
}
|
||
//теперь копируем инфу по файлам.
|
||
if (cloneData) {
|
||
db_project_info res = new db_project_info(dst);
|
||
migrateFilesSettings(res, true, false);
|
||
}
|
||
}
|
||
public void Clone(File dst) throws Exception {
|
||
Clone(dst, true);
|
||
}
|
||
public void ResetDB() throws Exception {
|
||
Utils.CleanDirectory(getDataDirectory());
|
||
db_project_info to_restore = new db_project_info();
|
||
//-
|
||
to_restore.name = name;
|
||
to_restore.description = description;
|
||
to_restore.original = original;
|
||
// to_restore.fgIterations = fgIterations;
|
||
// to_restore.fgResistance = fgResistance;
|
||
// to_restore.fgScreen = fgScreen;
|
||
//-
|
||
CheckVisualiserDirectories();
|
||
db.Connect();
|
||
db.CreateAllTables();
|
||
db.prepareTablesStatements();
|
||
db.Insert(to_restore);
|
||
db.Disconnect();
|
||
}
|
||
///------------------------------------------------------------------------------------------->>>>>
|
||
public void unpackMessagesAndLog(String packed_messages, String log_in) throws Exception {
|
||
if (packed_messages.length() > 0) {
|
||
int idx = 0;
|
||
String[] splited = packed_messages.split("\\|");
|
||
int numberOfFiles = Integer.parseInt(splited[idx++]);
|
||
for (int i = 0; i < numberOfFiles; ++i) {
|
||
String message_file = Utils_.toW(splited[idx++]); //для ключа.
|
||
int numberOfMessages = Integer.parseInt(splited[idx++]);
|
||
if (!db.files.Data.containsKey(message_file)) {
|
||
throw new PassException("Ошибка при распаковке сообщений: файл: [" +
|
||
message_file +
|
||
"] не найден");
|
||
}
|
||
DBProjectFile messageFile = db.files.Data.get(message_file);
|
||
//0-1-2
|
||
for (int k = 0; k < numberOfMessages; ++k) {
|
||
String[] localSplit = splited[idx++].split(" ");
|
||
int m_type = Integer.parseInt(localSplit[0]);
|
||
int m_line = Integer.parseInt(localSplit[1]);
|
||
int m_group = Integer.parseInt(localSplit[2]);
|
||
String m_value = splited[idx++];
|
||
messageFile.CreateAndAddNewMessage(m_type, m_value, m_line, m_group);
|
||
}
|
||
messageFile.father.db.Update(messageFile);
|
||
}
|
||
}
|
||
Log = log_in;
|
||
Update();
|
||
}
|
||
public boolean hasErrorMessages(String packed_messages) throws Exception {
|
||
if (packed_messages.length() > 0) {
|
||
int idx = 0;
|
||
String[] splited = packed_messages.split("\\|");
|
||
int numberOfFiles = Integer.parseInt(splited[idx++]);
|
||
for (int i = 0; i < numberOfFiles; ++i) {
|
||
int numberOfMessages = Integer.parseInt(splited[idx++]);
|
||
for (int k = 0; k < numberOfMessages; ++k) {
|
||
String[] localSplit = splited[idx++].split(" ");
|
||
int m_type = Integer.parseInt(localSplit[0]);
|
||
if (m_type == 1) {
|
||
UI.Info(packed_messages);
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
public void updateLog(String log_in) throws Exception {
|
||
Log = log_in;
|
||
Update();
|
||
}
|
||
public void updateCompilationOut(String text_in) throws Exception {
|
||
compilation_output = text_in;
|
||
db.Update(this);
|
||
}
|
||
public void updateRunOut(String text_in) throws Exception {
|
||
run_output = text_in;
|
||
db.Update(this);
|
||
}
|
||
public boolean CheckSameStyle(TextLog log) {
|
||
boolean res = false;
|
||
Vector<String> fixed = new Vector<>();
|
||
Vector<String> extended = new Vector<>();
|
||
Vector<String> free = new Vector<>();
|
||
for (String fileName : files_order) {
|
||
DBProjectFile file = db.files.get(fileName);
|
||
switch (file.style) {
|
||
case fixed:
|
||
fixed.add(fileName);
|
||
break;
|
||
case extended:
|
||
extended.add(fileName);
|
||
break;
|
||
case free:
|
||
free.add(fileName);
|
||
break;
|
||
}
|
||
}
|
||
res = (!fixed.isEmpty() && extended.isEmpty() && free.isEmpty()) ||
|
||
(fixed.isEmpty() && !extended.isEmpty() && free.isEmpty()) ||
|
||
(fixed.isEmpty() && extended.isEmpty() && !free.isEmpty());
|
||
if (!res) {
|
||
log.Writeln_(
|
||
"Найдены файлы с различным стилем Fortran:\n" +
|
||
"Фиксированный: " + fixed.size() + "\n" +
|
||
String.join("\n", fixed) + "\n" +
|
||
"Расширенный: " + extended.size() + "\n" +
|
||
String.join("\n", extended) + "\n" +
|
||
"Свободный: " + free.size() + "\n" +
|
||
String.join("\n", free)
|
||
);
|
||
}
|
||
return res;
|
||
}
|
||
public void findVersion_r(Vector<db_project_info> res, File file) {
|
||
for (db_project_info version : versions.values()) {
|
||
if (version.Home.getAbsolutePath().equals(file.getAbsolutePath())) {
|
||
res.add(version);
|
||
} else
|
||
version.findVersion_r(res, file);
|
||
}
|
||
}
|
||
public db_project_info findVersion(File file) {
|
||
Vector<db_project_info> res = new Vector<>();
|
||
findVersion_r(res, file);
|
||
return res.isEmpty() ? null : res.get(0);
|
||
}
|
||
//-
|
||
public void UpdateLoopsCount() {
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
for (ParallelRegion parallelRegion : parallelRegions.Data.values())
|
||
parallelRegion.UpdateLoopsCount();
|
||
}
|
||
public void UpdateFunctionsCount() {
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
for (ParallelRegion parallelRegion : parallelRegions.Data.values())
|
||
parallelRegion.UpdateFunctionsCount();
|
||
}
|
||
public void UpdateArraysCount() {
|
||
numArrays = declaratedArrays.size();
|
||
try {
|
||
db.Update(this);
|
||
} catch (Exception e) {
|
||
Utils_.MainLog.PrintException(e);
|
||
}
|
||
for (ParallelRegion parallelRegion : parallelRegions.Data.values())
|
||
parallelRegion.UpdateArraysCount();
|
||
}
|
||
//имя файла: число совпадений. ( ненулевое)
|
||
public LinkedHashMap<String, Long> getMatches(String keyword_in, boolean registerOn, boolean wholeWord) throws Exception {
|
||
//---------------------------
|
||
LinkedHashMap<String, Long> res = new LinkedHashMap<>();
|
||
for (DBProjectFile file : db.files.Data.values()) {
|
||
if (!file.state.equals(FileState.Excluded)) {
|
||
long matches_count = Utils.findInFile(keyword_in, registerOn, wholeWord, file.file);
|
||
if (matches_count > 0) {
|
||
res.put(file.name, matches_count);
|
||
}
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
public db_project_info CreateVersionsTree() throws Exception {
|
||
File anchestor_file = find_anchestor();
|
||
db_project_info root_ = createVersionsTree_r(anchestor_file);
|
||
return root_;
|
||
}
|
||
public db_project_info createVersionsTree_r(File dir) throws Exception {
|
||
db_project_info result = null;
|
||
File[] files_ = dir.listFiles();
|
||
if (files_ != null) {
|
||
LinkedHashMap<String, File> subdirs = new LinkedHashMap<>();
|
||
//определить проект ли данная папка. и выделить его подпапки.
|
||
for (File file : files_) {
|
||
if (file.isDirectory()) {
|
||
if (file.getName().equals(Constants.data)) {
|
||
result = dir.equals(this.Home) ? this : new db_project_info(dir);
|
||
result.node = new DefaultMutableTreeNode(result); //узел в древе версий.
|
||
//не является нарушением разделения графики и данных. за графику все равно отвечает рендерер.
|
||
} else
|
||
subdirs.put(file.getName(), file);
|
||
}
|
||
}
|
||
//-
|
||
//если проект, то рекурсивно ищем его подверсии.
|
||
if (result != null) {
|
||
Vector<db_project_info> sorted_versions = new Vector<>();
|
||
for (File subdir : subdirs.values()) {
|
||
db_project_info v = createVersionsTree_r(subdir);
|
||
if (v != null) {
|
||
v.parent = result;
|
||
sorted_versions.add(v);
|
||
}
|
||
}
|
||
sorted_versions.sort((o1, o2) -> {
|
||
Long d1 = o1.creationDate;
|
||
Long d2 = o2.creationDate;
|
||
return d1.compareTo(d2);
|
||
});
|
||
//-- добавляем рассортированные версии.
|
||
for (db_project_info version : sorted_versions) {
|
||
result.versions.put(version.name, version);
|
||
result.node.add(version.node);
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
public File find_anchestor() {
|
||
File child = Home;
|
||
//так как мы открыли проект, гарантированно родитель существует.
|
||
File parent = new File(child.getParent());
|
||
while (db_project_info.get_db_file(parent).exists()) {
|
||
child = parent;
|
||
parent = new File(parent.getParent());
|
||
}
|
||
//смягчение требования
|
||
/*
|
||
while (new File(parent, db_project_info.data).exists()) {
|
||
child = parent;
|
||
parent = new File(parent.getParent());
|
||
}
|
||
*/
|
||
return child;
|
||
}
|
||
public void PrintVersions_r() {
|
||
System.out.println(Home.getAbsolutePath());
|
||
for (db_project_info version : versions.values())
|
||
version.PrintVersions_r();
|
||
//--
|
||
}
|
||
public String getVersionTooltip() {
|
||
return description;
|
||
}
|
||
//---
|
||
public void gen_variants_vectors() {
|
||
//заполнить первыми тройками чтобы рекурсия работала. берем последний шаблон.
|
||
Vector<Vector<BigInteger>> res = templates.get(templates.size() - 1).get_triples(true);
|
||
if (templates.size() > 1)
|
||
gen_rec(templates, res, templates.size() - 2);
|
||
//теперь надо создать из этого списка варианты.
|
||
for (Vector<BigInteger> vector : res) {
|
||
ParallelVariant variant = new ParallelVariant(this, vector);
|
||
// if (!parallelVariants.containsKey(variant.UniqKey))
|
||
parallelVariants.put(variant.UniqKey, variant);
|
||
}
|
||
}
|
||
//---
|
||
public int getVariantsCoverageCount() {
|
||
if (templates.isEmpty()) return 0;
|
||
int res = 0;
|
||
//--
|
||
// тут сортируем по размеру.
|
||
Vector<ProjectArray> sortedSizeTemplates = new Vector<>(templates);
|
||
sortedSizeTemplates.sort((o1, o2) -> o2.dimSize - o1.dimSize);
|
||
//--
|
||
ProjectArray mainTemplate = sortedSizeTemplates.get(0);
|
||
for (long mVarId : mainTemplate.get_varIDs(false)) {
|
||
String main_binary = mainTemplate.get_binary(mVarId);
|
||
boolean variantEnabled = true;
|
||
for (int i = 1; i < sortedSizeTemplates.size(); ++i) {
|
||
ProjectArray template = sortedSizeTemplates.get(i);
|
||
String template_binary = (mainTemplate.dimSize > template.dimSize) ?
|
||
main_binary.substring(0, template.dimSize) :
|
||
main_binary;
|
||
//сконвертировать из двоичной в long, чтобы получить varId
|
||
long varID = Long.parseLong(template_binary, 2);
|
||
//-- проверить на пригодность этот самый varID
|
||
if (!template.checkVarID(varID, false)) {
|
||
variantEnabled = false;
|
||
break;
|
||
}
|
||
}
|
||
if (variantEnabled) res++;
|
||
}
|
||
return res;
|
||
}
|
||
//минимальное покрытие.
|
||
public void gen_variants_coverage() {
|
||
Vector<Vector<BigInteger>> res = new Vector<>();
|
||
//1. найти шаблон максимального размера. для этого получаем сортировку из списка по убыванию.
|
||
Vector<ProjectArray> sortedBySizeTemplates = new Vector<>(templates);
|
||
sortedBySizeTemplates.sort((o1, o2) -> o2.dimSize - o1.dimSize);
|
||
if (!sortedBySizeTemplates.isEmpty()) {
|
||
ProjectArray mainTemplate = sortedBySizeTemplates.get(0);
|
||
Vector<Vector<BigInteger>> main_template_triples = mainTemplate.get_triples(false);
|
||
//для каждой тройки от главного (максимального) шаблона, берем по одной подходящей от остальных.
|
||
for (Vector<BigInteger> triple : main_template_triples) {
|
||
//двоичное представление максимального шаблона. 1111
|
||
String main_binary = mainTemplate.get_binary(triple.get(1).longValueExact());
|
||
boolean variantEnabled = true;
|
||
Vector<BigInteger> variantVector = new Vector<>(triple);
|
||
//перебор остальных шаблонов
|
||
for (int i = 1; i < sortedBySizeTemplates.size(); ++i) {
|
||
ProjectArray template = sortedBySizeTemplates.get(i);
|
||
String template_binary = (mainTemplate.dimSize > template.dimSize) ?
|
||
main_binary.substring(0, template.dimSize) :
|
||
main_binary;
|
||
//сконвертировать из двоичной в long, чтобы получить varId
|
||
long varID = Long.parseLong(template_binary, 2);
|
||
//-- проверить на пригодность этот самый varID
|
||
if (template.checkVarID(varID, false)) {
|
||
//вар ИД подошел, составляем вектор для очередного варианта.
|
||
for (BigInteger regID : template.regIDs) //для всех областей
|
||
{
|
||
variantVector.add(template.address);
|
||
variantVector.add(BigInteger.valueOf(varID));
|
||
variantVector.add(regID);
|
||
}
|
||
} else {
|
||
//вар ид не подошел. значит. этого варианта, не будет вообще. нужно идти к следующей тройке лидера.
|
||
variantEnabled = false;
|
||
break;
|
||
}
|
||
}
|
||
if (variantEnabled) {
|
||
res.add(variantVector);
|
||
}
|
||
}
|
||
}
|
||
//--
|
||
//теперь надо создать из этого списка варианты.
|
||
for (Vector<BigInteger> vector : res) {
|
||
ParallelVariant variant = new ParallelVariant(this, vector);
|
||
parallelVariants.put(variant.UniqKey, variant);
|
||
}
|
||
}
|
||
public ProjectArray getTemplateByAddress(BigInteger address_in) {
|
||
for (ProjectArray template : templates) {
|
||
if (template.address.equals(address_in))
|
||
return template;
|
||
}
|
||
return null;
|
||
}
|
||
public void SelectAllVersions(boolean b) {
|
||
this.Select(b && !this.IsMCopy());
|
||
for (db_project_info version : versions.values())
|
||
version.SelectAllVersions(b);
|
||
}
|
||
private void getSelectedVersionsForDeletionR(Index count, Vector<db_project_info> target, boolean needs_versions) {
|
||
if (needs_versions) {
|
||
if (this.isSelected()) {
|
||
target.add(this);
|
||
count.Inc();
|
||
//версия отмечена. подверсии больше не нужны.
|
||
for (db_project_info version : versions.values()) {
|
||
version.getSelectedVersionsForDeletionR(count, null, false);
|
||
}
|
||
} else {
|
||
// не отмечена. проверяем дочерние.
|
||
for (db_project_info version : versions.values()) {
|
||
version.getSelectedVersionsForDeletionR(count, target, true);
|
||
}
|
||
}
|
||
} else {
|
||
//просто считаем все без разбору, так как это подверсии уже отмеченной версии.
|
||
count.Inc();
|
||
for (db_project_info version : versions.values()) {
|
||
version.getSelectedVersionsForDeletionR(count, null, false);
|
||
}
|
||
}
|
||
}
|
||
public int getSelectedVersionsForDeletion(Vector<db_project_info> target) {
|
||
Index count = new Index();
|
||
getSelectedVersionsForDeletionR(count, target, true);
|
||
return count.getValue();
|
||
}
|
||
public void getSelectedVersions(Vector<db_project_info> target) {
|
||
if (this.isSelected())
|
||
target.add(this);
|
||
for (db_project_info version : versions.values())
|
||
version.getSelectedVersions(target);
|
||
}
|
||
public String getLocalName() {
|
||
//требует отображения рута. без него работать не будет.
|
||
if (Global.mainModule.HasRoot())
|
||
return Home.getAbsolutePath().substring(Global.mainModule.getRoot().Home.getParentFile().getAbsolutePath().length() + 1);
|
||
else return Home.getName();
|
||
}
|
||
public void SelectAllFiles(boolean b) {
|
||
for (DBProjectFile file : db.files.Data.values())
|
||
file.Select(b);
|
||
}
|
||
public ProjectFiles_json filesToJson() {
|
||
ProjectFiles_json res = new ProjectFiles_json();
|
||
LinkedHashMap<LanguageName, Vector<DBProjectFile>> programs = getPrograms();
|
||
if (programs.containsKey(this.languageName))
|
||
res.files.addAll(programs.get(this.languageName));
|
||
return res;
|
||
}
|
||
public boolean hasSubdirectories() {
|
||
subdirectories.clear();
|
||
getSubdirectoriesR(Home);
|
||
return !subdirectories.isEmpty();
|
||
}
|
||
public boolean checkSubdirectories(TextLog Log) {
|
||
if (hasSubdirectories()) {
|
||
Log.Writeln_("Проект содержит вложенные папки!");
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
}
|