ПредметЛогічного.ц

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

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

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

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

    ціль предмет_логічного = виділити_предмет<ПредметЛогічного>(М, М.предмет_структури_логічне);

    предмет_логічного.значення = позитивне(значення);

    вернути предмет_логічного;
  }

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

  місцева дія предмет_логічного_виконати(предмет_логічного: адреса<ПредметЛогічного>, М: адреса<Машина>, предмет_я: адреса<Предмет>, аргументи: адреса<Накопичувач<адреса<Предмет>>>, іменовані_аргументи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>): предмет_або_стан_падіння {
    увімкнути_стан_падіння(М, пусто);
    вернути виділити_предмет_тексту_з_ю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"ні");
    }
  }
}