VisualSapfor/src/_VisualDVM/Utils.java

package _VisualDVM;
import Common.Passes.PassException;
import Common.Utils.Index;
import Common.Utils.StringTemplate;
import Common.Utils.TextLog;
import Common.Utils.Utils_;
import Common.Visual.UI;
import Common.Visual.Windows.Dialog.VFileChooser_;
import _VisualDVM.GlobalData.Tasks.TaskState;
import _VisualDVM.ProjectData.Files.DBProjectFile;
import _VisualDVM.ProjectData.Project.db_project_info;
import javafx.util.Pair;
import org.apache.commons.io.FileUtils;

import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.file.*;
import java.security.MessageDigest;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.IntStream;
public class Utils {
    public static boolean isLinuxSystemCommand(String text) {
        for (String command : Constants.linux_system_commands) {
            if (text.equalsIgnoreCase(command)) return true;
        }
        return false;
    }
    public static String MFVar(Object o) {
        return "$(" + o.toString() + ")";
    }
    public static String ReadAllText(File file) {
        try {
            return new String(Files.readAllBytes(file.toPath()));
        } catch (Exception e) {
            Utils_.MainLog.PrintException(e);
        }
        return "";
    }
    public static void CleanDirectory(File dir) {
        if (dir.exists() && dir.isDirectory()) {
            File[] files = dir.listFiles();
            if (files != null) {
                for (File f : files) {
                    try {
                        Utils_.forceDeleteWithCheck(f);
                    } catch (Exception e) {
                        Utils_.MainLog.PrintException(e);
                    }
                }
            }
        }
    }
    public static void WriteToFile(File f, String text) throws IOException {
        Files.write(
                f.toPath(),
                text.getBytes(),
                StandardOpenOption.CREATE,
                StandardOpenOption.TRUNCATE_EXISTING);
    }
    // http://java-online.ru/blog-archive.xhtml
    public static void getFilesCountR(File dir, Index res) {
        for (File f : dir.listFiles()) {
            res.Inc();
            if (f.isDirectory())
                getFilesCountR(f, res);
        }
    }
    public static int getFilesCount(File dir) {
        Index res = new Index();
        getFilesCountR(dir, res);
        return res.getValue();
    }
    public static File CreateTempResourceFile(String res_name) throws Exception {
        URL u = (Utils.class.getResource("/files/" + res_name));
        InputStream i = u.openStream();
        Path p = Paths.get(Global.TempDirectory.getAbsolutePath(), Utils_.getDateName(res_name));
        Files.copy(i, p, StandardCopyOption.REPLACE_EXISTING);
        return p.toFile();
    }
    public static void CreateResourceFile(String res_name, File dst) throws Exception {
        URL u = (Utils.class.getResource("/files/" + res_name));
        InputStream i = u.openStream();
        Files.copy(i, dst.toPath(), StandardCopyOption.REPLACE_EXISTING);
    }
    //просто дать объект под файл с сгенерированным именем System.out.println
    public static File CreateTempFile(String name, String text) throws IOException {
        File res = getTempFileName(name);
        WriteToFile(res, text);
        return res;
    }
    public static File CreateTempFile(String name, String ext, String text) throws IOException {
        File res = getTempFileName(name, ext);
        WriteToFile(res, text);
        return res;
    }
    public static File getTempFileName(String name, String ext) {
        return Paths.get(System.getProperty("user.dir"), "Temp", Utils_.getDateName(name) + (ext.isEmpty() ? "" : ("." + ext))).toFile();
    }
    public static File getTempFileName(String name) {
        return getTempFileName(name, "");
    }
    public static boolean isAnchestor(File child, File anchestor) {
        return child.getAbsolutePath().startsWith(anchestor.getAbsolutePath() + (Utils_.isWindows() ? "\\" : "/"));
    }
    //при условии что это точно его предок
    public static String getRelativeAddress(File file, File anchestor) {
        return file.getAbsolutePath().substring(anchestor.getAbsolutePath().length() + 1);
    }
    //для переименования/добавления новых файлов.
    public static boolean validateFileShortNewName(String name, TextLog Log) {
        boolean res = true;
        if (name.isEmpty()) {
            Log.Writeln_("Имя файла не может быть пустым");
            res = false;
        }
        if (Utils_.ContainsCyrillic(name)) {
            Log.Writeln_("Имя файла не может содержать кириллицу");
            res = false;
        }
        if (Utils_.ContainsForbiddenName(name)) {
            Log.Writeln_("Имя файла не может содержать запрещённых символов\n" + Utils_.printAllForbiddenCharacters());
            res = false;
        }
        return res;
    }
    //корень сюда гарантированно не попадает. значит можно запрещать двоеточие.
    //идет по всем уровням файлов
    public static boolean validateProjectFile(File file, TextLog Log) {
        String name = file.getName();
        if (Utils_.ContainsCyrillic(name) || Utils_.ContainsForbiddenName(name)) {
            Log.Writeln_(file.getAbsolutePath());
            return false;
        }
        return true;
    }
    //входной параметр всегда папка.
    public static void validateProjectFolder_r(File dir, TextLog Log) {
        validateProjectFile(dir, Log);
        File[] files = dir.listFiles();
        if (files != null)
            for (File file : files) {
                if (file.isDirectory())
                    validateProjectFolder_r(file, Log);
                else validateProjectFile(file, Log);
            }
    }
    public static boolean validateProjectFolder(File dir, TextLog Log) {
        TextLog files_list = new TextLog();
        String[] filesLines = files_list.text.split("\n");
        validateProjectFolder_r(dir, files_list);
        if (!files_list.isEmpty())
            Log.Writeln_("Имена " + filesLines.length + " файлов/подпапок содержат запрещённые символы " +
                    Utils_.printAllForbiddenCharacters() +
                    "или кириллицу");
        //нужно проверить корень на наличие хоть одной программы.
        return Log.isEmpty();
    }
    public static void GetVertices(float R, float r, float x0, float y0, int n, float phi) {
        boolean inner = false;
        for (int i = 0; i < 2 * n; i++) {
            float rad = inner ? r : R;
            System.out.println("x=" + (x0 + rad * Math.cos(phi + Math.PI * i / n)));
            System.out.println("y=" + (y0 + rad * Math.sin(phi + Math.PI * i / n)));
            inner = !inner;
        }
    }
    public static String md5Custom(String st) {
        MessageDigest messageDigest = null;
        byte[] digest = new byte[0];
        try {
            messageDigest = MessageDigest.getInstance("MD5");
            messageDigest.reset();
            messageDigest.update(st.getBytes());
            digest = messageDigest.digest();
        } catch (Exception e) {
            // тут можно обработать ошибку
            // возникает она если в передаваемый алгоритм в getInstance(,,,) не существует
            Utils_.MainLog.PrintException(e);
        }
        BigInteger bigInt = new BigInteger(1, digest);
        String md5Hex = bigInt.toString(16);
        while (md5Hex.length() < 32) {
            md5Hex = "0" + md5Hex;
        }
        return md5Hex;
    }
    public static void renameSubdirs_r(DefaultMutableTreeNode node, File old_anchestor, File new_anchestor) {
        if (node.getUserObject() instanceof File) {
            File old_file = (File) node.getUserObject();
            String relative_name = old_file.getAbsolutePath().substring(old_anchestor.getAbsolutePath().length() + 1);
            File new_file = Paths.get(new_anchestor.getAbsolutePath(), relative_name).toFile();
            node.setUserObject(new_file);
            for (int i = 0; i < node.getChildCount(); ++i) {
                renameSubdirs_r((DefaultMutableTreeNode) node.getChildAt(i), old_anchestor, new_anchestor);
            }
        }
    }
    public static Socket createClientSocket(InetAddress address, int port, int timeout) throws Exception {
        Socket socket = new Socket();
        socket.setSoTimeout(timeout);
        socket.connect(new InetSocketAddress(address, port), timeout);
        return socket;
    }
    public static void CreateResourceFile(File dst) throws Exception {
        URL u = (Utils.class.getResource("/files/" + dst.getName()));
        InputStream i = u.openStream();
        Files.copy(i, dst.toPath(), StandardCopyOption.REPLACE_EXISTING);
    }
    public static void getFilesByExtensions_r(File dir, Vector<File> res, String... extensions) {
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isFile()) {
                    String file_extension = Utils_.getExtension(file);
                    for (String ext : extensions) {
                        if (file_extension.equalsIgnoreCase(ext)) {
                            res.add(file);
                        }
                    }
                }
                if (file.isDirectory())
                    getFilesByExtensions_r(file, res, extensions);
            }
        }
    }
    //----->>
    public static void deleteFilesByExtensions(File dir, String... extensions) throws Exception {
        Vector<File> res = new Vector<>();
        Utils.getFilesByExtensions_r(dir, res, extensions);
        for (File src : res)
            Utils_.forceDeleteWithCheck(src);
    }
    //----->>
    //--процессы-------------------------------------------------->>>>>
    //<editor-fold desc="создание скрипта">
    public static Process startScript(File scriptDirectory, File targetDirectory, String name, String scriptText, Map<String, String> envs) throws Exception {
        //->
        File scriptFile = createScript(scriptDirectory, targetDirectory, name, scriptText);
        ProcessBuilder procBuilder = new ProcessBuilder(scriptFile.getAbsolutePath());
        procBuilder.directory(scriptDirectory);
        procBuilder.redirectErrorStream(true);
        if (envs != null) {
            for (String envName : envs.keySet()) {
                procBuilder.environment().put(envName, envs.get(envName));
            }
        }
        return procBuilder.start();
    }
    public static Process startScript(File scriptDirectory, File targetDirectory, String name, String scriptText) throws Exception {
        return startScript(scriptDirectory, targetDirectory, name, scriptText, null);
    }
    public static File createScript(File scriptDirectory, File targetDirectory, String name, String scriptText) throws Exception {
        //->
        File scriptFile = Paths.get(scriptDirectory.getAbsolutePath(), name + (Utils_.isWindows() ? ".bat" : "")).toFile();
        FileUtils.write(scriptFile, "cd " + Utils_.DQuotes(targetDirectory.getAbsolutePath()) + "\n" + scriptText);
        if (!scriptFile.setExecutable(true)) throw new PassException("Не удалось создать исполняемый файл для скрипта");
        return scriptFile;
    }
    //</editor-fold>
    //<editor-fold desc="чтение вывода процесса">
    public static String readLine(Process process) throws Exception {
        InputStream stdout = process.getInputStream();
        InputStreamReader isrStdout = new InputStreamReader(stdout);
        BufferedReader brStdout = new BufferedReader(isrStdout);
        String line = brStdout.readLine();
        return line;
    }
    public static Vector<String> readAllLines(Process process) throws Exception {
        Vector<String> output = new Vector<>();
        InputStream stdout = process.getInputStream();
        InputStreamReader isrStdout = new InputStreamReader(stdout);
        BufferedReader brStdout = new BufferedReader(isrStdout);
        String line;
        while ((line = brStdout.readLine()) != null) {
            output.add(line);
        }
        return output;
    }
    public static String readAllOutput(Process process) throws Exception {
        return String.join("\n", readAllLines(process));
    }
    //</editor-fold>
    public static String extractHeaderName(String line) {
        String tline = line.trim().toLowerCase();
        if (tline.startsWith("include")) {
            String[] data = tline.split("'");
            return data.length > 1 ? data[1] : null;
        }
        return null;
    }
    public static String getRelativeName(File dir, File file) {
        return
                file.getAbsolutePath().startsWith(dir.getAbsolutePath()) ?
                        file.getAbsolutePath().substring(dir.getAbsolutePath().length() + 1).replace('/', '\\') :
                        file.getAbsolutePath()
                ;
    }
    public static boolean containsLine(Vector<String> list, String line, int max_index) {
        int last_index = -1;
        for (int i = 0; i < list.size(); ++i)
            if (list.get(i).equals(line)) last_index = i;
        return (last_index >= max_index);
    }
    public static String compareTexts(String master, String slave) {
        Vector<String> lines = new Vector<>(Arrays.asList(master.split("\n")));
        Vector<String> slavelines = new Vector<>(Arrays.asList(slave.split("\n")));
        Vector<String> t2 = new Vector<>();
        int old_j = 0;
        int j = 0;
        for (int i = 0; i < lines.size(); ++i) {
            if (containsLine(slavelines, lines.get(i), old_j)) {
                for (int k = old_j; k < slavelines.size(); ++k) {
                    j = k;
                    if (lines.get(i).equals(slavelines.get(k))) {
                        j++;
                        t2.add(slavelines.get(k));
                        break;
                    } else
                        t2.add("+ " + slavelines.get(k));
                }
                old_j = j;
            } else {
                //строки гарантированно нет.
                t2.add("- " + lines.get(i));
            }
        }
        //теперь граничное условие. если первый файл кончился а второй нет, его остаток это добавление.
        for (int i = j; i < slavelines.size(); ++i)
            t2.add("+ " + slavelines.get(i));
        return String.join("\n", t2);
    }
    public static int getHalfKernels() {
        int countCores = 1;
        if (Runtime.getRuntime().availableProcessors() > 1)
            countCores = Runtime.getRuntime().availableProcessors() / 2;
        return countCores;
    }
    public static int getMaxKernels() {
        return Math.max(2, Runtime.getRuntime().availableProcessors());
    }
    public static int getMatrixProcessors(String matrix) {
        if (matrix.trim().isEmpty()) return 1;
        String[] data = matrix.split(" ");
        int res = 1;
        for (String d : data)
            res *= Integer.parseInt(d);
        return res;
    }
    public static int getCTestMaxDim(File test) {
        int fileMax = 0;
        final String prefix = "#pragma dvm array distribute";
        int n = 0;
        try {
            for (String line : FileUtils.readLines(test, Charset.defaultCharset())) {
                //  #pragma dvm array distribute[block][block], не важно
                String packedLine = Utils_.removeCharacters(Utils_.removeRedundantSpaces(line).toLowerCase(), "\n", "\r", "\t");
                if (packedLine.startsWith(prefix)) {
                    packedLine = packedLine.substring(prefix.length());
                    boolean bracketOpen = false;
                    int pragmaMax = 0;
                    String distr = "";
                    for (int i = packedLine.indexOf('['); i < packedLine.length(); ++i) {
                        char c = packedLine.charAt(i);
                        if (bracketOpen) {
                            if (c == ']') {
                                bracketOpen = false;
                                if (distr.equals("block"))
                                    pragmaMax++;
                                distr = "";
                            } else {
                                distr += c;
                            }
                        } else {
                            if (c == '[') {
                                bracketOpen = true;
                            } else {
                                break;
                            }
                        }
                    }
                    fileMax = Math.max(fileMax, pragmaMax);
                }
                ++n;
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return fileMax;
    }
    public static int getCProjectMaxDim(db_project_info project) {
        int res = 0;
        for (DBProjectFile file : project.db.files.Data.values()) {
            if (file.isActiveProgram())
                res = Math.max(res, getCTestMaxDim(file.file));
        }
        return res;
    }
    public static boolean isTimeout(long startDate, long maxtime_sec) {
        Date now = new Date();
        long delta = (now.getTime() - startDate) / 1000;
        return (delta > maxtime_sec);
    }
    //https://translated.turbopages.org/proxy_u/en-ru.ru.596e2df7-62fd38bb-6b4aad49-74722d776562/https/stackoverflow.com/questions/34658054/finding-whole-word-only-in-java-string-search
    public static long findInFile(String keyword_in, boolean registerOn, boolean wholeWord, File file) {
        if (keyword_in.isEmpty()) return 0;
        long res = 0;
        try {
            String text = FileUtils.readFileToString(file);
            String keyword = keyword_in;
            //-->>
            if (!registerOn) {
                text = text.toUpperCase();
                keyword = keyword.toUpperCase();
            }
            String regex = wholeWord ? "\\b" + keyword + "\\b" : keyword;
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(text);
            while (matcher.find()) res++;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return res;
    }
    public static void addEmptyLines(Vector<String> lines, int num) {
        IntStream.range(0, num).mapToObj(i -> "").forEach(lines::add);
    }
    protected static boolean isSource(File file) {
        if (file.isFile()) {
            String extension = Utils_.getExtension(file).toLowerCase();
            switch (extension) {
                case "f":
                case "fdv":
                case "for":
                case "f77":
                case "f90":
                    //   case "fh":
                case "c":
                case "cdv":
                case "cpp":
                    //   case "h":
                    return true;
            }
        }
        return false;
    }
    public static boolean containsSource(File folder, boolean question) {
        File visualiserData = new File(folder, Constants.data);
        if (visualiserData.exists()) {
            return true;
        }     //есть папка с данными, значит его уже открывали, все хорошо.
        File[] files = folder.listFiles();
        Vector<File> sources = new Vector<>();
        if (files != null) {
            for (File file : files) {
                if (isSource(file)) {
                    sources.add(file);
                }
            }
        }
        if (sources.isEmpty()) {
            if (question) return UI.Question("Папка " + Utils_.Brackets(folder.getName()) + "\n" +
                    "не содержит ни одного файла, распознанного как поддерживаемый код\n" +
                    "Всё равно открыть её как проект");
            else return false;
        } else return true;
    }
    public static void Kill(String PID, boolean force) {
        if (!PID.isEmpty()) {
            String killCommand =
                    force ? Utils_.isWindows() ? "taskkill /PID " + Utils_.DQuotes(PID) + " /F /T" : "kill -9 " + Utils_.DQuotes(PID) :
                            Utils_.isWindows() ? "taskkill /PID " + Utils_.DQuotes(PID) : "kill -2 " + Utils_.DQuotes(PID);
            System.out.println(killCommand);
            try {
                Process killer = Utils.startScript(Global.TempDirectory, Global.TempDirectory, "killer", killCommand);
                killer.waitFor();
                System.out.println(Utils.readAllOutput(killer));
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
    public static boolean isFunctionName(String name) {
        if (name.isEmpty())
            return false;
        char[] letters = name.toCharArray();
        if (!(Utils_.isEnglishLetter(letters[0]) || letters[0] == '_')) {
            return false;
        }
        //---
        for (int i = 1; i < letters.length; ++i) {
            if (!(Utils_.isEnglishLetter(letters[i]) || letters[i] == '_' || Utils_.isIntegerValue(String.valueOf(letters[i])))) {
                return false;
            }
        }
        return true;
    }
    public static void keepNewFiles(File directory, int count) throws Exception {
        if (count > 0) {
            File[] old_ = directory.listFiles(pathname -> pathname.isFile());
            if (old_ != null) {
                Vector<File> old = new Vector<>();
                Collections.addAll(old, old_);
                old.sort((o1, o2) -> Long.compare(o2.lastModified(), o1.lastModified()));
                for (int i = count - 1; i < old.size(); ++i) {
                    File file = old.get(i);
                    FileUtils.forceDelete(file);
                }
            }
        }
    }
    public static boolean isParallelVersionName(String name) {
        char[] chars = name.toLowerCase().toCharArray();
        if ((chars.length > 1) && (chars[0] == 'p')) {
            for (int i = 1; i < chars.length; ++i) {
                if (!Character.isDigit(chars[i])) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
    public static boolean isCrushedLine(String line) {
        String l_line = line.toLowerCase();
        for (String crushed : Constants.crushed_cases)
            if (l_line.contains(crushed))
                return true;
        return false;
    }
    public static boolean isCrushed(List<String> output_lines, List<String> errors_lines) {
        return output_lines.stream().anyMatch(Utils::isCrushedLine) || errors_lines.stream().anyMatch(Utils::isCrushedLine);
    }
    public static Pair<TaskState, Integer> analyzeCorrectness(List<String> lines) {
        int complete = 0;
        int errors = 0;
        int total = 0;
        int starts = 0;
        int ends = 0;
        for (String s : lines) {
            String line = s.toUpperCase();
            if (line.contains("COMPLETE")) {
                complete++;
                total++;
            } else if (line.contains("ERROR")) {
                errors++;
                total++;
            } else if (line.contains("START")) {
                starts++;
            } else if (line.contains("END")) {
                ends++;
            }
        }
        TaskState state = TaskState.Finished;
        if (starts == 0 || ends == 0) {
            state = TaskState.WrongTestFormat;
       } else
       if (errors > 0) {
            state = TaskState.DoneWithErrors;
        } else {
            state = TaskState.Done;
        }
        return new Pair<>(state, (int) ((((double) complete) / total) * 100));
    }
    public static Pair<TaskState, Integer> analyzePerformance(List<String> lines) {
        StringTemplate stringTemplate = new StringTemplate("Verification =", "");
        for (String line : lines) {
            String param = stringTemplate.check_and_get_param(line);
            if (param != null) {
                switch (param) {
                    case "SUCCESSFUL":
                        return new Pair<>(TaskState.Done, 100);
                    case "UNSUCCESSFUL":
                        return new Pair<>(TaskState.DoneWithErrors, 0);
                    default:
                        break;
                }
            }
        }
        return new Pair<>(TaskState.WrongTestFormat, 0);
    }
    public static double parseCleanTime(String output) {
        double res = 0.0;
        StringTemplate template = new StringTemplate("Time in seconds =", "");
        String p = template.check_and_get_param(output);
        try {
            if (p != null) res = Double.parseDouble(p);
        } catch (Exception ex) {
            Utils_.MainLog.PrintException(ex);
        }
        return res;
    }
    public static void RestoreSelectedDirectory(VFileChooser_ directoryChooser) {
        String last_dir_home = Global.normalProperties.ProjectsSearchDirectory;
        if (!last_dir_home.isEmpty())
            directoryChooser.SetCurrentDirectory(last_dir_home);
    }
    public static void ClearProjectData(File project_home) throws Exception {
        Utils.deleteFilesByExtensions(project_home, "dep", "proj");
        File project_data = new File(project_home, Constants.data);
        if (project_data.exists())
            FileUtils.forceDelete(project_data);
    }
    //--
    public static boolean isVersion(File directory) throws Exception {
        return new File(directory, Constants.data).exists();
    }
    public static boolean checkFileCreation(File file) {
        for (int i = 1; i <= 10; ++i) {
            if (file.exists()) return true;
            else Utils_.sleep(1000);
        }
        return false;
    }
    public static void createEmptyFile(String name) {
        File file = new File(name);
        try {
            FileUtils.writeStringToFile(file, "");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    public static Pair<Vector<String>, Vector<String>> getFortranLines(String text) {
        Vector<String> lines = new Vector<>();
        Vector<String> visible_lines = new Vector<>();
        //1.прочитать весь текст.
        char[] chars = text.toCharArray();
        //по символам получить строки.
        char c = 0; //текущий символ
        int i = 0; //индекс текущего символа.
        StringBuilder line = new StringBuilder(); //текущая строка
        StringBuilder v_line = new StringBuilder(); //текущая строка
        while (i < chars.length) {
            c = chars[i];
            //System.out.print("`"+c+"`");
            ++i;
            switch (c) {
                case '\r': //возврат каретки, игнор
                    break;
                case ' ':
                case '\t':
                    if (Global.normalProperties.SpacesOn) line.append(c);
                    v_line.append(c);
                    break;
                case '\n': //конец строки
                    if (Global.normalProperties.FortranWrapsOn) {
                        //оракул. лезем в начало следующей строки
                        //и анализируем первые 5 символов
                        boolean hasWrap = false;
                        int wi;
                        //------
                        //с нуля потому что и уже увеличено.
                        for (int j = 0; (j < 6) && ((wi = i + j) < chars.length); ++j) {
                            char s = chars[wi];
                            if ((j == 0) && ((s == 'c') || (s == 'C') || (s == '!'))) {
                                break;
                            }
                            if ((j > 0) && (j < 5) && (s == '!')) {
                                break;
                            }
                            if ((j == 5) && (s != ' ')) {
                                hasWrap = true;
                                i = wi + 1;
                                break;
                            }
                        }
                        //-----
                        if (hasWrap)
                            break;
                    }
                    //добавление строки в результат.
                    if ((line.length() > 0) || Global.normalProperties.EmptyLinesOn
                        //     Global.db.settings.get(SettingName.SpacesOn).toBoolean()
                    ) {
                        lines.add(line.toString());
                        visible_lines.add(v_line.toString());
                    }
                    //сброс
                    line = new StringBuilder();
                    v_line = new StringBuilder();
                    break;
                default:
                    line.append(c);
                    v_line.append(c);
                    break;
            }
        }
        if ((i > 0) && (c != '\n')) {
            //строка оборвалась на EOF
            //добавление строки в результат.
            if ((line.length() > 0) || Global.normalProperties.EmptyLinesOn
                //     && Global.db.settings.get(SettingName.SpacesOn).toBoolean()
            ) {
                lines.add(line.toString());
                visible_lines.add(v_line.toString());
            }
        }
        return new Pair<>(lines, visible_lines);
    }
    public static boolean CompareLines(String line1_raw, String line2_raw) {
        String line1 = line1_raw;
        String line2 = line2_raw;
        if (!Global.normalProperties.RegisterOn) {
            line1 = line1.toUpperCase();
            line2 = line2.toUpperCase();
        }
        if (!Global.normalProperties.SpacesOn) {
            line1 = Utils_.removeCharacters(line1, " ", "\t");
            line2 = Utils_.removeCharacters(line2, " ", "\t");
        }
        return line1.equals(line2);
    }
    public static boolean Contains(Vector<String> list, String line, int max_index) {
        int last_index = -1;
        for (int i = 0; i < list.size(); ++i)
            if (CompareLines(list.get(i), line)) last_index = i;
        return (last_index >= max_index);
    }
    public static boolean compareFortranTexts(String text1, String text2) {
        Pair<Vector<String>, Vector<String>> p1 = getFortranLines(text1);
        Pair<Vector<String>, Vector<String>> p2 = getFortranLines(text2);
        Vector<String> lines1 = p1.getKey();
        Vector<String> lines2 = p2.getKey();
        if (lines1.size() != lines2.size())
            return false;
        for (int i = 0; i < lines1.size(); ++i) {
            if (!CompareLines(lines1.get(i), lines2.get(i)))
                return false;
        }
        return true;
    }
    //--
    private static void get_newest_file_date_r(File dir, Vector<Long> dates) {
        Vector<File> files = new Vector(Arrays.asList(dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isFile();
            }
        })));
        if (!files.isEmpty()) {
            files.sort(new Comparator<File>() {
                @Override
                public int compare(File o1, File o2) {
                    return Long.compare(o1.lastModified(), o2.lastModified());
                }
            }.reversed());
            dates.add(files.firstElement().lastModified());
        }
        //--
        Vector<File> subdirs = new Vector(Arrays.asList(dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isDirectory();
            }
        })));
        if (!subdirs.isEmpty()) {
            for (File subdir : subdirs)
                get_newest_file_date_r(subdir, dates);
        }
    }
    public static long getNewestFileDate(File dir) {
        Vector<Long> dates = new Vector<>();
        get_newest_file_date_r(dir, dates);
        Collections.sort(dates);
        if (dates.isEmpty()) {
            dates.add(dir.lastModified());
        }
        return dates.firstElement();
    }
}