Перенос.

src/ProjectData/SapforData/Arrays/ArrayDecl.java

@@ -0,0 +1,18 @@
+package ProjectData.SapforData.Arrays;
+import Common.Utils.Utils;
+import ProjectData.Files.DBProjectFile;
+import ProjectData.SapforData.FileObjectWithMessages;
+// это то что отображается в боковом графе файла. не путать с сапфоровским ProjectArray
+public class ArrayDecl extends FileObjectWithMessages {
+    public String array_name;
+    public ArrayLocation array_loc;
+    public ArrayDecl(String array_name_in, ArrayLocation array_loc_in, DBProjectFile father_in, int lineNum_in) {
+        super(father_in, lineNum_in);
+        array_name = array_name_in;
+        array_loc = array_loc_in;
+    }
+    @Override
+    public String Description() {
+        return array_loc.getDescription() + " массив " + Utils.Brackets(array_name);
+    }
+}

src/ProjectData/SapforData/Arrays/ArrayLocation.java

@@ -0,0 +1,40 @@
+package ProjectData.SapforData.Arrays;
+public enum ArrayLocation {
+    local, common, module, parameter, structure, local_save, unknown;
+    public static ArrayLocation fromInt(int i) {
+        switch (i) {
+            case 0:
+                return local;
+            case 1:
+                return common;
+            case 2:
+                return module;
+            case 3:
+                return parameter;
+            case 4:
+                return structure;
+            case 5:
+                return local_save;
+            default:
+                return unknown;
+        }
+    }
+    public String getDescription() {
+        switch (this) {
+            case local:
+                return "локальный";
+            case common:
+                return "глобальный";
+            case module:
+                return "модульный";
+            case parameter:
+                return "параметр";
+            case structure:
+                return "структура";
+            case local_save:
+                return "локальный сохраняемый";
+            default:
+                return this.toString();
+        }
+    }
+}

src/ProjectData/SapforData/Arrays/ArrayState.java

@@ -0,0 +1,24 @@
+package ProjectData.SapforData.Arrays;
+import javax.swing.*;
+import java.net.URL;
+public enum ArrayState {
+    Selected, None, SpfPrivate, IOPrivate, Unknown;
+    public static ArrayState fromInt(int i) {
+        switch (i) {
+            case 0:
+                return Selected;
+            case 1:
+                return None;
+            case 2:
+                return SpfPrivate;
+            case 3:
+                return IOPrivate;
+            default:
+                return Unknown;
+        }
+    }
+    public ImageIcon GetIcon() {
+        URL imageUrl = getClass().getResource("/icons/Arrays/" + this + ".png");
+        return new ImageIcon(imageUrl);
+    }
+}

src/ProjectData/SapforData/Arrays/ArraysSet.java

@@ -0,0 +1,82 @@
+package ProjectData.SapforData.Arrays;
+import Common.Current;
+import Common.Database.DataSet;
+import Common.Global;
+import Common.UI.DataSetControlForm;
+import GlobalData.Settings.SettingName;
+import Visual_DVM_2021.Passes.PassCode_2021;
+import Visual_DVM_2021.Passes.Pass_2021;
+
+import java.util.Vector;
+
+import static Common.UI.Tables.TableEditors.EditorHyperlinks;
+import static Common.UI.Tables.TableRenderers.RendererHiddenList;
+import static Common.UI.Tables.TableRenderers.RendererHyperlinks;
+public class ArraysSet extends DataSet<Long, ProjectArray> {
+    public ArraysSet() {
+        super(Long.class, ProjectArray.class);
+    }
+    @Override
+    public String getSingleDescription() {
+        return "массив";
+    }
+    @Override
+    public String getPluralDescription() {
+        return "объявленные массивы";
+    }
+    @Override
+    public Current CurrentName() {
+        return Current.ProjectArray;
+    }
+    @Override
+    protected DataSetControlForm createUI() {
+        return new DataSetControlForm(this) {
+            @Override
+            public boolean hasCheckBox() {
+                return true;
+            }
+            @Override
+            protected void AdditionalInitColumns() {
+                columns.get(0).setVisible(false);
+                if (Global.db.settings.get(SettingName.ShowFullArraysDeclarations).toBoolean()) {
+                    columns.get(4).setRenderer(RendererHyperlinks);
+                    columns.get(4).setEditor(EditorHyperlinks);
+                } else {
+                    columns.get(4).setRenderer(RendererHiddenList);
+                    columns.get(4).setMaxWidth(200);
+                }
+            }
+        };
+    }
+    @Override
+    public String[] getUIColumnNames() {
+        return new String[]{
+                "Имя", "Область описания", "Файлы объявления", "Размерность", "Размер элемента(байт)", "Область распараллеливания"
+        };
+    }
+    @Override
+    public Object getFieldAt(ProjectArray object, int columnIndex) {
+        switch (columnIndex) {
+            case 1:
+                return object.State;
+            case 2:
+                return object.GetShortNameWithDim();
+            case 3:
+                return object.locName + " : " + object.location;
+            case 4:
+                return object.GetDeclPlacesList();
+            case 5:
+                return object.dimSize;
+            case 6:
+                return object.typeSize;
+            case 7:
+                return object.GetRegionsText();
+            default:
+                return null;
+        }
+    }
+    @Override
+    public void CheckAll(boolean flag) {
+        Pass_2021.passes.get(PassCode_2021.MassSelectArrays).Do(flag,new Vector(Current.getProject().declaratedArrays.Data.values()));
+    }
+}

src/ProjectData/SapforData/Arrays/Distribution/AlignRule.java

@@ -0,0 +1,145 @@
+package ProjectData.SapforData.Arrays.Distribution;
+import Common.Utils.Index;
+import ProjectData.SapforData.Arrays.ProjectArray;
+import ProjectData.SapforData.Regions.ParallelRegion;
+import javafx.util.Pair;
+
+import java.math.BigInteger;
+import java.util.Vector;
+public class AlignRule {
+    public BigInteger alignArray_address;
+    public BigInteger alignWith_address;
+    public ParallelRegion parent_region = null;
+    public Vector<Pair<Integer, Integer>> alignRule;
+    public Vector<Pair<Integer, Pair<Integer, Integer>>> alignRuleWith = new Vector<>();
+    public AlignRule(String[] splited, Index idx) {
+        alignArray_address = new BigInteger((splited[idx.Inc()]));
+        alignWith_address = new BigInteger(splited[idx.Inc()]);
+        int alignRule_size = Integer.parseInt((splited[idx.Inc()]));
+        alignRule = new Vector<>(alignRule_size);
+        for (int i = 0; i < alignRule_size; ++i) {
+            int first = Integer.parseInt(splited[idx.Inc()]);
+            int second = Integer.parseInt(splited[idx.Inc()]);
+            alignRule.add(new Pair<>(first, second));
+        }
+        int alignRuleWith_size = Integer.parseInt(splited[idx.Inc()]);
+        alignRuleWith = new Vector<>(alignRuleWith_size);
+        for (int i = 0; i < alignRuleWith_size; ++i) {
+            int first = Integer.parseInt(splited[idx.Inc()]);
+            int first_ = Integer.parseInt(splited[idx.Inc()]);
+            int second_ = Integer.parseInt(splited[idx.Inc()]);
+            alignRuleWith.add(new Pair<>(first, new Pair<>(first_, second_)));
+        }
+    }
+    private static Pair<String, String> convertDigitToPositive(int digit) {
+        String buf = "";
+        String sign = " + ";
+        if (digit < 0) {
+            sign = " - ";
+            int val = -digit;
+            buf += String.valueOf(val);
+        } else
+            buf += String.valueOf(digit);
+        return new Pair<>(sign, buf);
+    }
+    public ProjectArray getAlignArray() {
+        return parent_region.arrays.get(alignArray_address);
+    }
+    public ProjectArray getAlignWith() {
+        return parent_region.arrays.get(alignWith_address);
+    }
+    String genStringExpr(String letter, Pair<Integer, Integer> expr) {
+        String retVal = "";
+        if (expr.getKey() == 0 && expr.getValue() == 0)
+            retVal = "*";
+        else if (expr.getValue() == 0) {
+            if (expr.getKey() == 1)
+                retVal = letter;
+            else {
+                Pair<String, String> digit2 = convertDigitToPositive(expr.getKey());
+                if (digit2.getKey() == " - ")
+                    retVal = "(-" + digit2.getValue() + ")" + " * " + letter;
+                else retVal = digit2.getValue() + " * " + letter;
+            }
+        } else {
+            Pair<String, String> digit1 = convertDigitToPositive(expr.getValue());
+            if (expr.getKey() == 1)
+                retVal = letter + digit1.getKey() + digit1.getValue();
+            else {
+                Pair<String, String> digit2 = convertDigitToPositive(expr.getKey());
+                if (digit2.getKey() == " - ")
+                    retVal = "(-" + digit2.getValue() + ")" + " * " + letter + digit1.getKey() + digit1.getValue();
+                else
+                    retVal = digit2.getValue() + " * " + letter + digit1.getKey() + digit1.getValue();
+            }
+        }
+        return retVal;
+    }
+    public int GetLenString() {
+        String val = "";
+        val += getAlignArray().shortName + "(";
+        for (int i = 0; i < alignRule.size(); ++i) {
+            val += genStringExpr(ProjectArray.alignNames[i], alignRule.get(i));
+            if (i != alignRule.size() - 1)
+                val += ",";
+        }
+        val += ") ";
+        return val.length();
+    }
+    public Pair<String, String> GenRule(int maxArrayStringLen) {
+        getAlignArray().ac_current.clear();
+        getAlignArray().ac_new.clear();
+        getAlignArray().spaces_shift = "";
+        //------------------------------------------------------------>>>
+        getAlignArray().align_template = getAlignWith();
+        getAlignArray().parent_region = parent_region;
+        //------------------------------------------------------------>>>
+        String retVal = "";
+        String arrayString = "";
+        retVal += getAlignArray().TypeString() + " ";
+        arrayString += getAlignArray().shortName + "(";
+        for (int i = 0; i < alignRule.size(); ++i) {
+            arrayString += genStringExpr(ProjectArray.alignNames[i], alignRule.get(i));
+            if (i != alignRule.size() - 1)
+                arrayString += ",";
+        }
+        arrayString += ") ";
+        for (int i = 0; i < maxArrayStringLen - arrayString.length(); ++i) {
+            getAlignArray().spaces_shift += " ";
+        }
+        retVal += getAlignArray().spaces_shift;
+        retVal += arrayString;
+        String bracket_open = "(";
+        String bracket_close = ")";
+
+        /*
+        if (getAlignWith().isTemplFlag > 0)
+        {
+            bracket_open = "[";
+            bracket_close = "]";
+        }
+         */
+        retVal += "→ " + getAlignWith().shortName + bracket_open;
+        Vector<String> alignEachDim = new Vector<>(getAlignWith().dimSize);
+        for (int i = 0; i < alignEachDim.capacity(); ++i)
+            alignEachDim.add("*");
+        for (int i = 0; i < alignRuleWith.size(); ++i) {
+            if (alignRuleWith.get(i).getKey() != -1) {
+                alignEachDim.set(alignRuleWith.get(i).getKey(), genStringExpr(ProjectArray.alignNames[i], alignRuleWith.get(i).getValue()));
+                //коэццициенты находятся здесь!!------------------------------------------------------------------->>
+                getAlignArray().ac_current.put(i,
+                        new Dimension(i,
+                                alignRuleWith.get(i).getValue().getKey(),
+                                alignRuleWith.get(i).getValue().getValue()
+                        ));
+            } else getAlignArray().ac_current.put(i, new Dimension(i));
+        }
+        for (int i = 0; i < alignEachDim.size(); ++i) {
+            retVal += alignEachDim.get(i);
+            if (i != getAlignWith().dimSize - 1)
+                retVal += ",";
+        }
+        retVal += bracket_close;// + String_.wands(alignArray.Id.ToString());
+        return new Pair<>(getAlignWith().shortName, retVal);
+    }
+}

src/ProjectData/SapforData/Arrays/Distribution/DataDirective.java

@@ -0,0 +1,49 @@
+package ProjectData.SapforData.Arrays.Distribution;
+import ProjectData.SapforData.Arrays.ArrayLocation;
+import ProjectData.SapforData.Arrays.ProjectArray;
+import javafx.util.Pair;
+
+import java.math.BigInteger;
+import java.util.LinkedHashMap;
+import java.util.Vector;
+public class DataDirective extends Directive {
+    public Vector<AlignRule> alignRules;
+    public String rules_ = "";
+    public Vector<String> rules = new Vector<>();
+    public void genRules_(LinkedHashMap<Long, ProjectArray> Arrays) {
+        rules_ = "";
+        int maxLen = 0;
+        for (AlignRule a : alignRules)
+            maxLen = Math.max(maxLen, a.GetLenString());
+        LinkedHashMap<String, Vector<String>> toPrint = new LinkedHashMap<>();
+        for (AlignRule a : alignRules) {
+            if (Arrays.get(a.alignArray_address).location != ArrayLocation.parameter) {
+                Pair<String, String> result = a.GenRule(maxLen);
+                if (!toPrint.containsKey(result.getKey()))
+                    toPrint.put(result.getKey(), new Vector<>());
+                toPrint.get(result.getKey()).add(result.getValue());
+            }
+        }
+        for (Vector<String> v : toPrint.values()) {
+            rules_ += String.join("\n", v);
+        }
+    }
+    public void genRules(LinkedHashMap<BigInteger, ProjectArray> Arrays) {
+        rules.clear();
+        int maxLen = 0;
+        for (AlignRule a : alignRules)
+            maxLen = Math.max(maxLen, a.GetLenString());
+        LinkedHashMap<String, Vector<String>> toPrint = new LinkedHashMap<>();
+        for (AlignRule a : alignRules) {
+            if (Arrays.get(a.alignArray_address).location != ArrayLocation.parameter) {
+                Pair<String, String> result = a.GenRule(maxLen);
+                if (!toPrint.containsKey(result.getKey()))
+                    toPrint.put(result.getKey(), new Vector<>());
+                toPrint.get(result.getKey()).add(result.getValue());
+            }
+        }
+        for (Vector<String> v : toPrint.values())
+            for (String r : v)
+                rules.add(r);
+    }
+}

src/ProjectData/SapforData/Arrays/Distribution/Dimension.java

@@ -0,0 +1,37 @@
+package ProjectData.SapforData.Arrays.Distribution;
+import Common.Database.DBObject;
+import ProjectData.SapforData.Arrays.ProjectArray;
+public class Dimension extends DBObject {
+    //--------------------------------------
+    public int num; //номер измерения.
+    public int K = 0;
+    public int B = 0;
+    public boolean active = false;
+    //-------------------------------------
+    public Dimension(int num_in) {
+        num = num_in;
+    }
+    public Dimension(int num_in, int K_in, int B_in) {
+        num = num_in;
+        K = K_in;
+        B = B_in;
+        active = true;
+    }
+    public Dimension clone_() {
+        Dimension res = new Dimension(num);
+        res.active = active;
+        res.K = K;
+        res.B = B;
+        return res;
+    }
+    @Override
+    public Object getPK() {
+        return num;
+    }
+    public String getLetter() {
+        return ProjectArray.alignNames[num];
+    } //для отображения букв
+    public int getS() {
+        return active ? num : -1;
+    } //для триплета. шифр.
+}

src/ProjectData/SapforData/Arrays/Distribution/Directive.java

@@ -0,0 +1,8 @@
+package ProjectData.SapforData.Arrays.Distribution;
+import ProjectData.LanguageName;
+public class Directive {
+    public LanguageName langType = LanguageName.fortran;
+    public String file = "";
+    public int line = -1;
+    public int col = -1;
+}

src/ProjectData/SapforData/Arrays/ProjectArray.java

@@ -0,0 +1,400 @@
+package ProjectData.SapforData.Arrays;
+import Common.Current;
+import Common.Database.DBObject;
+import Common.Utils.Index;
+import Common.Utils.Utils;
+import ProjectData.DBArray.DBArray;
+import ProjectData.Files.DBProjectFile;
+import ProjectData.SapforData.Arrays.Distribution.Dimension;
+import ProjectData.SapforData.Arrays.Templates.TemplateDimension;
+import ProjectData.SapforData.Arrays.Templates.TemplateDimensionState;
+import ProjectData.SapforData.Arrays.Templates.TemplateLink;
+import ProjectData.SapforData.Regions.ParallelRegion;
+import ProjectData.SapforData.Regions.UI.ArrayAlignmentBar;
+import Visual_DVM_2021.Passes.PassCode_2021;
+import Visual_DVM_2021.Passes.Pass_2021;
+import javafx.util.Pair;
+
+import javax.swing.*;
+import java.math.BigInteger;
+import java.util.LinkedHashMap;
+import java.util.Vector;
+import java.util.stream.Collectors;
+public class ProjectArray extends DBObject {
+    //----------------------------------------------------------------------
+    public static final String[] alignNames = {"i", "j", "k", "l", "m", "n", "q", "r", "s", "t", "u", "w", "x", "y", "z"};
+    //-
+    public static String filterName = "";
+    public static String filterLocation = "";
+    public static String filterLocationName = "";
+    public static String filterFile = "";
+    public static String filterRegion = "*";
+    public String UniqKey;
+    public ArrayState State;
+    //-----------------------------
+    public long id;
+    public String name;
+    public String shortName;
+    public int dimSize;
+    public int typeSize;
+    public ArrayLocation location;
+    public String locName;
+    //только для шаблонов. для ФИЛЬТРА управления распределением измерений.
+    public Vector<TemplateDimension> dimensions = new Vector<>();
+    public int isTemplFlag;
+    public int isLoopArrayFlag;
+    //----------------------------
+    public BigInteger address;
+    //----------------------------
+    public ParallelRegion parent_region = null; //родительяская область распараллеливания.
+    //связи->
+    public LinkedHashMap<Long, ProjectArray> links = new LinkedHashMap<>();
+    //------>
+    public ProjectArray align_template = null; //ссылка на шаблон на который идет выравнивание.
+    public String spaces_shift = ""; //смещение из пробелов
+    //ИЗМЕНЕНИЕ РАСПРЕДЕЛЕНИЯ
+    //------------------------------------------------------------------------------------------------------>
+    //текущие
+    public LinkedHashMap<Integer, Dimension> ac_current = new LinkedHashMap<>();
+    //кандидаты на замену.
+    public LinkedHashMap<Integer, Dimension> ac_new = new LinkedHashMap<>();
+    //https://stackoverflow.com/questions/4941372/how-to-insert-image-into-jtable-cell
+    public ArrayAlignmentBar bar = null;
+    //------------------------------------------------------------------------------------------------------>
+    //<editor-fold desc="Функционал шаблона">
+    public Vector<BigInteger> regIDs = new Vector<>();
+    Vector<Pair<Integer, Integer>> sizes = new Vector<>();
+    Vector<Integer> deprecateToDist = new Vector<>();
+    Vector<Integer> mappedDims = new Vector<>();
+    LinkedHashMap<BigInteger, TemplateLink> templateInfo = new LinkedHashMap<>();
+    Vector<ArrayDecl> declPlaces = new Vector<>();
+    Vector<String> regions = new Vector<>();
+    public ProjectArray(String[] infoF, Index idx, BigInteger address_in) {
+        id = Integer.parseInt(infoF[idx.Inc()]);
+        name = infoF[idx.Inc()];
+        shortName = infoF[idx.Inc()];
+        dimSize = Integer.parseInt(infoF[idx.Inc()]);
+        typeSize = Integer.parseInt(infoF[idx.Inc()]);
+        address = address_in;
+        State = ArrayState.fromInt(Integer.parseInt(infoF[idx.Inc()]));
+        location = ArrayLocation.fromInt(Integer.parseInt(infoF[idx.Inc()]));
+        locName = infoF[idx.Inc()];
+        int sizes_size = Integer.parseInt(infoF[idx.Inc()]);
+        for (int i = 0; i < sizes_size; ++i) {
+            int first = Integer.parseInt(infoF[idx.Inc()]);
+            int second = Integer.parseInt(infoF[idx.Inc()]);
+            sizes.add(new Pair<>(first, second));
+        }
+        sizes_size = Integer.parseInt(infoF[idx.Inc()]);
+        for (int i = 0; i < sizes_size; ++i)
+            deprecateToDist.add(Integer.parseInt(infoF[idx.Inc()]));
+        sizes_size = Integer.parseInt(infoF[idx.Inc()]);
+        for (int i = 0; i < sizes_size; ++i)
+            mappedDims.add(Integer.parseInt(infoF[idx.Inc()]));
+        int templateInfo_size = Integer.parseInt(infoF[idx.Inc()]);
+        for (int i = 0; i < templateInfo_size; ++i) {
+            BigInteger key = new BigInteger(infoF[idx.Inc()]);
+            TemplateLink templateLink = new TemplateLink(infoF, idx);
+            templateInfo.put(key, templateLink);
+        }
+        String[] localSplited = infoF[idx.Inc()].split("\\|");
+        isTemplFlag = Integer.parseInt(localSplited[0]);
+        isLoopArrayFlag = Integer.parseInt(localSplited[1]);
+        int numDeclPlaces = Integer.parseInt(localSplited[2]);
+        int idxPl = 3;
+        for (int i = 0; i < numDeclPlaces; ++i, idxPl += 2) {
+            String declFile = Utils.toW(localSplited[idxPl]);
+            DBProjectFile file = Current.getProject().db.files.Data.get(declFile);
+            int declLine = Integer.parseInt(localSplited[idxPl + 1]);
+            //declPlaces.add(new Pair<>(declFile, declLine));
+            ArrayDecl decl = new ArrayDecl(shortName, location, file, declLine);
+            declPlaces.add(decl);
+            file.array_decls.add(decl); //--
+        }
+        int numRegs = Integer.parseInt(localSplited[idxPl++]);
+        for (int i = 0; i < numRegs; ++i)
+            regions.add(localSplited[idxPl++]);
+        UniqKey = shortName + locName + dimSize;
+        //короткое имя+ функция/модуль/комон+ размерность
+    }
+    public static String fill_binary(int d, String binary) {
+        int delta = Math.abs(binary.length() - d);
+        String res = binary;
+        for (int i = 0; i < delta; ++i) {
+            res = ("0" + res);
+        }
+        return res;
+    }
+    //длина должна быть равной, ищем есть ли совпадающие позиции с единицами
+    public static boolean mask(String banned, String variant) {
+        for (int i = 0; i < variant.length(); ++i)
+            if ((variant.toCharArray()[i] == '1') && (banned.toCharArray()[i] == '1')) //попался, масконосец!
+                return true;
+        return false;
+    }
+    public String printLinks() {
+        Vector<String> res = links.keySet().stream().map(Object::toString).collect(Collectors.toCollection(Vector::new));
+        return String.join(" ", res);
+    }
+    //----------------------------------------------------------------------
+    @Override
+    public Object getPK() {
+        return id;
+    }
+    public boolean has_decl_place(String bg_file) {
+        for (ArrayDecl decl : declPlaces)
+            if (decl.file.startsWith(bg_file)) return true;
+        return false;
+    }
+    public boolean has_region(String bg_region) {
+        if (bg_region.equals("*"))
+            return true;
+        for (String region : regions)
+            if (region.startsWith(bg_region)) return true;
+        return false;
+    }
+    public String TypeString() {
+        return (isLoopArrayFlag == 0) ? ((isTemplFlag == 0) ? "МАССИВ" : "ШАБЛОН") : "ЦИКЛ";
+    }
+    public String state_symbol() {
+        return State == ArrayState.Selected ? "☑" : "☐";
+    }
+    @Override
+    public String toString() {
+        return id + " " + state_symbol() + " " +
+                State + " " +
+                shortName + " " +
+                locName + " : " + location + " " + dimSize + " " + typeSize;
+    }
+    public String GetShortNameWithDim() {
+        String res = shortName + "( ";
+        if (sizes != null && sizes.size() != dimSize) {
+            for (int i = 0; i < dimSize; ++i) {
+                res += alignNames[i];
+                if (i < dimSize - 1)
+                    res += ", ";
+                else res += ")";
+            }
+        } else {
+            for (int i = 0; i < dimSize; ++i) {
+                if (sizes.get(i).getKey() != sizes.get(i).getValue() && sizes.get(i).getKey() != -1)
+                    res += sizes.get(i).getKey() + ":" + sizes.get(i).getValue();
+                else
+                    res += alignNames[i];
+                if (i < dimSize - 1)
+                    res += ", ";
+                else res += ")";
+            }
+        }
+        return res;
+    }
+    //-
+    //для таблицы вариантов, измерения (i,j,k,..)
+    public String GetShortNameWithDimLetters() {
+        String res = shortName + "(";
+        for (int i = 0; i < dimSize; ++i) {
+            res += alignNames[i];
+            if (i < dimSize - 1)
+                res += ",";
+            else res += ")";
+        }
+        return res;
+    }
+    //-
+    public Vector<String> GetDeclPlacesList() {
+        Vector<String> links = new Vector<>();
+        for (ArrayDecl d : declPlaces)
+            links.add(d.file + ":" + d.line);
+        return links;
+    }
+    public String GetRegionsText() {
+        String res = "";
+        for (int i = 0; i < regions.size(); ++i)
+            res += regions.get(i) + ((i != regions.size() - 1) ? "," : "");
+        return res;
+    }
+    public boolean DimDisabled(int dim) {
+        // не участвует в шаблонах. или явно запрещено
+        return (mappedDims.get(dim) == 0) || (deprecateToDist.get(dim) == 1);
+    }
+    public void CreateDimensions() {
+        for (BigInteger regID : regIDs) {
+            ParallelRegion region = Current.getProject().parallelRegions.get(regID);
+            for (int i = 0; i < Current.getProject().maxdim; ++i) {
+                dimensions.add(new TemplateDimension(
+                        i, this, region
+                ));
+            }
+        }
+    }
+    public Object[] CreateTemplateCells() {
+        Vector<Object> res = new Vector<>();
+        res.add(this.shortName);
+        for (int i = 0; i < dimensions.size(); ++i) {
+            res.add(dimensions.get(i));
+        }
+        return res.toArray();
+    }
+    //получить двоичное представление варианта распределения и дополнить его нулями.
+    public String get_binary(long varID) {
+        String binary = Long.toBinaryString(varID);
+        return fill_binary(dimSize, binary);
+    }
+    public Vector<Long> get_varIDs(boolean filter) {
+        long d = (long) Math.pow(2, dimSize);
+        Vector<Long> varIDs = new Vector<>();
+        Vector<String> DimsDep = new Vector<>();
+        for (int z = 0; z < mappedDims.size(); ++z)
+            DimsDep.add(
+                    String.valueOf((DimDisabled(z) ? 1 : 0)));
+        String banned_dimensions = String.join("", DimsDep);
+        //------ Дляполностью размноженного нужен d-1 ?
+        for (long i = 0; i < d; ++i) {
+            String binary = get_binary(i);
+            if (!mask(banned_dimensions, binary)) {
+                if (filter) {
+                    boolean valid = true;
+                    if (Current.getProject().f_distributed())
+                        valid = CheckFilterMask(i, true, binary);
+                    if (valid && Current.getProject().f_multiplied())
+                        valid = CheckFilterMask(i, false, binary);
+                    if (valid)
+                        varIDs.add(i);
+                } else varIDs.add(i);
+            }
+        }
+        return varIDs;
+    }
+    //проверка одиночного вар ида. нужна для минимального покрытия.
+    public boolean checkVarID(long i, boolean filter) {
+        Vector<String> DimsDep = new Vector<>();
+        for (int z = 0; z < mappedDims.size(); ++z)
+            DimsDep.add(String.valueOf((DimDisabled(z) ? 1 : 0)));
+        String banned_dimensions = String.join("", DimsDep);
+        String binary = get_binary(i);
+        if (!mask(banned_dimensions, binary)) {
+            if (filter) {
+                boolean valid = true;
+                if (Current.getProject().f_distributed())
+                    valid = CheckFilterMask(i, true, binary);
+                if (valid && Current.getProject().f_multiplied())
+                    valid = CheckFilterMask(i, false, binary);
+                return valid;
+            } else return true;
+        }
+        return false;
+    }
+    public Vector<Long> get_varIDs() {
+        return get_varIDs(true);
+    }
+    //для первичного заполнения рекурсии
+    public Vector<Vector<BigInteger>> get_triples(boolean filter) {
+        Vector<Vector<BigInteger>> res = new Vector<>();
+        Vector<Long> varIDs = get_varIDs(filter);
+        for (long varID : varIDs) {
+            for (BigInteger regID : regIDs) //для всех областей
+            {
+                Vector<BigInteger> tripple = new Vector<>();
+                tripple.add(address);
+                tripple.add(BigInteger.valueOf(varID));
+                tripple.add(regID);
+                res.add(tripple);
+            }
+        }
+        return res;
+    }
+    public String GetShortNameForVariant(long varID) {
+        String binary = get_binary(varID);
+        String res = shortName + "(";
+        for (int i = 0; i < dimSize; ++i) {
+            if (i < binary.length()) {
+                switch (binary.toCharArray()[i]) {
+                    case '0':
+                        res += TemplateDimensionState.multiplied.getDescription();
+                        break;
+                    case '1':
+                        res += TemplateDimensionState.distributed.getDescription();
+                        break;
+                    default:
+                        break;
+                }
+                res += Utils.ending(i == binary.length() - 1);
+            }
+        }
+        return res;
+    }
+    //</editor-fold>
+    public String getFilterMask() {
+        String res = "";
+        for (int i = 0; i < dimensions.size(); ++i) {
+            res += (dimensions.get(i).state.ordinal());
+        }
+        return res;
+    }
+    public boolean CheckFilterMask(long varID, boolean distributed, String binary_in) {
+        char s = distributed ? '1' : '0';
+        String filterMask = getFilterMask();
+        String variant = binary_in.isEmpty() ? get_binary(varID) : binary_in;
+        // System.out.println(shortName+"|mask="+filterMask+"|varId="+variant+"|"+s);
+        for (int i = 0; i < variant.length(); ++i) {
+            if ((filterMask.toCharArray()[i] == s) && (variant.toCharArray()[i] != s)) return false;
+        }
+        return true;
+    }
+    public boolean CheckFilterMask(long varID, boolean distributed) {
+        return CheckFilterMask(varID, distributed, "");
+    }
+    public void SaveUserState() throws Exception {
+        if (Current.getProject().db.savedArrays.Data.containsKey(UniqKey)) {
+            DBArray sa = Current.getProject().db.savedArrays.Data.get(UniqKey);
+            sa.State = State;
+            Current.getProject().db.Update(sa);
+        } else
+            Current.getProject().db.Insert(new DBArray(this));
+    }
+    //-----------------------------------------------------------------------
+    @Override
+    public boolean isSelectionEnabled() {
+        return (State == ArrayState.Selected) || (State == ArrayState.None);
+    }
+    @Override
+    public ImageIcon GetDisabledIcon() {
+        return Utils.getIcon("/icons/Arrays/" + State.toString() + ".png");
+    }
+    @Override
+    public void select(boolean flag) {
+        Pass_2021.passes.get(PassCode_2021.MassSelectArrays).Do(flag, this);
+    }
+    @Override
+    public boolean isSelected() {
+        return (State == ArrayState.Selected);
+    }
+    //-
+    @Override
+    public boolean isVisible() {
+        if (isTemplFlag > 0) return true;
+        return shortName.startsWith(filterName) &&
+                location.toString().startsWith(filterLocation) &&
+                locName.startsWith(filterLocationName) &&
+                has_decl_place(filterFile) &&
+                has_region(filterRegion);
+    }
+    public void init_new_ac() {
+        ac_new.clear();
+        for (int dim : ac_current.keySet())
+            ac_new.put(dim, ac_current.get(dim).clone_());
+    }
+    public boolean ac_need_change() {
+        for (int dim : ac_current.keySet()) {
+            Dimension old_ = ac_current.get(dim);
+            Dimension new_ = ac_new.get(dim);
+            if ((old_.K != new_.K) || (old_.B != new_.B))
+                return true;
+        }
+        return false;
+    }
+    public boolean canBeDistributed() {
+        return (isLoopArrayFlag == 0) && (isTemplFlag == 0);
+    }
+    //----
+}

src/ProjectData/SapforData/Arrays/Templates/TemplateDimension.java

@@ -0,0 +1,34 @@
+package ProjectData.SapforData.Arrays.Templates;
+import Common.Database.DBObject;
+import ProjectData.SapforData.Arrays.ProjectArray;
+import ProjectData.SapforData.Regions.ParallelRegion;
+//для генерации вариантов и для управления распределением измерений.
+public class TemplateDimension extends DBObject {
+    public int num = -1;
+    public ProjectArray template = null;
+    public ParallelRegion region = null;
+    public TemplateDimensionState state;
+    public TemplateDimension(int num_in, ProjectArray template_in, ParallelRegion region_in) {
+        num = num_in;
+        template = template_in;
+        region = region_in;
+        state = isBlocked() ? TemplateDimensionState.multiplied : TemplateDimensionState.distributed;
+    }
+    public boolean isBlocked() {
+        return (num >= template.dimSize) || template.DimDisabled(num);
+    }
+    public void SwitchState() {
+        switch (state) {
+            case distributed:
+                state = TemplateDimensionState.multiplied;
+                break;
+            case multiplied:
+                state = TemplateDimensionState.distributed;
+                break;
+        }
+    }
+    @Override
+    public Object getPK() {
+        return num;
+    }
+}

src/ProjectData/SapforData/Arrays/Templates/TemplateDimensionState.java

@@ -0,0 +1,36 @@
+package ProjectData.SapforData.Arrays.Templates;
+import Common.Current;
+public enum TemplateDimensionState {
+    multiplied, //0
+    distributed; //1
+    public String getMaskDescription() {
+        switch (this) {
+            case distributed:
+                if (Current.getProject().f_distributed()) {
+                    return "BLOCK";
+                } else {
+                    if (Current.getProject().f_multiplied())
+                        return "  X  ";
+                    else return "BLOCK";
+                }
+            case multiplied:
+                if (Current.getProject().f_multiplied()) {
+                    return "  *  ";
+                } else {
+                    if (Current.getProject().f_distributed())
+                        return "  X  ";
+                    else return "  *  ";
+                }
+        }
+        return "?";
+    }
+    public String getDescription() {
+        switch (this) {
+            case distributed:
+                return "BLOCK";
+            case multiplied:
+                return "  *  ";
+        }
+        return "??";
+    }
+}

src/ProjectData/SapforData/Arrays/Templates/TemplateLink.java

@@ -0,0 +1,24 @@
+package ProjectData.SapforData.Arrays.Templates;
+import Common.Utils.Index;
+import javafx.util.Pair;
+
+import java.util.Vector;
+public class TemplateLink {
+    Vector<Integer> linkWithTemplate = new Vector<>();
+    Vector<Pair<Integer, Integer>> alignRuleWithTemplate = new Vector<>();
+    long templateArray;
+    public TemplateLink(String[] splited, Index idx) {
+        int linkWithTemplate_size = Integer.parseInt(splited[idx.Inc()]);
+        for (int i = 0; i < linkWithTemplate_size; ++i) {
+            int link_ = Integer.parseInt(splited[idx.Inc()]);
+            linkWithTemplate.add(link_);
+        }
+        int alignRuleWithTemplate_size = Integer.parseInt(splited[idx.Inc()]);
+        for (int i = 0; i < alignRuleWithTemplate_size; ++i) {
+            int f = Integer.parseInt(splited[idx.Inc()]);
+            int s = Integer.parseInt(splited[idx.Inc()]);
+            alignRuleWithTemplate.add(new Pair<>(f, s));
+        }
+        templateArray = Long.parseLong(splited[idx.Inc()]);
+    }
+}

src/ProjectData/SapforData/Arrays/UI/DimensionRenderer.java

@@ -0,0 +1,20 @@
+package ProjectData.SapforData.Arrays.UI;
+import Common.Current;
+import Common.UI.Tables.RendererCell;
+import Common.UI.Themes.VisualiserFonts;
+import ProjectData.SapforData.Arrays.Templates.TemplateDimension;
+
+import javax.swing.*;
+public class DimensionRenderer extends RendererCell<TemplateDimension> {
+    @Override
+    public TemplateDimension Init(JTable table, Object value_in, int row, int column) {
+        return (TemplateDimension) value_in;
+    }
+    @Override
+    public void Display() {
+        if (value != null) {
+            setText(value.state.getMaskDescription());
+            setFont(value.isBlocked() ? Current.getTheme().Fonts.get(VisualiserFonts.Disabled) : Current.getTheme().Fonts.get(VisualiserFonts.Hyperlink));
+        }
+    }
+}

src/ProjectData/SapforData/Arrays/UI/DimensionStateChanger.java

@@ -0,0 +1,25 @@
+package ProjectData.SapforData.Arrays.UI;
+import Common.Current;
+import Common.UI.Tables.DBObjectEditor;
+import Common.UI.Themes.VisualiserFonts;
+import Common.UI.UI;
+import ProjectData.SapforData.Arrays.Templates.TemplateDimension;
+
+import javax.swing.*;
+public class DimensionStateChanger extends DBObjectEditor<TemplateDimension> {
+    @Override
+    public Object getCellEditorValue() {
+        return value;
+    }
+    @Override
+    public void InitValue(JTable table, Object value_in, int row, int column) {
+        value = (TemplateDimension) value_in;
+    }
+    @Override
+    public void Action() {
+        setFont(Current.getTheme().Fonts.get(VisualiserFonts.Hyperlink));
+        value.SwitchState();
+        setText(value.state.getMaskDescription());
+        UI.getVersionsWindow().getVariantsWindow().ShowFilteredVariantsCount();
+    }
+}

src/ProjectData/SapforData/Arrays/UI/DimensionsTableForm.java

@@ -0,0 +1,55 @@
+package ProjectData.SapforData.Arrays.UI;
+import Common.Current;
+import Common.UI.ControlForm;
+import Common.UI.Tables.Grid.GridAnchestor;
+import Common.UI.Tables.StyledTable;
+import Common.UI.UI;
+import ProjectData.SapforData.Arrays.ProjectArray;
+import ProjectData.SapforData.Arrays.Templates.TemplateDimension;
+
+import java.awt.*;
+import java.util.Vector;
+
+import static Common.UI.Tables.TableEditors.EditorDimension;
+import static Common.UI.Tables.TableRenderers.RendererDimension;
+public class DimensionsTableForm extends ControlForm<StyledTable> {
+    public DimensionsTableForm() {
+        super(StyledTable.class);
+    }
+    @Override
+    public void Show() {
+        super.Show();
+        content.add(scroll, BorderLayout.CENTER);
+        content.updateUI();
+    }
+    @Override
+    public void Clear() {
+        super.Clear();
+        UI.Clear(content);
+    }
+    @Override
+    public void CreateControl() {
+        Vector<String> columns = new Vector<>();
+        columns.add("шаблон");
+        for (int i = 0; i < Current.getProject().maxdim; ++i)
+            columns.add(ProjectArray.alignNames[i]);
+        Vector<Object> dimensions = new Vector<>();
+        Current.getProject().templates.forEach(t -> dimensions.add(t.CreateTemplateCells()));
+        control = new StyledTable(new GridAnchestor(columns, dimensions) {
+            @Override
+            public Object getValueAt(int rowIndex, int columnIndex) {
+                return ((Object[]) data.get(rowIndex))[columnIndex];
+            }
+            @Override
+            public boolean isCellEditable(int row, int col) {
+                return (col > 0) && !((TemplateDimension) getValueAt(row, col)).isBlocked();
+            }
+        }) {
+            @Override
+            public void Init() {
+                setDefaultRenderer(TemplateDimension.class, UI.TableRenderers.get(RendererDimension));
+                setDefaultEditor(TemplateDimension.class, UI.TableEditors.get(EditorDimension));
+            }
+        };
+    }
+}

src/ProjectData/SapforData/Arrays/UI/DistributionMenu.java

@@ -0,0 +1,20 @@
+package ProjectData.SapforData.Arrays.UI;
+import Common.UI.Menus.GraphMenu;
+import Common.UI.Trees.StyledTree;
+import Visual_DVM_2021.Passes.PassCode_2021;
+import Visual_DVM_2021.Passes.Pass_2021;
+
+import javax.swing.*;
+public class DistributionMenu extends GraphMenu {
+    JMenuItem mChangeDistribution;
+    public DistributionMenu(StyledTree tree) {
+        super(tree, "области распараллеливания");
+        mChangeDistribution = Pass_2021.passes.get(PassCode_2021.SPF_ModifyArrayDistribution).createMenuItem();
+        add(mChangeDistribution);
+    }
+    @Override
+    public void CheckElementsVisibility() {
+        super.CheckElementsVisibility();
+        mChangeDistribution.setVisible(Pass_2021.passes.get(PassCode_2021.SPF_GetArrayDistribution).isDone());
+    }
+}

src/ProjectData/SapforData/Arrays/UI/FileArraysTree.java

@@ -0,0 +1,12 @@
+package ProjectData.SapforData.Arrays.UI;
+import Common.Current;
+import ProjectData.Files.UI.FileGraphTree;
+public class FileArraysTree extends FileGraphTree {
+    public FileArraysTree() {
+        super(Current.getFile().getArraysTree());
+    }
+    @Override
+    public String getBranchesName() {
+        return "объявления массивов";
+    }
+}

src/ProjectData/SapforData/Arrays/UI/RulesTree.java

@@ -0,0 +1,43 @@
+package ProjectData.SapforData.Arrays.UI;
+import Common.Current;
+import Common.UI.Menus.GraphMenu;
+import Common.UI.Trees.StyledTree;
+import Common.UI.Trees.TreeRenderers;
+import ProjectData.SapforData.Regions.ParallelRegion;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreePath;
+
+import static Common.UI.Trees.TreeRenderers.RendererRule;
+public class RulesTree extends StyledTree {
+    public RulesTree() {
+        super(Current.getProject().align_rules_root);
+        setRootVisible(false);
+        expandRow(0);
+        ExpandAll();
+        Current.set(Current.ParallelRegion, null);
+    }
+    @Override
+    protected GraphMenu createMenu() {
+        return new DistributionMenu(this);
+    }
+    @Override
+    public TreeRenderers getRenderer() {
+        return RendererRule;
+    }
+    @Override
+    public void SelectionAction(TreePath e) {
+        ParallelRegion region = null;
+        if (e != null) {
+            DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.getLastPathComponent();
+            Object o = node.getUserObject();
+            if (o instanceof String) {
+                region = (ParallelRegion) ((DefaultMutableTreeNode) node.getParent()).getUserObject();
+            }
+            if (o instanceof ParallelRegion) {
+                region = (ParallelRegion) o;
+            }
+        }
+        Current.set(Current.ParallelRegion, region);
+    }
+}

src/ProjectData/SapforData/Arrays/UI/RulesTreeCellRenderer.java

@@ -0,0 +1,23 @@
+package ProjectData.SapforData.Arrays.UI;
+import Common.Current;
+import Common.UI.Themes.VisualiserFonts;
+import Common.UI.Trees.StyledTreeCellRenderer;
+import ProjectData.SapforData.Regions.ParallelRegion;
+
+import javax.swing.*;
+import javax.swing.tree.DefaultMutableTreeNode;
+public class RulesTreeCellRenderer extends StyledTreeCellRenderer {
+    public java.awt.Component getTreeCellRendererComponent(
+            JTree tree, Object value,
+            boolean selected, boolean expanded,
+            boolean leaf, int row, boolean hasFocus) {
+        super.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
+        Object o = ((DefaultMutableTreeNode) value).getUserObject();
+        if (o instanceof String) {
+            setFont(Current.getTheme().Fonts.get(VisualiserFonts.Distribution));
+        } else if (o instanceof ParallelRegion)
+            setFont(Current.getTheme().Fonts.get(VisualiserFonts.TreeItalic));
+        setForeground(tree.getForeground());
+        return this;
+    }
+}