ПредметАдреси.ц

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

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

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

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

    предмет_адреси.значення = значення;

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

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

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