ПредметСтруктури.ц

взяти визначення МаМа;

секція МаМа {
  місцева дія виділити_предмет_структури(М: адреса<Машина>, назва: адреса<Назва>, предок: адреса<ПредметСтруктури>): адреса<ПредметСтруктури> {
    ціль предмет_структури = виділити_предмет<ПредметСтруктури>(М, М.предмет_структури_Структура);

    предмет_структури.властивості = зробити_реєстр<адреса<Назва>, адреса<Предмет>>(М, перевірити_чи_назви_рівні);
    предмет_структури.назва = назва;
    предмет_структури.предок = предок;
    предмет_структури.параметри = виділити_реєстр<адреса<Назва>, Параметр>(М, перевірити_чи_назви_рівні);
    якщо предок != пусто {
      змінна ціль пп: позитивне = 0;
      поки пп < предок.параметри.розмір {
        змінити_в_реєстрі<адреса<Назва>, Параметр>(М, предмет_структури.параметри, предок.параметри.елементи[пп].ключ, предок.параметри.елементи[пп].значення);
        пп += 1;
      }
    }
    предмет_структури.методи = зробити_реєстр<адреса<Назва>, адреса<Предмет>>(М, перевірити_чи_назви_рівні);
    предмет_структури.середовище_створення = пусто;

    вернути предмет_структури;
  }

  // мітка: прохід по типах предметів
  місцева дія додати_метод_до_предмета_структури(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, назва: адреса<Назва>, предмет_дії: адреса<Предмет>): предмет_або_стан_падіння {
    якщо предмет_структури == М.предмет_структури_Структура {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_Дія {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_НативнаДія {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_число {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_текст {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_юнікод {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_Модуль {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_список {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_словник {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_логічне {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_байти {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    якщо предмет_структури == М.предмет_структури_адреса {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати метод") як адреса<Предмет>;
    }
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи::адреса, назва, предмет_дії);
    вернути пусто;
  }

  місцева дія звільнити_предмет_структури(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>) {
    звільнити_значення_реєстру<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.властивості);
    звільнити_реєстр_параметрів(М, предмет_структури.параметри);
    звільнити_значення_реєстру<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.методи);
    звільнити(М, предмет_структури);
  }

  // мітка: прохід по типах предметів
  місцева дія предмет_структури_виконати(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    якщо предмет_структури == М.предмет_структури_предмет {
      ціль складений_предмет = виділити_складений_предмет(М, предмет_структури);
      якщо іменовані_аргументи != пусто {
        змінна ціль па: позитивне = 0;
        поки па < іменовані_аргументи.розмір {
          ціль елемент_аргумента_з_назвою = іменовані_аргументи.елементи[па];
          змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, складений_предмет.властивості::адреса, елемент_аргумента_з_назвою.ключ, елемент_аргумента_з_назвою.значення);
          па += 1;
        }
      }
      вернути складений_предмет як адреса<Предмет>;
    } інакше якщо предмет_структури == М.предмет_структури_Структура {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо створити предмет структури вручну") як адреса<Предмет>;
    } інакше якщо предмет_структури == М.предмет_структури_Дія {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо створити предмет дії вручну") як адреса<Предмет>;
    } інакше якщо предмет_структури == М.предмет_структури_НативнаДія {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо створити предмет нативної дії вручну") як адреса<Предмет>;
    } інакше якщо предмет_структури == М.предмет_структури_число {
      змінна ціль знайдено_предмет_аргумента_значення = ні;
      змінна ціль предмет_аргумента_значення: адреса<Предмет> = пусто;
      якщо іменовані_аргументи != пусто {
        ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
        якщо елемент_значення != пусто {
          знайдено_предмет_аргумента_значення = так;
          предмет_аргумента_значення = елемент_значення.значення;
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        якщо аргументи != пусто {
          якщо аргументи.розмір > 0 {
            знайдено_предмет_аргумента_значення = так;
            предмет_аргумента_значення = аргументи.дані[0];
          }
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        увімкнути_стан_падіння(М, пусто);
        вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
      }
      якщо предмет_аргумента_значення.тип == М.предмет_структури_число {
        вернути предмет_аргумента_значення;
      }
      вернути предмет_числове(предмет_аргумента_значення, М);
    } інакше якщо предмет_структури == М.предмет_структури_текст {
      змінна ціль знайдено_предмет_аргумента_значення = ні;
      змінна ціль предмет_аргумента_значення: адреса<Предмет> = пусто;
      якщо іменовані_аргументи != пусто {
        ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
        якщо елемент_значення != пусто {
          знайдено_предмет_аргумента_значення = так;
          предмет_аргумента_значення = елемент_значення.значення;
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        якщо аргументи != пусто {
          якщо аргументи.розмір > 0 {
            знайдено_предмет_аргумента_значення = так;
            предмет_аргумента_значення = аргументи.дані[0];
          }
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        увімкнути_стан_падіння(М, пусто);
        вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
      }
      якщо предмет_аргумента_значення.тип == М.предмет_структури_текст {
        вернути предмет_аргумента_значення;
      }
      вернути предмет_виконати_властивість(предмет_аргумента_значення, М, М.БН.С.чародія_текст, пусто, пусто);
    } інакше якщо предмет_структури == М.предмет_структури_юнікод {
      змінна ціль знайдено_предмет_аргумента_значення = ні;
      змінна ціль предмет_аргумента_значення: адреса<Предмет> = пусто;
      якщо іменовані_аргументи != пусто {
        ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
        якщо елемент_значення != пусто {
          знайдено_предмет_аргумента_значення = так;
          предмет_аргумента_значення = елемент_значення.значення;
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        якщо аргументи != пусто {
          якщо аргументи.розмір > 0 {
            знайдено_предмет_аргумента_значення = так;
            предмет_аргумента_значення = аргументи.дані[0];
          }
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        увімкнути_стан_падіння(М, пусто);
        вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
      }
      якщо предмет_аргумента_значення.тип == М.предмет_структури_юнікод {
        вернути предмет_аргумента_значення;
      }
      вернути предмет_виконати_властивість(предмет_аргумента_значення, М, М.БН.С.чародія_юнікод, пусто, пусто);
    } інакше якщо предмет_структури == М.предмет_структури_Модуль {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо створити предмет модуля вручну") як адреса<Предмет>;
    } інакше якщо предмет_структури == М.предмет_структури_список {
      змінна ціль знайдено_предмет_аргумента_значення = ні;
      змінна ціль предмет_аргумента_значення: адреса<Предмет> = пусто;
      якщо іменовані_аргументи != пусто {
        ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
        якщо елемент_значення != пусто {
          знайдено_предмет_аргумента_значення = так;
          предмет_аргумента_значення = елемент_значення.значення;
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        якщо аргументи != пусто {
          якщо аргументи.розмір > 0 {
            знайдено_предмет_аргумента_значення = так;
            предмет_аргумента_значення = аргументи.дані[0];
          }
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        увімкнути_стан_падіння(М, пусто);
        вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
      }
      вернути предмет_виконати_властивість(предмет_аргумента_значення, М, М.БН.С.чародія_список, пусто, пусто);
    } інакше якщо предмет_структури == М.предмет_структури_словник {
      змінна ціль знайдено_предмет_аргумента_значення = ні;
      змінна ціль предмет_аргумента_значення: адреса<Предмет> = пусто;
      якщо іменовані_аргументи != пусто {
        ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
        якщо елемент_значення != пусто {
          знайдено_предмет_аргумента_значення = так;
          предмет_аргумента_значення = елемент_значення.значення;
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        якщо аргументи != пусто {
          якщо аргументи.розмір > 0 {
            знайдено_предмет_аргумента_значення = так;
            предмет_аргумента_значення = аргументи.дані[0];
          }
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        увімкнути_стан_падіння(М, пусто);
        вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
      }
      вернути предмет_виконати_властивість(предмет_аргумента_значення, М, М.БН.С.чародія_словник, пусто, пусто);
    } інакше якщо предмет_структури == М.предмет_структури_логічне {
      змінна ціль знайдено_предмет_аргумента_значення = ні;
      змінна ціль предмет_аргумента_значення: адреса<Предмет> = пусто;
      якщо іменовані_аргументи != пусто {
        ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
        якщо елемент_значення != пусто {
          знайдено_предмет_аргумента_значення = так;
          предмет_аргумента_значення = елемент_значення.значення;
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        якщо аргументи != пусто {
          якщо аргументи.розмір > 0 {
            знайдено_предмет_аргумента_значення = так;
            предмет_аргумента_значення = аргументи.дані[0];
          }
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        увімкнути_стан_падіння(М, пусто);
        вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
      }
      якщо перевірити_чи_предмет_виражається_логічним_так(предмет_аргумента_значення, М) {
        вернути М.предмет_логічного_так як адреса<Предмет>;
      }
      вернути М.предмет_логічного_ні як адреса<Предмет>;
    } інакше якщо предмет_структури == М.предмет_структури_байти {
      змінна ціль знайдено_предмет_аргумента_значення = ні;
      змінна ціль предмет_аргумента_значення: адреса<Предмет> = пусто;
      якщо іменовані_аргументи != пусто {
        ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
        якщо елемент_значення != пусто {
          знайдено_предмет_аргумента_значення = так;
          предмет_аргумента_значення = елемент_значення.значення;
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        якщо аргументи != пусто {
          якщо аргументи.розмір > 0 {
            знайдено_предмет_аргумента_значення = так;
            предмет_аргумента_значення = аргументи.дані[0];
          }
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        увімкнути_стан_падіння(М, пусто);
        вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
      }
      якщо перевірити_чи_предмет_є_числом(предмет_аргумента_значення, М) == так {
        ціль предмет_числа_аргумента_значення = предмет_аргумента_значення як адреса<ПредметЧисла>;
        ціль значення_числа_аргумента_значення = предмет_числа_аргумента_значення.значення;
        ціль предмет_байтів = виділити_предмет_байтів(М, позитивне(значення_числа_аргумента_значення));
        вернути предмет_байтів як адреса<Предмет>;
      }
      вернути предмет_виконати_властивість(предмет_аргумента_значення, М, М.БН.С.чародія_байти, пусто, пусто);
    } інакше якщо предмет_структури == М.предмет_структури_адреса {
      змінна ціль знайдено_предмет_аргумента_значення = ні;
      змінна ціль предмет_аргумента_значення: адреса<Предмет> = пусто;
      якщо іменовані_аргументи != пусто {
        ціль елемент_значення = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, М.БН.С.значення);
        якщо елемент_значення != пусто {
          знайдено_предмет_аргумента_значення = так;
          предмет_аргумента_значення = елемент_значення.значення;
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        якщо аргументи != пусто {
          якщо аргументи.розмір > 0 {
            знайдено_предмет_аргумента_значення = так;
            предмет_аргумента_значення = аргументи.дані[0];
          }
        }
      }
      якщо знайдено_предмет_аргумента_значення == ні {
        увімкнути_стан_падіння(М, пусто);
        вернути виділити_предмет_тексту_з_ю8(М, ю8"Пропущено аргумент \"значення\"") як адреса<Предмет>;
      }
      вернути предмет_виконати_властивість(предмет_аргумента_значення, М, М.БН.С.чародія_адреса, пусто, пусто);
    }
    ціль складений_предмет = виділити_складений_предмет(М, предмет_структури);
    змінна ціль пп: позитивне = 0;
    поки пп < предмет_структури.параметри.розмір {
      ціль елемент_параметра = предмет_структури.параметри.елементи[пп];
      ціль назва_параметра = елемент_параметра.ключ;
      ціль параметр = елемент_параметра.значення;
      змінна ціль аргумент: адреса<Предмет> = пусто;
      якщо аргументи == пусто {
        якщо іменовані_аргументи == пусто {
          якщо параметр.код_значення_за_замовчуванням == пусто {
            увімкнути_стан_падіння(М, пусто);
            вернути виділити_предмет_тексту_помилки_пропущено_аргумент(М, назва_параметра);
          } інакше {
            ціль результат_виконання_значення_за_замовчуванням = виконати_код_в_середовищі(М, предмет_структури.середовище_створення, параметр.код_значення_за_замовчуванням);
            якщо М.стан_падіння == позитивне(так) {
              вернути результат_виконання_значення_за_замовчуванням;
            }
            ціль значення_за_замовчуванням = забрати_з_накопичувача<адреса<Предмет>>(М, М.НаО::адреса);
            аргумент = значення_за_замовчуванням;
          }
        } інакше {
          ціль елемент_аргумента_з_назвою = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, назва_параметра);
          якщо елемент_аргумента_з_назвою == пусто {
            якщо параметр.код_значення_за_замовчуванням == пусто {
              увімкнути_стан_падіння(М, пусто);
              вернути виділити_предмет_тексту_помилки_пропущено_аргумент(М, назва_параметра);
            } інакше {
              ціль результат_виконання_значення_за_замовчуванням = виконати_код_в_середовищі(М, предмет_структури.середовище_створення, параметр.код_значення_за_замовчуванням);
              якщо М.стан_падіння == позитивне(так) {
                вернути результат_виконання_значення_за_замовчуванням;
              }
              ціль значення_за_замовчуванням = забрати_з_накопичувача<адреса<Предмет>>(М, М.НаО::адреса);
              аргумент = значення_за_замовчуванням;
            }
          } інакше {
            аргумент = елемент_аргумента_з_назвою.значення;
          }
        }
      } інакше {
        якщо іменовані_аргументи == пусто {
          якщо аргументи.розмір > пп {
            аргумент = аргументи.дані[пп];
          } інакше {
            якщо параметр.код_значення_за_замовчуванням == пусто {
              увімкнути_стан_падіння(М, пусто);
              вернути виділити_предмет_тексту_помилки_пропущено_аргумент(М, назва_параметра);
            } інакше {
              ціль результат_виконання_значення_за_замовчуванням = виконати_код_в_середовищі(М, предмет_структури.середовище_створення, параметр.код_значення_за_замовчуванням);
              якщо М.стан_падіння == позитивне(так) {
                вернути результат_виконання_значення_за_замовчуванням;
              }
              ціль значення_за_замовчуванням = забрати_з_накопичувача<адреса<Предмет>>(М, М.НаО::адреса);
              аргумент = значення_за_замовчуванням;
            }
          }
        } інакше {
          ціль елемент_аргумента_з_назвою = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, іменовані_аргументи, назва_параметра);
          якщо елемент_аргумента_з_назвою == пусто {
            якщо аргументи.розмір > пп {
              аргумент = аргументи.дані[пп];
            } інакше {
              якщо параметр.код_значення_за_замовчуванням == пусто {
                увімкнути_стан_падіння(М, пусто);
                вернути виділити_предмет_тексту_помилки_пропущено_аргумент(М, назва_параметра);
              } інакше {
                ціль результат_виконання_значення_за_замовчуванням = виконати_код_в_середовищі(М, предмет_структури.середовище_створення, параметр.код_значення_за_замовчуванням);
                якщо М.стан_падіння == позитивне(так) {
                  вернути результат_виконання_значення_за_замовчуванням;
                }
                ціль значення_за_замовчуванням = забрати_з_накопичувача<адреса<Предмет>>(М, М.НаО::адреса);
                аргумент = значення_за_замовчуванням;
              }
            }
          } інакше {
            аргумент = елемент_аргумента_з_назвою.значення;
          }
        }
      }
      якщо параметр.типи.розмір > 0 {
        змінна ціль пп: позитивне = 0;
        змінна ціль знайдено_тип: логічне = ні;
        поки пп < параметр.типи.розмір {
          якщо перевірити_чи_предмет_є(аргумент, М, параметр.типи.дані[пп]) {
            знайдено_тип = так;
          }
          пп += 1;
        }
        якщо знайдено_тип == ні {
          увімкнути_стан_падіння(М, пусто);
          якщо аргумент == пусто {
            ціль ю8_значення_назви = ю8 { пусто, 0 };
            якщо виділити_ю8_з_назви(М, назва_параметра, ю8_значення_назви::адреса) == ні {
              // потім: помилка
            }
            ціль п = виділити_предмет_тексту_помилки_невірний_тип_аргумента(М, ю8_значення_назви, параметр.типи, пусто);
            звільнити(М, ю8_значення_назви.дані як адреса);
            вернути п;
          } інакше {
            ціль ю8_значення_назви = ю8 { пусто, 0 };
            якщо виділити_ю8_з_назви(М, назва_параметра, ю8_значення_назви::адреса) == ні {
              // потім: помилка
            }
            ціль п = виділити_предмет_тексту_помилки_невірний_тип_аргумента(М, ю8_значення_назви, параметр.типи, аргумент.тип);
            звільнити(М, ю8_значення_назви.дані як адреса);
            вернути п;
          }
        }
      }
      змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, складений_предмет.властивості::адреса, назва_параметра, аргумент);
      пп += 1;
    }
    вернути складений_предмет як адреса<Предмет>;
  }

  місцева дія предмет_структури_отримати_властивість(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, назва: адреса<Назва>): предмет_або_стан_падіння {
    якщо назва == М.БН.С.назва {
      якщо предмет_структури.назва == пусто {
        вернути пусто;
      }
      вернути виділити_предмет_з_назви(М, предмет_структури.назва);
    }
    ціль елемент_реєстру = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.властивості::адреса, назва);
    якщо елемент_реєстру != пусто {
      вернути елемент_реєстру.значення;
    }
    змінна ціль тип = предмет_структури.тип;
    поки тип != пусто {
      ціль елемент_реєстру_методів = отримати_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, тип.методи::адреса, назва);
      якщо елемент_реєстру_методів != пусто {
        вернути елемент_реєстру_методів.значення;
      }
      тип = тип.предок;
    }
    вернути пусто;
  }

  місцева дія предмет_структури_змінити_властивість(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, назва: адреса<Назва>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    якщо назва == М.БН.С.назва {
      вернути пусто;
    }
    якщо перевірити_чи_назва_чародія(М, назва) {
      вернути пусто;
    }
    змінити_в_реєстрі<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.властивості::адреса, назва, аргумент);
    вернути пусто;
  }

  місцева дія предмет_структури_видалити_властивість(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, назва: адреса<Назва>): предмет_або_стан_падіння {
    якщо видалити_з_реєстру<адреса<Назва>, адреса<Предмет>>(М, предмет_структури.властивості::адреса, назва) {
      вернути М.предмет_логічного_так як адреса<Предмет>;
    }
    вернути М.предмет_логічного_ні як адреса<Предмет>;
  }

  місцева дія предмет_структури_виконати_властивість(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, назва_властивості: адреса<Назва>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    ціль предмет_властивості = предмет_структури_отримати_властивість(предмет_структури, М, назва_властивості);
    якщо М.стан_падіння == позитивне(так) {
      вернути предмет_властивості;
    }
    вернути предмет_виконати(предмет_властивості, М, предмет_структури як адреса<Предмет>, аргументи, іменовані_аргументи);
  }

  місцева дія предмет_структури_отримати_елемент(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, ключ: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо отримати елемент зі структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_змінити_елемент(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, ключ: адреса<Предмет>, значення: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо змінити елемент в структурі") як адреса<Предмет>;
  }

  місцева дія предмет_структури_видалити_елемент(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, ключ: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо видалити елемент зі структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_отримати_перебір(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо отримати перебір зі структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_додати(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати додавання для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_відняти(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати віднімання для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_помножити(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати множення для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_поділити(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати ділення для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_отримати_остачу_ділення(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати отримання остачі ділення для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_отримати_частку_ділення(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати отримання частки ділення для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_піднести_до_степеня(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати піднесення до степеня для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_зсунути_вліво(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати зсув вліво для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_зсунути_вправо(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати зсув вправо для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_зсунути_вправо_зі_заповненням(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати зсув вправо зі заповненням для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_двійкове_і(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове І для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_двійкове_або(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове АБО для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_двійкове_виключне_або(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове ВИКЛЮЧНЕ АБО для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_двійкове_не(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове НЕ для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_більше(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати перевірку на більшість для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_менше(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати перевірку на меншість для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_рівно(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    якщо перевірити_чи_предмет_структури_рівно(предмет_структури, М, аргумент) {
      вернути М.предмет_логічного_так як адреса<Предмет>;
    }
    вернути М.предмет_логічного_ні як адреса<Предмет>;
  }

  місцева дія предмет_структури_містить(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати перевірку на містікість для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_є(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    якщо аргумент == пусто {
      вернути М.предмет_логічного_ні як адреса<Предмет>;
    }
    якщо аргумент.тип != М.предмет_структури_Структура {
      вернути М.предмет_логічного_ні як адреса<Предмет>;
    }
    якщо перевірити_чи_предмет_структури_є(предмет_структури, М, аргумент як адреса<ПредметСтруктури>) {
      вернути М.предмет_логічного_так як адреса<Предмет>;
    }
    вернути М.предмет_логічного_ні як адреса<Предмет>;
  }

  місцева дія предмет_структури_відʼємне(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати відʼємне для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_числове(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати числове для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_заперечити(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>): предмет_або_стан_падіння {
    вернути М.предмет_логічного_ні як адреса<Предмет>;
  }

  місцева дія предмет_структури_збільшити(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати збільшення для структури") як адреса<Предмет>;
  }

  місцева дія предмет_структури_зменшити(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати зменшення для структури") як адреса<Предмет>;
  }

  місцева дія перевірити_чи_предмет_структури_рівно(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, аргумент: адреса<Предмет>): логічне {
    ціль предмет = предмет_структури як адреса<Предмет>;
    якщо предмет == аргумент {
      вернути так;
    }
    вернути ні;
  }

  місцева дія перевірити_чи_предмет_структури_є(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, предмет_структури: адреса<ПредметСтруктури>): логічне {
    якщо предмет_структури == М.предмет_структури_Структура {
      вернути так;
    }
    вернути ні;
  }

  місцева дія надрукувати_предмет_структури_в_накопичувач_ю8(предмет_структури: адреса<ПредметСтруктури>, М: адреса<Машина>, накопичувач_ю8: адреса<НакопичувачЮ8>, глибина: позитивне) {
    покласти_ю8_в_накопичувач_ю8(М, накопичувач_ю8, ю8"<структура");
    якщо предмет_структури.назва != пусто {
      покласти_ю8_в_накопичувач_ю8(М, накопичувач_ю8, ю8" ");
      ціль назва_ю8 = ю8 { пусто, 0 };
      якщо виділити_ю8_з_назви(М, предмет_структури.назва, назва_ю8::адреса) == ні {
        ПОМЕРТИ(М, ю8"Не вдалось отримати ю8 з назви дії");
      }
      покласти_ю8_в_накопичувач_ю8(М, накопичувач_ю8, назва_ю8);
      звільнити(М, назва_ю8.дані як адреса);
    }
    покласти_ю8_в_накопичувач_ю8(М, накопичувач_ю8, ю8">");
  }
}