API tools faq
paste
Advertisement
karlicoss

vizi oO

karlicoss
Aug 27th, 2011
525
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 67.11 KB | None | 0 0
raw download clone embed print report
  1. package ru.ifmo.vizi.btree;
  2.  
  3. import ru.ifmo.vizi.base.auto.*;
  4. import java.util.Locale;
  5.  
  6. public final class BTree extends BaseAutoReverseAutomata {
  7.     /**
  8.       * Модель данных.
  9.       */
  10.     public final Data d = new Data();
  11.  
  12.     /**
  13.       * Конструктор для языка
  14.       */
  15.     public BTree(Locale locale) {
  16.         super("ru.ifmo.vizi.btree.Comments", locale);
  17.         init(new Main(), d);
  18.     }
  19.  
  20.     /**
  21.       * Данные.
  22.       */
  23.     public final class Data {
  24.         /**
  25.           * Экземпляр апплета.
  26.           */
  27.         public BTreeVisualizer visualizer = null;
  28.  
  29.         /**
  30.           * Корень дерева.
  31.           */
  32.         public treeNode root = null;
  33.  
  34.         /**
  35.           * Текущий узел.
  36.           */
  37.         public treeNode x = null;
  38.  
  39.         /**
  40.           * Ключ.
  41.           */
  42.         public char k = 'A';
  43.  
  44.         /**
  45.           * ???.
  46.           */
  47.         public int t = 2;
  48.  
  49.         /**
  50.           * ???.
  51.           */
  52.         public treeNode y = null;
  53.  
  54.         /**
  55.           * ???.
  56.           */
  57.         public int m = 0;
  58.  
  59.         /**
  60.           * Русская Строка.
  61.           */
  62.         public String sRu = new String();
  63.  
  64.         /**
  65.           * English String.
  66.           */
  67.         public String sEn = new String();
  68.  
  69.         /**
  70.           *  (Процедура SplitChild).
  71.           */
  72.         public treeNode SplitChild_z;
  73.  
  74.         /**
  75.           * Переменная цикла (Процедура SplitChild).
  76.           */
  77.         public int SplitChild_j;
  78.  
  79.         /**
  80.           * Переменная цикла (Процедура InsertNonfull).
  81.           */
  82.         public boolean InsertNonfull_flag;
  83.  
  84.         /**
  85.           * Переменная цикла (Процедура InsertNonfull).
  86.           */
  87.         public int InsertNonfull_i;
  88.  
  89.         public String toString() {
  90.             return("");
  91.         }
  92.     }
  93.  
  94.     /**
  95.       * Разрезает вершину.
  96.       */
  97.     private final class SplitChild extends BaseAutomata implements Automata {
  98.         /**
  99.           * Начальное состояние автомата.
  100.           */
  101.         private final int START_STATE = 0;
  102.  
  103.         /**
  104.           * Конечное состояние автомата.
  105.           */
  106.         private final int END_STATE = 16;
  107.  
  108.         /**
  109.           * Конструктор.
  110.           */
  111.         public SplitChild() {
  112.             super(
  113.                 "SplitChild",
  114.                 0, // Номер начального состояния
  115.                 16, // Номер конечного состояния
  116.                 new String[]{
  117.                     "Начальное состояние",  
  118.                     "Начало цикла",
  119.                     "Цикл",
  120.                     "XZ",
  121.                     "XZ",
  122.                     "XZ (окончание)",
  123.                     "Начало цикла",
  124.                     "Цикл",
  125.                     "XZ",
  126.                     "Начало цикла",
  127.                     "Цикл",
  128.                     "XZ",
  129.                     "Начало цикла",
  130.                     "Цикл",
  131.                     "XZ",
  132.                     "XZ",
  133.                     "Конечное состояние"
  134.                 }, new int[]{
  135.                     Integer.MAX_VALUE, // Начальное состояние,  
  136.                     -1, // Начало цикла
  137.                     -1, // Цикл
  138.                     -1, // XZ
  139.                     -1, // XZ
  140.                     -1, // XZ (окончание)
  141.                     -1, // Начало цикла
  142.                     -1, // Цикл
  143.                     -1, // XZ
  144.                     -1, // Начало цикла
  145.                     -1, // Цикл
  146.                     -1, // XZ
  147.                     -1, // Начало цикла
  148.                     -1, // Цикл
  149.                     -1, // XZ
  150.                     -1, // XZ
  151.                     Integer.MAX_VALUE, // Конечное состояние
  152.                 }
  153.             );
  154.         }
  155.  
  156.         /**
  157.           * Сделать один шаг автомата в перед.
  158.           */
  159.         protected void doStepForward(int level) {
  160.             // Переход в следующее состояние
  161.             switch (state) {
  162.                 case START_STATE: { // Начальное состояние
  163.                     state = 1; // Начало цикла
  164.                     break;
  165.                 }
  166.                 case 1: { // Начало цикла
  167.                     stack.pushBoolean(false);
  168.                     state = 2; // Цикл
  169.                     break;
  170.                 }
  171.                 case 2: { // Цикл
  172.                     if (d.SplitChild_j <= d.t - 1) {
  173.                         state = 3; // XZ
  174.                     } else {
  175.                         state = 4; // XZ
  176.                     }
  177.                     break;
  178.                 }
  179.                 case 3: { // XZ
  180.                     stack.pushBoolean(true);
  181.                     state = 2; // Цикл
  182.                     break;
  183.                 }
  184.                 case 4: { // XZ
  185.                     if (!d.y.leaf) {
  186.                         state = 6; // Начало цикла
  187.                     } else {
  188.                         stack.pushBoolean(false);
  189.                         state = 5; // XZ (окончание)
  190.                     }
  191.                     break;
  192.                 }
  193.                 case 5: { // XZ (окончание)
  194.                     state = 9; // Начало цикла
  195.                     break;
  196.                 }
  197.                 case 6: { // Начало цикла
  198.                     stack.pushBoolean(false);
  199.                     state = 7; // Цикл
  200.                     break;
  201.                 }
  202.                 case 7: { // Цикл
  203.                     if (d.SplitChild_j <= d.t) {
  204.                         state = 8; // XZ
  205.                     } else {
  206.                         stack.pushBoolean(true);
  207.                         state = 5; // XZ (окончание)
  208.                     }
  209.                     break;
  210.                 }
  211.                 case 8: { // XZ
  212.                     stack.pushBoolean(true);
  213.                     state = 7; // Цикл
  214.                     break;
  215.                 }
  216.                 case 9: { // Начало цикла
  217.                     stack.pushBoolean(false);
  218.                     state = 10; // Цикл
  219.                     break;
  220.                 }
  221.                 case 10: { // Цикл
  222.                     if (d.m <= d.SplitChild_j) {
  223.                         state = 11; // XZ
  224.                     } else {
  225.                         state = 12; // Начало цикла
  226.                     }
  227.                     break;
  228.                 }
  229.                 case 11: { // XZ
  230.                     stack.pushBoolean(true);
  231.                     state = 10; // Цикл
  232.                     break;
  233.                 }
  234.                 case 12: { // Начало цикла
  235.                     stack.pushBoolean(false);
  236.                     state = 13; // Цикл
  237.                     break;
  238.                 }
  239.                 case 13: { // Цикл
  240.                     if (d.m <= d.SplitChild_j) {
  241.                         state = 14; // XZ
  242.                     } else {
  243.                         state = 15; // XZ
  244.                     }
  245.                     break;
  246.                 }
  247.                 case 14: { // XZ
  248.                     stack.pushBoolean(true);
  249.                     state = 13; // Цикл
  250.                     break;
  251.                 }
  252.                 case 15: { // XZ
  253.                     state = END_STATE;
  254.                     break;
  255.                 }
  256.             }
  257.  
  258.             // Действие в текущем состоянии
  259.             switch (state) {
  260.                 case 1: { // Начало цикла
  261.                     startSection();
  262.                     storeField(d, "SplitChild_z");
  263.                     d.SplitChild_z = new treeNode();
  264.                     storeField(d.SplitChild_z, "leaf");
  265.                     d.SplitChild_z.leaf = d.y.leaf;
  266.                     storeField(d.SplitChild_z, "n");
  267.                     d.SplitChild_z.n = d.t - 1;
  268.                     storeField(d, "SplitChild_j");
  269.                     d.SplitChild_j = 1;
  270.                     break;
  271.                 }
  272.                 case 2: { // Цикл
  273.                     break;
  274.                 }
  275.                 case 3: { // XZ
  276.                     startSection();
  277.                     storeArray(d.SplitChild_z.keys, d.SplitChild_j);
  278.                     d.SplitChild_z.keys[d.SplitChild_j] = d.y.keys[d.SplitChild_j + d.t];
  279.                     storeField(d, "SplitChild_j");
  280.                     d.SplitChild_j = d.SplitChild_j + 1;
  281.                     break;
  282.                 }
  283.                 case 4: { // XZ
  284.                     break;
  285.                 }
  286.                 case 5: { // XZ (окончание)
  287.                     break;
  288.                 }
  289.                 case 6: { // Начало цикла
  290.                     startSection();
  291.                     storeField(d, "SplitChild_j");
  292.                     d.SplitChild_j = 1;
  293.                     break;
  294.                 }
  295.                 case 7: { // Цикл
  296.                     break;
  297.                 }
  298.                 case 8: { // XZ
  299.                     startSection();
  300.                     storeArray(d.SplitChild_z.links, d.SplitChild_j);
  301.                     d.SplitChild_z.links[d.SplitChild_j] = d.y.links[d.SplitChild_j + d.t];
  302.                     storeField(d, "SplitChild_j");
  303.                     d.SplitChild_j = d.SplitChild_j + 1;
  304.                     break;
  305.                 }
  306.                 case 9: { // Начало цикла
  307.                     startSection();
  308.                     storeField(d.y, "n");
  309.                     d.y.n = d.t - 1;
  310.                     storeField(d, "SplitChild_j");
  311.                     d.SplitChild_j = d.x.n + 1;
  312.                     break;
  313.                 }
  314.                 case 10: { // Цикл
  315.                     break;
  316.                 }
  317.                 case 11: { // XZ
  318.                     startSection();
  319.                     storeArray(d.x.links, d.SplitChild_j + 1);
  320.                     d.x.links[d.SplitChild_j + 1] = d.x.links[d.SplitChild_j];
  321.                     storeField(d, "SplitChild_j");
  322.                     d.SplitChild_j = d.SplitChild_j - 1;
  323.                     break;
  324.                 }
  325.                 case 12: { // Начало цикла
  326.                     startSection();
  327.                     storeArray(d.x.links, d.m + 1);
  328.                     d.x.links[d.m + 1] = d.SplitChild_z;
  329.                     storeField(d, "SplitChild_j");
  330.                     d.SplitChild_j = d.x.n;
  331.                     break;
  332.                 }
  333.                 case 13: { // Цикл
  334.                     break;
  335.                 }
  336.                 case 14: { // XZ
  337.                     startSection();
  338.                     storeArray(d.x.keys, d.SplitChild_j + 1);
  339.                     d.x.keys[d.SplitChild_j + 1] = d.x.keys[d.SplitChild_j];
  340.                     storeField(d, "SplitChild_j");
  341.                     d.SplitChild_j = d.SplitChild_j - 1;
  342.                     break;
  343.                 }
  344.                 case 15: { // XZ
  345.                     startSection();
  346.                     storeArray(d.x.keys, d.m);
  347.                     d.x.keys[d.m] = d.y.keys[d.t];
  348.                     storeField(d.x, "n");
  349.                     d.x.n = d.x.n + 1;
  350.                     break;
  351.                 }
  352.             }
  353.         }
  354.  
  355.         /**
  356.           * Сделать один шаг автомата назад.
  357.           */
  358.         protected void doStepBackward(int level) {
  359.             // Обращение действия в текущем состоянии
  360.             switch (state) {
  361.                 case 1: { // Начало цикла
  362.                     restoreSection();
  363.                     break;
  364.                 }
  365.                 case 2: { // Цикл
  366.                     break;
  367.                 }
  368.                 case 3: { // XZ
  369.                     restoreSection();
  370.                     break;
  371.                 }
  372.                 case 4: { // XZ
  373.                     break;
  374.                 }
  375.                 case 5: { // XZ (окончание)
  376.                     break;
  377.                 }
  378.                 case 6: { // Начало цикла
  379.                     restoreSection();
  380.                     break;
  381.                 }
  382.                 case 7: { // Цикл
  383.                     break;
  384.                 }
  385.                 case 8: { // XZ
  386.                     restoreSection();
  387.                     break;
  388.                 }
  389.                 case 9: { // Начало цикла
  390.                     restoreSection();
  391.                     break;
  392.                 }
  393.                 case 10: { // Цикл
  394.                     break;
  395.                 }
  396.                 case 11: { // XZ
  397.                     restoreSection();
  398.                     break;
  399.                 }
  400.                 case 12: { // Начало цикла
  401.                     restoreSection();
  402.                     break;
  403.                 }
  404.                 case 13: { // Цикл
  405.                     break;
  406.                 }
  407.                 case 14: { // XZ
  408.                     restoreSection();
  409.                     break;
  410.                 }
  411.                 case 15: { // XZ
  412.                     restoreSection();
  413.                     break;
  414.                 }
  415.             }
  416.  
  417.             // Переход в предыдущее состояние
  418.             switch (state) {
  419.                 case 1: { // Начало цикла
  420.                     state = START_STATE;
  421.                     break;
  422.                 }
  423.                 case 2: { // Цикл
  424.                     if (stack.popBoolean()) {
  425.                         state = 3; // XZ
  426.                     } else {
  427.                         state = 1; // Начало цикла
  428.                     }
  429.                     break;
  430.                 }
  431.                 case 3: { // XZ
  432.                     state = 2; // Цикл
  433.                     break;
  434.                 }
  435.                 case 4: { // XZ
  436.                     state = 2; // Цикл
  437.                     break;
  438.                 }
  439.                 case 5: { // XZ (окончание)
  440.                     if (stack.popBoolean()) {
  441.                         state = 7; // Цикл
  442.                     } else {
  443.                         state = 4; // XZ
  444.                     }
  445.                     break;
  446.                 }
  447.                 case 6: { // Начало цикла
  448.                     state = 4; // XZ
  449.                     break;
  450.                 }
  451.                 case 7: { // Цикл
  452.                     if (stack.popBoolean()) {
  453.                         state = 8; // XZ
  454.                     } else {
  455.                         state = 6; // Начало цикла
  456.                     }
  457.                     break;
  458.                 }
  459.                 case 8: { // XZ
  460.                     state = 7; // Цикл
  461.                     break;
  462.                 }
  463.                 case 9: { // Начало цикла
  464.                     state = 5; // XZ (окончание)
  465.                     break;
  466.                 }
  467.                 case 10: { // Цикл
  468.                     if (stack.popBoolean()) {
  469.                         state = 11; // XZ
  470.                     } else {
  471.                         state = 9; // Начало цикла
  472.                     }
  473.                     break;
  474.                 }
  475.                 case 11: { // XZ
  476.                     state = 10; // Цикл
  477.                     break;
  478.                 }
  479.                 case 12: { // Начало цикла
  480.                     state = 10; // Цикл
  481.                     break;
  482.                 }
  483.                 case 13: { // Цикл
  484.                     if (stack.popBoolean()) {
  485.                         state = 14; // XZ
  486.                     } else {
  487.                         state = 12; // Начало цикла
  488.                     }
  489.                     break;
  490.                 }
  491.                 case 14: { // XZ
  492.                     state = 13; // Цикл
  493.                     break;
  494.                 }
  495.                 case 15: { // XZ
  496.                     state = 13; // Цикл
  497.                     break;
  498.                 }
  499.                 case END_STATE: { // Начальное состояние
  500.                     state = 15; // XZ
  501.                     break;
  502.                 }
  503.             }
  504.         }
  505.  
  506.         /**
  507.           * Комментарий к текущему состоянию
  508.           */
  509.         public String getComment() {
  510.             String comment = "";
  511.             Object[] args = null;
  512.             // Выбор комментария
  513.             switch (state) {
  514.             }
  515.  
  516.             return java.text.MessageFormat.format(comment, args);
  517.         }
  518.  
  519.         /**
  520.           * Выполняет действия по отрисовке состояния
  521.           */
  522.         public void drawState() {
  523.             switch (state) {
  524.             }
  525.         }
  526.     }
  527.  
  528.     /**
  529.       * .
  530.       */
  531.     private final class InsertNonfull extends BaseAutomata implements Automata {
  532.         /**
  533.           * Начальное состояние автомата.
  534.           */
  535.         private final int START_STATE = 0;
  536.  
  537.         /**
  538.           * Конечное состояние автомата.
  539.           */
  540.         private final int END_STATE = 23;
  541.  
  542.         /**
  543.           * Конструктор.
  544.           */
  545.         public InsertNonfull() {
  546.             super(
  547.                 "InsertNonfull",
  548.                 0, // Номер начального состояния
  549.                 23, // Номер конечного состояния
  550.                 new String[]{
  551.                     "Начальное состояние",  
  552.                     "XZ",
  553.                     "XZ",
  554.                     "Начало цикла",
  555.                     "Если текущая вершина лист",
  556.                     "Если текущая вершина лист (окончание)",
  557.                     "InThis",
  558.                     "Цикл",
  559.                     "XZ1",
  560.                     "XZ2",
  561.                     "XZ",
  562.                     "Цикл",
  563.                     "XZ1",
  564.                     "XZ2",
  565.                     "XZ",
  566.                     "XZ (окончание)",
  567.                     "XZ",
  568.                     "Разрезает вершину (автомат)",
  569.                     "XZ",
  570.                     "XZ",
  571.                     "XZ (окончание)",
  572.                     "XZ",
  573.                     "XZ",
  574.                     "Конечное состояние"
  575.                 }, new int[]{
  576.                     Integer.MAX_VALUE, // Начальное состояние,  
  577.                     -1, // XZ
  578.                     -1, // XZ
  579.                     -1, // Начало цикла
  580.                     -1, // Если текущая вершина лист
  581.                     -1, // Если текущая вершина лист (окончание)
  582.                     0, // InThis
  583.                     -1, // Цикл
  584.                     -1, // XZ1
  585.                     0, // XZ2
  586.                     0, // XZ
  587.                     -1, // Цикл
  588.                     -1, // XZ1
  589.                     -1, // XZ2
  590.                     -1, // XZ
  591.                     -1, // XZ (окончание)
  592.                     -1, // XZ
  593.                     CALL_AUTO_LEVEL, // Разрезает вершину (автомат)
  594.                     0, // XZ
  595.                     -1, // XZ
  596.                     -1, // XZ (окончание)
  597.                     -1, // XZ
  598.                     0, // XZ
  599.                     Integer.MAX_VALUE, // Конечное состояние
  600.                 }
  601.             );
  602.         }
  603.  
  604.         /**
  605.           * Сделать один шаг автомата в перед.
  606.           */
  607.         protected void doStepForward(int level) {
  608.             // Переход в следующее состояние
  609.             switch (state) {
  610.                 case START_STATE: { // Начальное состояние
  611.                     state = 1; // XZ
  612.                     break;
  613.                 }
  614.                 case 1: { // XZ
  615.                     stack.pushBoolean(false);
  616.                     state = 2; // XZ
  617.                     break;
  618.                 }
  619.                 case 2: { // XZ
  620.                     if (d.InsertNonfull_flag) {
  621.                         state = 3; // Начало цикла
  622.                     } else {
  623.                         state = END_STATE;
  624.                     }
  625.                     break;
  626.                 }
  627.                 case 3: { // Начало цикла
  628.                     state = 4; // Если текущая вершина лист
  629.                     break;
  630.                 }
  631.                 case 4: { // Если текущая вершина лист
  632.                     if (d.x.leaf) {
  633.                         state = 6; // InThis
  634.                     } else {
  635.                         state = 10; // XZ
  636.                     }
  637.                     break;
  638.                 }
  639.                 case 5: { // Если текущая вершина лист (окончание)
  640.                     stack.pushBoolean(true);
  641.                     state = 2; // XZ
  642.                     break;
  643.                 }
  644.                 case 6: { // InThis
  645.                     stack.pushBoolean(false);
  646.                     state = 7; // Цикл
  647.                     break;
  648.                 }
  649.                 case 7: { // Цикл
  650.                     if ((1 <= d.InsertNonfull_i) && (d.k < d.x.keys[d.InsertNonfull_i])) {
  651.                         state = 8; // XZ1
  652.                     } else {
  653.                         state = 9; // XZ2
  654.                     }
  655.                     break;
  656.                 }
  657.                 case 8: { // XZ1
  658.                     stack.pushBoolean(true);
  659.                     state = 7; // Цикл
  660.                     break;
  661.                 }
  662.                 case 9: { // XZ2
  663.                     stack.pushBoolean(true);
  664.                     state = 5; // Если текущая вершина лист (окончание)
  665.                     break;
  666.                 }
  667.                 case 10: { // XZ
  668.                     stack.pushBoolean(false);
  669.                     state = 11; // Цикл
  670.                     break;
  671.                 }
  672.                 case 11: { // Цикл
  673.                     if ((1 <= d.InsertNonfull_i) && (d.k < d.x.keys[d.InsertNonfull_i])) {
  674.                         state = 12; // XZ1
  675.                     } else {
  676.                         state = 13; // XZ2
  677.                     }
  678.                     break;
  679.                 }
  680.                 case 12: { // XZ1
  681.                     stack.pushBoolean(true);
  682.                     state = 11; // Цикл
  683.                     break;
  684.                 }
  685.                 case 13: { // XZ2
  686.                     state = 14; // XZ
  687.                     break;
  688.                 }
  689.                 case 14: { // XZ
  690.                     if (d.x.links[d.InsertNonfull_i].n == 2 * d.t - 1) {
  691.                         state = 16; // XZ
  692.                     } else {
  693.                         stack.pushBoolean(false);
  694.                         state = 15; // XZ (окончание)
  695.                     }
  696.                     break;
  697.                 }
  698.                 case 15: { // XZ (окончание)
  699.                     state = 22; // XZ
  700.                     break;
  701.                 }
  702.                 case 16: { // XZ
  703.                     state = 17; // Разрезает вершину (автомат)
  704.                     break;
  705.                 }
  706.                 case 17: { // Разрезает вершину (автомат)
  707.                     if (child.isAtEnd()) {
  708.                         child = null;
  709.                         state = 18; // XZ
  710.                     }
  711.                     break;
  712.                 }
  713.                 case 18: { // XZ
  714.                     state = 19; // XZ
  715.                     break;
  716.                 }
  717.                 case 19: { // XZ
  718.                     if (d.x.keys[d.InsertNonfull_i] < d.k) {
  719.                         state = 21; // XZ
  720.                     } else {
  721.                         stack.pushBoolean(false);
  722.                         state = 20; // XZ (окончание)
  723.                     }
  724.                     break;
  725.                 }
  726.                 case 20: { // XZ (окончание)
  727.                     stack.pushBoolean(true);
  728.                     state = 15; // XZ (окончание)
  729.                     break;
  730.                 }
  731.                 case 21: { // XZ
  732.                     stack.pushBoolean(true);
  733.                     state = 20; // XZ (окончание)
  734.                     break;
  735.                 }
  736.                 case 22: { // XZ
  737.                     stack.pushBoolean(false);
  738.                     state = 5; // Если текущая вершина лист (окончание)
  739.                     break;
  740.                 }
  741.             }
  742.  
  743.             // Действие в текущем состоянии
  744.             switch (state) {
  745.                 case 1: { // XZ
  746.                     startSection();
  747.                     storeField(d, "InsertNonfull_flag");
  748.                     d.InsertNonfull_flag = true;
  749.                     break;
  750.                 }
  751.                 case 2: { // XZ
  752.                     break;
  753.                 }
  754.                 case 3: { // Начало цикла
  755.                     startSection();
  756.                     storeField(d, "InsertNonfull_i");
  757.                     d.InsertNonfull_i = d.x.n;
  758.                     break;
  759.                 }
  760.                 case 4: { // Если текущая вершина лист
  761.                     break;
  762.                 }
  763.                 case 5: { // Если текущая вершина лист (окончание)
  764.                     break;
  765.                 }
  766.                 case 6: { // InThis
  767.                     startSection();
  768.                     break;
  769.                 }
  770.                 case 7: { // Цикл
  771.                     break;
  772.                 }
  773.                 case 8: { // XZ1
  774.                     startSection();
  775.                     storeArray(d.x.keys, d.InsertNonfull_i + 1);
  776.                     d.x.keys[d.InsertNonfull_i + 1] = d.x.keys[d.InsertNonfull_i];
  777.                     storeField(d, "InsertNonfull_i");
  778.                     d.InsertNonfull_i = d.InsertNonfull_i - 1;
  779.                     break;
  780.                 }
  781.                 case 9: { // XZ2
  782.                     startSection();
  783.                     storeArray(d.x.keys, d.InsertNonfull_i + 1);
  784.                     d.x.keys[d.InsertNonfull_i + 1] = d.k;
  785.                     storeField(d.x, "n");
  786.                     d.x.n = d.x.n + 1;
  787.                     storeField(d, "InsertNonfull_flag");
  788.                     d.InsertNonfull_flag = false;
  789.                     break;
  790.                 }
  791.                 case 10: { // XZ
  792.                     startSection();
  793.                     break;
  794.                 }
  795.                 case 11: { // Цикл
  796.                     break;
  797.                 }
  798.                 case 12: { // XZ1
  799.                     startSection();
  800.                     storeField(d, "InsertNonfull_i");
  801.                     d.InsertNonfull_i = d.InsertNonfull_i - 1;
  802.                     break;
  803.                 }
  804.                 case 13: { // XZ2
  805.                     startSection();
  806.                     storeField(d, "InsertNonfull_i");
  807.                     d.InsertNonfull_i = d.InsertNonfull_i + 1;
  808.                     break;
  809.                 }
  810.                 case 14: { // XZ
  811.                     break;
  812.                 }
  813.                 case 15: { // XZ (окончание)
  814.                     break;
  815.                 }
  816.                 case 16: { // XZ
  817.                     startSection();
  818.                     storeField(d, "m");
  819.                     d.m = d.InsertNonfull_i;
  820.                     storeField(d, "y");
  821.                     d.y = d.x.links[d.InsertNonfull_i];
  822.                     break;
  823.                 }
  824.                 case 17: { // Разрезает вершину (автомат)
  825.                     if (child == null) {
  826.                         child = new SplitChild();
  827.                         child.toStart();
  828.                     }
  829.                     child.stepForward(level);
  830.                     step--;
  831.                     break;
  832.                 }
  833.                 case 18: { // XZ
  834.                     startSection();
  835.                     break;
  836.                 }
  837.                 case 19: { // XZ
  838.                     break;
  839.                 }
  840.                 case 20: { // XZ (окончание)
  841.                     break;
  842.                 }
  843.                 case 21: { // XZ
  844.                     startSection();
  845.                     storeField(d, "InsertNonfull_i");
  846.                     d.InsertNonfull_i = d.InsertNonfull_i + 1;
  847.                     break;
  848.                 }
  849.                 case 22: { // XZ
  850.                     startSection();
  851.                     storeField(d, "x");
  852.                     d.x = d.x.links[d.InsertNonfull_i];
  853.                     break;
  854.                 }
  855.             }
  856.         }
  857.  
  858.         /**
  859.           * Сделать один шаг автомата назад.
  860.           */
  861.         protected void doStepBackward(int level) {
  862.             // Обращение действия в текущем состоянии
  863.             switch (state) {
  864.                 case 1: { // XZ
  865.                     restoreSection();
  866.                     break;
  867.                 }
  868.                 case 2: { // XZ
  869.                     break;
  870.                 }
  871.                 case 3: { // Начало цикла
  872.                     restoreSection();
  873.                     break;
  874.                 }
  875.                 case 4: { // Если текущая вершина лист
  876.                     break;
  877.                 }
  878.                 case 5: { // Если текущая вершина лист (окончание)
  879.                     break;
  880.                 }
  881.                 case 6: { // InThis
  882.                     restoreSection();
  883.                     break;
  884.                 }
  885.                 case 7: { // Цикл
  886.                     break;
  887.                 }
  888.                 case 8: { // XZ1
  889.                     restoreSection();
  890.                     break;
  891.                 }
  892.                 case 9: { // XZ2
  893.                     restoreSection();
  894.                     break;
  895.                 }
  896.                 case 10: { // XZ
  897.                     restoreSection();
  898.                     break;
  899.                 }
  900.                 case 11: { // Цикл
  901.                     break;
  902.                 }
  903.                 case 12: { // XZ1
  904.                     restoreSection();
  905.                     break;
  906.                 }
  907.                 case 13: { // XZ2
  908.                     restoreSection();
  909.                     break;
  910.                 }
  911.                 case 14: { // XZ
  912.                     break;
  913.                 }
  914.                 case 15: { // XZ (окончание)
  915.                     break;
  916.                 }
  917.                 case 16: { // XZ
  918.                     restoreSection();
  919.                     break;
  920.                 }
  921.                 case 17: { // Разрезает вершину (автомат)
  922.                     if (child == null) {
  923.                         child = new SplitChild();
  924.                         child.toEnd();
  925.                     }
  926.                     child.stepBackward(level);
  927.                     step++;
  928.                     break;
  929.                 }
  930.                 case 18: { // XZ
  931.                     restoreSection();
  932.                     break;
  933.                 }
  934.                 case 19: { // XZ
  935.                     break;
  936.                 }
  937.                 case 20: { // XZ (окончание)
  938.                     break;
  939.                 }
  940.                 case 21: { // XZ
  941.                     restoreSection();
  942.                     break;
  943.                 }
  944.                 case 22: { // XZ
  945.                     restoreSection();
  946.                     break;
  947.                 }
  948.             }
  949.  
  950.             // Переход в предыдущее состояние
  951.             switch (state) {
  952.                 case 1: { // XZ
  953.                     state = START_STATE;
  954.                     break;
  955.                 }
  956.                 case 2: { // XZ
  957.                     if (stack.popBoolean()) {
  958.                         state = 5; // Если текущая вершина лист (окончание)
  959.                     } else {
  960.                         state = 1; // XZ
  961.                     }
  962.                     break;
  963.                 }
  964.                 case 3: { // Начало цикла
  965.                     state = 2; // XZ
  966.                     break;
  967.                 }
  968.                 case 4: { // Если текущая вершина лист
  969.                     state = 3; // Начало цикла
  970.                     break;
  971.                 }
  972.                 case 5: { // Если текущая вершина лист (окончание)
  973.                     if (stack.popBoolean()) {
  974.                         state = 9; // XZ2
  975.                     } else {
  976.                         state = 22; // XZ
  977.                     }
  978.                     break;
  979.                 }
  980.                 case 6: { // InThis
  981.                     state = 4; // Если текущая вершина лист
  982.                     break;
  983.                 }
  984.                 case 7: { // Цикл
  985.                     if (stack.popBoolean()) {
  986.                         state = 8; // XZ1
  987.                     } else {
  988.                         state = 6; // InThis
  989.                     }
  990.                     break;
  991.                 }
  992.                 case 8: { // XZ1
  993.                     state = 7; // Цикл
  994.                     break;
  995.                 }
  996.                 case 9: { // XZ2
  997.                     state = 7; // Цикл
  998.                     break;
  999.                 }
  1000.                 case 10: { // XZ
  1001.                     state = 4; // Если текущая вершина лист
  1002.                     break;
  1003.                 }
  1004.                 case 11: { // Цикл
  1005.                     if (stack.popBoolean()) {
  1006.                         state = 12; // XZ1
  1007.                     } else {
  1008.                         state = 10; // XZ
  1009.                     }
  1010.                     break;
  1011.                 }
  1012.                 case 12: { // XZ1
  1013.                     state = 11; // Цикл
  1014.                     break;
  1015.                 }
  1016.                 case 13: { // XZ2
  1017.                     state = 11; // Цикл
  1018.                     break;
  1019.                 }
  1020.                 case 14: { // XZ
  1021.                     state = 13; // XZ2
  1022.                     break;
  1023.                 }
  1024.                 case 15: { // XZ (окончание)
  1025.                     if (stack.popBoolean()) {
  1026.                         state = 20; // XZ (окончание)
  1027.                     } else {
  1028.                         state = 14; // XZ
  1029.                     }
  1030.                     break;
  1031.                 }
  1032.                 case 16: { // XZ
  1033.                     state = 14; // XZ
  1034.                     break;
  1035.                 }
  1036.                 case 17: { // Разрезает вершину (автомат)
  1037.                     if (child.isAtStart()) {
  1038.                         child = null;
  1039.                         state = 16; // XZ
  1040.                     }
  1041.                     break;
  1042.                 }
  1043.                 case 18: { // XZ
  1044.                     state = 17; // Разрезает вершину (автомат)
  1045.                     break;
  1046.                 }
  1047.                 case 19: { // XZ
  1048.                     state = 18; // XZ
  1049.                     break;
  1050.                 }
  1051.                 case 20: { // XZ (окончание)
  1052.                     if (stack.popBoolean()) {
  1053.                         state = 21; // XZ
  1054.                     } else {
  1055.                         state = 19; // XZ
  1056.                     }
  1057.                     break;
  1058.                 }
  1059.                 case 21: { // XZ
  1060.                     state = 19; // XZ
  1061.                     break;
  1062.                 }
  1063.                 case 22: { // XZ
  1064.                     state = 15; // XZ (окончание)
  1065.                     break;
  1066.                 }
  1067.                 case END_STATE: { // Начальное состояние
  1068.                     state = 2; // XZ
  1069.                     break;
  1070.                 }
  1071.             }
  1072.         }
  1073.  
  1074.         /**
  1075.           * Комментарий к текущему состоянию
  1076.           */
  1077.         public String getComment() {
  1078.             String comment = "";
  1079.             Object[] args = null;
  1080.             // Выбор комментария
  1081.             switch (state) {
  1082.                 case 6: { // InThis
  1083.                     comment = BTree.this.getComment("InsertNonfull.DrawStep1");
  1084.                     break;
  1085.                 }
  1086.                 case 9: { // XZ2
  1087.                     comment = BTree.this.getComment("InsertNonfull.StepAfterLoop1");
  1088.                     break;
  1089.                 }
  1090.                 case 10: { // XZ
  1091.                     comment = BTree.this.getComment("InsertNonfull.DrawStep2");
  1092.                     break;
  1093.                 }
  1094.                 case 17: { // Разрезает вершину (автомат)
  1095.                     comment = child.getComment();
  1096.                     args = new Object[0];
  1097.                     break;
  1098.                 }
  1099.                 case 18: { // XZ
  1100.                     comment = BTree.this.getComment("InsertNonfull.test");
  1101.                     break;
  1102.                 }
  1103.                 case 22: { // XZ
  1104.                     comment = BTree.this.getComment("InsertNonfull.FinalStep");
  1105.                     break;
  1106.                 }
  1107.             }
  1108.  
  1109.             return java.text.MessageFormat.format(comment, args);
  1110.         }
  1111.  
  1112.         /**
  1113.           * Выполняет действия по отрисовке состояния
  1114.           */
  1115.         public void drawState() {
  1116.             switch (state) {
  1117.                 case 6: { // InThis
  1118.                     d.visualizer.showTree(d.x);
  1119.                     break;
  1120.                 }
  1121.                 case 9: { // XZ2
  1122.                     d.visualizer.showTree(null);
  1123.                     break;
  1124.                 }
  1125.                 case 10: { // XZ
  1126.                     d.visualizer.showTree(d.x);
  1127.                     break;
  1128.                 }
  1129.                 case 17: { // Разрезает вершину (автомат)
  1130.                     child.drawState();
  1131.                     break;
  1132.                 }
  1133.                 case 18: { // XZ
  1134.                     d.visualizer.showTree(null);
  1135.                     break;
  1136.                 }
  1137.                 case 22: { // XZ
  1138.                     d.visualizer.showTree(null);
  1139.                     break;
  1140.                 }
  1141.             }
  1142.         }
  1143.     }
  1144.  
  1145.     /**
  1146.       * Добавляет ключ в дерево.
  1147.       */
  1148.     private final class Insert extends BaseAutomata implements Automata {
  1149.         /**
  1150.           * Начальное состояние автомата.
  1151.           */
  1152.         private final int START_STATE = 0;
  1153.  
  1154.         /**
  1155.           * Конечное состояние автомата.
  1156.           */
  1157.         private final int END_STATE = 9;
  1158.  
  1159.         /**
  1160.           * Конструктор.
  1161.           */
  1162.         public Insert() {
  1163.             super(
  1164.                 "Insert",
  1165.                 0, // Номер начального состояния
  1166.                 9, // Номер конечного состояния
  1167.                 new String[]{
  1168.                     "Начальное состояние",  
  1169.                     "XZ",
  1170.                     "Если корень полный",
  1171.                     "Если корень полный (окончание)",
  1172.                     "XZ",
  1173.                     "Разрезает вершину (автомат)",
  1174.                     "XZ",
  1175.                     " (автомат)",
  1176.                     " (автомат)",
  1177.                     "Конечное состояние"
  1178.                 }, new int[]{
  1179.                     Integer.MAX_VALUE, // Начальное состояние,  
  1180.                     -1, // XZ
  1181.                     -1, // Если корень полный
  1182.                     -1, // Если корень полный (окончание)
  1183.                     -1, // XZ
  1184.                     CALL_AUTO_LEVEL, // Разрезает вершину (автомат)
  1185.                     0, // XZ
  1186.                     CALL_AUTO_LEVEL, //  (автомат)
  1187.                     CALL_AUTO_LEVEL, //  (автомат)
  1188.                     Integer.MAX_VALUE, // Конечное состояние
  1189.                 }
  1190.             );
  1191.         }
  1192.  
  1193.         /**
  1194.           * Сделать один шаг автомата в перед.
  1195.           */
  1196.         protected void doStepForward(int level) {
  1197.             // Переход в следующее состояние
  1198.             switch (state) {
  1199.                 case START_STATE: { // Начальное состояние
  1200.                     state = 1; // XZ
  1201.                     break;
  1202.                 }
  1203.                 case 1: { // XZ
  1204.                     state = 2; // Если корень полный
  1205.                     break;
  1206.                 }
  1207.                 case 2: { // Если корень полный
  1208.                     if (d.y.n == 2 * d.t - 1) {
  1209.                         state = 4; // XZ
  1210.                     } else {
  1211.                         state = 8; //  (автомат)
  1212.                     }
  1213.                     break;
  1214.                 }
  1215.                 case 3: { // Если корень полный (окончание)
  1216.                     state = END_STATE;
  1217.                     break;
  1218.                 }
  1219.                 case 4: { // XZ
  1220.                     state = 5; // Разрезает вершину (автомат)
  1221.                     break;
  1222.                 }
  1223.                 case 5: { // Разрезает вершину (автомат)
  1224.                     if (child.isAtEnd()) {
  1225.                         child = null;
  1226.                         state = 6; // XZ
  1227.                     }
  1228.                     break;
  1229.                 }
  1230.                 case 6: { // XZ
  1231.                     state = 7; //  (автомат)
  1232.                     break;
  1233.                 }
  1234.                 case 7: { //  (автомат)
  1235.                     if (child.isAtEnd()) {
  1236.                         child = null;
  1237.                         stack.pushBoolean(true);
  1238.                         state = 3; // Если корень полный (окончание)
  1239.                     }
  1240.                     break;
  1241.                 }
  1242.                 case 8: { //  (автомат)
  1243.                     if (child.isAtEnd()) {
  1244.                         child = null;
  1245.                         stack.pushBoolean(false);
  1246.                         state = 3; // Если корень полный (окончание)
  1247.                     }
  1248.                     break;
  1249.                 }
  1250.             }
  1251.  
  1252.             // Действие в текущем состоянии
  1253.             switch (state) {
  1254.                 case 1: { // XZ
  1255.                     startSection();
  1256.                     storeField(d, "sRu");
  1257.                     d.sRu = new String("Готово! Ключ вставлен на нужное место.");
  1258.                     storeField(d, "sEn");
  1259.                     d.sEn = new String("Completed!");
  1260.                    
  1261.                     storeField(d, "x");
  1262.                     d.x = d.root;
  1263.                     storeField(d, "y");
  1264.                     d.y = d.root;
  1265.                     break;
  1266.                 }
  1267.                 case 2: { // Если корень полный
  1268.                     break;
  1269.                 }
  1270.                 case 3: { // Если корень полный (окончание)
  1271.                     break;
  1272.                 }
  1273.                 case 4: { // XZ
  1274.                     startSection();
  1275.                     storeField(d, "x");
  1276.                     d.x = new treeNode();
  1277.                     storeField(d, "root");
  1278.                     d.root = d.x;
  1279.                     storeField(d.x, "leaf");
  1280.                     d.x.leaf = false;
  1281.                     storeField(d.x, "n");
  1282.                     d.x.n = 0;
  1283.                     storeArray(d.x.links, 1);
  1284.                     d.x.links[1] = d.y;
  1285.                     storeField(d, "m");
  1286.                     d.m = 1;
  1287.                     break;
  1288.                 }
  1289.                 case 5: { // Разрезает вершину (автомат)
  1290.                     if (child == null) {
  1291.                         child = new SplitChild();
  1292.                         child.toStart();
  1293.                     }
  1294.                     child.stepForward(level);
  1295.                     step--;
  1296.                     break;
  1297.                 }
  1298.                 case 6: { // XZ
  1299.                     startSection();
  1300.                     storeField(d, "x");
  1301.                     d.x = d.root;
  1302.                     break;
  1303.                 }
  1304.                 case 7: { //  (автомат)
  1305.                     if (child == null) {
  1306.                         child = new InsertNonfull();
  1307.                         child.toStart();
  1308.                     }
  1309.                     child.stepForward(level);
  1310.                     step--;
  1311.                     break;
  1312.                 }
  1313.                 case 8: { //  (автомат)
  1314.                     if (child == null) {
  1315.                         child = new InsertNonfull();
  1316.                         child.toStart();
  1317.                     }
  1318.                     child.stepForward(level);
  1319.                     step--;
  1320.                     break;
  1321.                 }
  1322.             }
  1323.         }
  1324.  
  1325.         /**
  1326.           * Сделать один шаг автомата назад.
  1327.           */
  1328.         protected void doStepBackward(int level) {
  1329.             // Обращение действия в текущем состоянии
  1330.             switch (state) {
  1331.                 case 1: { // XZ
  1332.                     restoreSection();
  1333.                     break;
  1334.                 }
  1335.                 case 2: { // Если корень полный
  1336.                     break;
  1337.                 }
  1338.                 case 3: { // Если корень полный (окончание)
  1339.                     break;
  1340.                 }
  1341.                 case 4: { // XZ
  1342.                     restoreSection();
  1343.                     break;
  1344.                 }
  1345.                 case 5: { // Разрезает вершину (автомат)
  1346.                     if (child == null) {
  1347.                         child = new SplitChild();
  1348.                         child.toEnd();
  1349.                     }
  1350.                     child.stepBackward(level);
  1351.                     step++;
  1352.                     break;
  1353.                 }
  1354.                 case 6: { // XZ
  1355.                     restoreSection();
  1356.                     break;
  1357.                 }
  1358.                 case 7: { //  (автомат)
  1359.                     if (child == null) {
  1360.                         child = new InsertNonfull();
  1361.                         child.toEnd();
  1362.                     }
  1363.                     child.stepBackward(level);
  1364.                     step++;
  1365.                     break;
  1366.                 }
  1367.                 case 8: { //  (автомат)
  1368.                     if (child == null) {
  1369.                         child = new InsertNonfull();
  1370.                         child.toEnd();
  1371.                     }
  1372.                     child.stepBackward(level);
  1373.                     step++;
  1374.                     break;
  1375.                 }
  1376.             }
  1377.  
  1378.             // Переход в предыдущее состояние
  1379.             switch (state) {
  1380.                 case 1: { // XZ
  1381.                     state = START_STATE;
  1382.                     break;
  1383.                 }
  1384.                 case 2: { // Если корень полный
  1385.                     state = 1; // XZ
  1386.                     break;
  1387.                 }
  1388.                 case 3: { // Если корень полный (окончание)
  1389.                     if (stack.popBoolean()) {
  1390.                         state = 7; //  (автомат)
  1391.                     } else {
  1392.                         state = 8; //  (автомат)
  1393.                     }
  1394.                     break;
  1395.                 }
  1396.                 case 4: { // XZ
  1397.                     state = 2; // Если корень полный
  1398.                     break;
  1399.                 }
  1400.                 case 5: { // Разрезает вершину (автомат)
  1401.                     if (child.isAtStart()) {
  1402.                         child = null;
  1403.                         state = 4; // XZ
  1404.                     }
  1405.                     break;
  1406.                 }
  1407.                 case 6: { // XZ
  1408.                     state = 5; // Разрезает вершину (автомат)
  1409.                     break;
  1410.                 }
  1411.                 case 7: { //  (автомат)
  1412.                     if (child.isAtStart()) {
  1413.                         child = null;
  1414.                         state = 6; // XZ
  1415.                     }
  1416.                     break;
  1417.                 }
  1418.                 case 8: { //  (автомат)
  1419.                     if (child.isAtStart()) {
  1420.                         child = null;
  1421.                         state = 2; // Если корень полный
  1422.                     }
  1423.                     break;
  1424.                 }
  1425.                 case END_STATE: { // Начальное состояние
  1426.                     state = 3; // Если корень полный (окончание)
  1427.                     break;
  1428.                 }
  1429.             }
  1430.         }
  1431.  
  1432.         /**
  1433.           * Комментарий к текущему состоянию
  1434.           */
  1435.         public String getComment() {
  1436.             String comment = "";
  1437.             Object[] args = null;
  1438.             // Выбор комментария
  1439.             switch (state) {
  1440.                 case 5: { // Разрезает вершину (автомат)
  1441.                     comment = child.getComment();
  1442.                     args = new Object[0];
  1443.                     break;
  1444.                 }
  1445.                 case 6: { // XZ
  1446.                     comment = BTree.this.getComment("Insert.test");
  1447.                     break;
  1448.                 }
  1449.                 case 7: { //  (автомат)
  1450.                     comment = child.getComment();
  1451.                     args = new Object[0];
  1452.                     break;
  1453.                 }
  1454.                 case 8: { //  (автомат)
  1455.                     comment = child.getComment();
  1456.                     args = new Object[0];
  1457.                     break;
  1458.                 }
  1459.             }
  1460.  
  1461.             return java.text.MessageFormat.format(comment, args);
  1462.         }
  1463.  
  1464.         /**
  1465.           * Выполняет действия по отрисовке состояния
  1466.           */
  1467.         public void drawState() {
  1468.             switch (state) {
  1469.                 case 1: { // XZ
  1470.                     d.visualizer.showTree(null);
  1471.                     break;
  1472.                 }
  1473.                 case 5: { // Разрезает вершину (автомат)
  1474.                     child.drawState();
  1475.                     break;
  1476.                 }
  1477.                 case 6: { // XZ
  1478.                     d.visualizer.showTree(null);
  1479.                     break;
  1480.                 }
  1481.                 case 7: { //  (автомат)
  1482.                     child.drawState();
  1483.                     break;
  1484.                 }
  1485.                 case 8: { //  (автомат)
  1486.                     child.drawState();
  1487.                     break;
  1488.                 }
  1489.             }
  1490.         }
  1491.     }
  1492.  
  1493.     /**
  1494.       * Удаляет ключ из дерева.
  1495.       */
  1496.     private final class Delete extends BaseAutomata implements Automata {
  1497.         /**
  1498.           * Начальное состояние автомата.
  1499.           */
  1500.         private final int START_STATE = 0;
  1501.  
  1502.         /**
  1503.           * Конечное состояние автомата.
  1504.           */
  1505.         private final int END_STATE = 2;
  1506.  
  1507.         /**
  1508.           * Конструктор.
  1509.           */
  1510.         public Delete() {
  1511.             super(
  1512.                 "Delete",
  1513.                 0, // Номер начального состояния
  1514.                 2, // Номер конечного состояния
  1515.                 new String[]{
  1516.                     "Начальное состояние",  
  1517.                     "Начало цикла",
  1518.                     "Конечное состояние"
  1519.                 }, new int[]{
  1520.                     Integer.MAX_VALUE, // Начальное состояние,  
  1521.                     -1, // Начало цикла
  1522.                     Integer.MAX_VALUE, // Конечное состояние
  1523.                 }
  1524.             );
  1525.         }
  1526.  
  1527.         /**
  1528.           * Сделать один шаг автомата в перед.
  1529.           */
  1530.         protected void doStepForward(int level) {
  1531.             // Переход в следующее состояние
  1532.             switch (state) {
  1533.                 case START_STATE: { // Начальное состояние
  1534.                     state = 1; // Начало цикла
  1535.                     break;
  1536.                 }
  1537.                 case 1: { // Начало цикла
  1538.                     state = END_STATE;
  1539.                     break;
  1540.                 }
  1541.             }
  1542.  
  1543.             // Действие в текущем состоянии
  1544.             switch (state) {
  1545.                 case 1: { // Начало цикла
  1546.                     startSection();
  1547.                     break;
  1548.                 }
  1549.             }
  1550.         }
  1551.  
  1552.         /**
  1553.           * Сделать один шаг автомата назад.
  1554.           */
  1555.         protected void doStepBackward(int level) {
  1556.             // Обращение действия в текущем состоянии
  1557.             switch (state) {
  1558.                 case 1: { // Начало цикла
  1559.                     restoreSection();
  1560.                     break;
  1561.                 }
  1562.             }
  1563.  
  1564.             // Переход в предыдущее состояние
  1565.             switch (state) {
  1566.                 case 1: { // Начало цикла
  1567.                     state = START_STATE;
  1568.                     break;
  1569.                 }
  1570.                 case END_STATE: { // Начальное состояние
  1571.                     state = 1; // Начало цикла
  1572.                     break;
  1573.                 }
  1574.             }
  1575.         }
  1576.  
  1577.         /**
  1578.           * Комментарий к текущему состоянию
  1579.           */
  1580.         public String getComment() {
  1581.             String comment = "";
  1582.             Object[] args = null;
  1583.             // Выбор комментария
  1584.             switch (state) {
  1585.             }
  1586.  
  1587.             return java.text.MessageFormat.format(comment, args);
  1588.         }
  1589.  
  1590.         /**
  1591.           * Выполняет действия по отрисовке состояния
  1592.           */
  1593.         public void drawState() {
  1594.             switch (state) {
  1595.             }
  1596.         }
  1597.     }
  1598.  
  1599.     /**
  1600.       * Главный автомат.
  1601.       */
  1602.     private final class Main extends BaseAutomata implements Automata {
  1603.         /**
  1604.           * Начальное состояние автомата.
  1605.           */
  1606.         private final int START_STATE = 0;
  1607.  
  1608.         /**
  1609.           * Конечное состояние автомата.
  1610.           */
  1611.         private final int END_STATE = 7;
  1612.  
  1613.         /**
  1614.           * Конструктор.
  1615.           */
  1616.         public Main() {
  1617.             super(
  1618.                 "Main",
  1619.                 0, // Номер начального состояния
  1620.                 7, // Номер конечного состояния
  1621.                 new String[]{
  1622.                     "Начальное состояние",  
  1623.                     "Выбрано добавление",
  1624.                     "Выбрано добавление (окончание)",
  1625.                     "Добавляет ключ в дерево (автомат)",
  1626.                     "Выбрано удаление",
  1627.                     "Выбрано удаление (окончание)",
  1628.                     "Удаляет ключ из дерева (автомат)",
  1629.                     "Конечное состояние"
  1630.                 }, new int[]{
  1631.                     Integer.MAX_VALUE, // Начальное состояние,  
  1632.                     -1, // Выбрано добавление
  1633.                     -1, // Выбрано добавление (окончание)
  1634.                     CALL_AUTO_LEVEL, // Добавляет ключ в дерево (автомат)
  1635.                     -1, // Выбрано удаление
  1636.                     -1, // Выбрано удаление (окончание)
  1637.                     CALL_AUTO_LEVEL, // Удаляет ключ из дерева (автомат)
  1638.                     Integer.MAX_VALUE, // Конечное состояние
  1639.                 }
  1640.             );
  1641.         }
  1642.  
  1643.         /**
  1644.           * Сделать один шаг автомата в перед.
  1645.           */
  1646.         protected void doStepForward(int level) {
  1647.             // Переход в следующее состояние
  1648.             switch (state) {
  1649.                 case START_STATE: { // Начальное состояние
  1650.                     state = 1; // Выбрано добавление
  1651.                     break;
  1652.                 }
  1653.                 case 1: { // Выбрано добавление
  1654.                     if (d.visualizer.combobox1.getSelectedIndex() == 0) {
  1655.                         state = 3; // Добавляет ключ в дерево (автомат)
  1656.                     } else {
  1657.                         stack.pushBoolean(false);
  1658.                         state = 2; // Выбрано добавление (окончание)
  1659.                     }
  1660.                     break;
  1661.                 }
  1662.                 case 2: { // Выбрано добавление (окончание)
  1663.                     state = 4; // Выбрано удаление
  1664.                     break;
  1665.                 }
  1666.                 case 3: { // Добавляет ключ в дерево (автомат)
  1667.                     if (child.isAtEnd()) {
  1668.                         child = null;
  1669.                         stack.pushBoolean(true);
  1670.                         state = 2; // Выбрано добавление (окончание)
  1671.                     }
  1672.                     break;
  1673.                 }
  1674.                 case 4: { // Выбрано удаление
  1675.                     if (d.visualizer.combobox1.getSelectedIndex() == 1) {
  1676.                         state = 6; // Удаляет ключ из дерева (автомат)
  1677.                     } else {
  1678.                         stack.pushBoolean(false);
  1679.                         state = 5; // Выбрано удаление (окончание)
  1680.                     }
  1681.                     break;
  1682.                 }
  1683.                 case 5: { // Выбрано удаление (окончание)
  1684.                     state = END_STATE;
  1685.                     break;
  1686.                 }
  1687.                 case 6: { // Удаляет ключ из дерева (автомат)
  1688.                     if (child.isAtEnd()) {
  1689.                         child = null;
  1690.                         stack.pushBoolean(true);
  1691.                         state = 5; // Выбрано удаление (окончание)
  1692.                     }
  1693.                     break;
  1694.                 }
  1695.             }
  1696.  
  1697.             // Действие в текущем состоянии
  1698.             switch (state) {
  1699.                 case 1: { // Выбрано добавление
  1700.                     break;
  1701.                 }
  1702.                 case 2: { // Выбрано добавление (окончание)
  1703.                     break;
  1704.                 }
  1705.                 case 3: { // Добавляет ключ в дерево (автомат)
  1706.                     if (child == null) {
  1707.                         child = new Insert();
  1708.                         child.toStart();
  1709.                     }
  1710.                     child.stepForward(level);
  1711.                     step--;
  1712.                     break;
  1713.                 }
  1714.                 case 4: { // Выбрано удаление
  1715.                     break;
  1716.                 }
  1717.                 case 5: { // Выбрано удаление (окончание)
  1718.                     break;
  1719.                 }
  1720.                 case 6: { // Удаляет ключ из дерева (автомат)
  1721.                     if (child == null) {
  1722.                         child = new Delete();
  1723.                         child.toStart();
  1724.                     }
  1725.                     child.stepForward(level);
  1726.                     step--;
  1727.                     break;
  1728.                 }
  1729.             }
  1730.         }
  1731.  
  1732.         /**
  1733.           * Сделать один шаг автомата назад.
  1734.           */
  1735.         protected void doStepBackward(int level) {
  1736.             // Обращение действия в текущем состоянии
  1737.             switch (state) {
  1738.                 case 1: { // Выбрано добавление
  1739.                     break;
  1740.                 }
  1741.                 case 2: { // Выбрано добавление (окончание)
  1742.                     break;
  1743.                 }
  1744.                 case 3: { // Добавляет ключ в дерево (автомат)
  1745.                     if (child == null) {
  1746.                         child = new Insert();
  1747.                         child.toEnd();
  1748.                     }
  1749.                     child.stepBackward(level);
  1750.                     step++;
  1751.                     break;
  1752.                 }
  1753.                 case 4: { // Выбрано удаление
  1754.                     break;
  1755.                 }
  1756.                 case 5: { // Выбрано удаление (окончание)
  1757.                     break;
  1758.                 }
  1759.                 case 6: { // Удаляет ключ из дерева (автомат)
  1760.                     if (child == null) {
  1761.                         child = new Delete();
  1762.                         child.toEnd();
  1763.                     }
  1764.                     child.stepBackward(level);
  1765.                     step++;
  1766.                     break;
  1767.                 }
  1768.             }
  1769.  
  1770.             // Переход в предыдущее состояние
  1771.             switch (state) {
  1772.                 case 1: { // Выбрано добавление
  1773.                     state = START_STATE;
  1774.                     break;
  1775.                 }
  1776.                 case 2: { // Выбрано добавление (окончание)
  1777.                     if (stack.popBoolean()) {
  1778.                         state = 3; // Добавляет ключ в дерево (автомат)
  1779.                     } else {
  1780.                         state = 1; // Выбрано добавление
  1781.                     }
  1782.                     break;
  1783.                 }
  1784.                 case 3: { // Добавляет ключ в дерево (автомат)
  1785.                     if (child.isAtStart()) {
  1786.                         child = null;
  1787.                         state = 1; // Выбрано добавление
  1788.                     }
  1789.                     break;
  1790.                 }
  1791.                 case 4: { // Выбрано удаление
  1792.                     state = 2; // Выбрано добавление (окончание)
  1793.                     break;
  1794.                 }
  1795.                 case 5: { // Выбрано удаление (окончание)
  1796.                     if (stack.popBoolean()) {
  1797.                         state = 6; // Удаляет ключ из дерева (автомат)
  1798.                     } else {
  1799.                         state = 4; // Выбрано удаление
  1800.                     }
  1801.                     break;
  1802.                 }
  1803.                 case 6: { // Удаляет ключ из дерева (автомат)
  1804.                     if (child.isAtStart()) {
  1805.                         child = null;
  1806.                         state = 4; // Выбрано удаление
  1807.                     }
  1808.                     break;
  1809.                 }
  1810.                 case END_STATE: { // Начальное состояние
  1811.                     state = 5; // Выбрано удаление (окончание)
  1812.                     break;
  1813.                 }
  1814.             }
  1815.         }
  1816.  
  1817.         /**
  1818.           * Комментарий к текущему состоянию
  1819.           */
  1820.         public String getComment() {
  1821.             String comment = "";
  1822.             Object[] args = null;
  1823.             // Выбор комментария
  1824.             switch (state) {
  1825.                 case START_STATE: { // Начальное состояние
  1826.                     comment = BTree.this.getComment("Main.START_STATE");
  1827.                     break;
  1828.                 }
  1829.                 case 3: { // Добавляет ключ в дерево (автомат)
  1830.                     comment = child.getComment();
  1831.                     args = new Object[0];
  1832.                     break;
  1833.                 }
  1834.                 case 6: { // Удаляет ключ из дерева (автомат)
  1835.                     comment = child.getComment();
  1836.                     args = new Object[0];
  1837.                     break;
  1838.                 }
  1839.                 case END_STATE: { // Конечное состояние
  1840.                     comment = BTree.this.getComment("Main.END_STATE");
  1841.                     args = new Object[]{new String(d.sRu), new String(d.sEn)};
  1842.                     break;
  1843.                 }
  1844.             }
  1845.  
  1846.             return java.text.MessageFormat.format(comment, args);
  1847.         }
  1848.  
  1849.         /**
  1850.           * Выполняет действия по отрисовке состояния
  1851.           */
  1852.         public void drawState() {
  1853.             switch (state) {
  1854.                 case START_STATE: { // Начальное состояние
  1855.                     d.visualizer.showTree(null);
  1856.                     break;
  1857.                 }
  1858.                 case 3: { // Добавляет ключ в дерево (автомат)
  1859.                     child.drawState();
  1860.                     break;
  1861.                 }
  1862.                 case 6: { // Удаляет ключ из дерева (автомат)
  1863.                     child.drawState();
  1864.                     break;
  1865.                 }
  1866.                 case END_STATE: { // Конечное состояние
  1867.                     d.visualizer.showTree(null);
  1868.                     break;
  1869.                 }
  1870.             }
  1871.         }
  1872.     }
  1873. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!