// 2025-2026 Богданович Давид Когут Прихожденко (кдб.дійсність.укр)
взяти визначення мавка;
взяти визначення мавка/розбирач;
взяти визначення мавка/компілювач;
простір мавка {
дія налаштувати_машину(
М: *Машина,
налаштування: Налаштування
) {
М.налаштування = налаштування;
М.шлях_до_теки_модулів = пусто;
М.шлях_до_теки_паків = пусто;
М.розмова = пусто;
М.глобальна_дійсність = виділити<Дійсність>(М, 1);
М.глобальна_дійсність.попередня = пусто;
М.глобальна_дійсність.наступна = пусто;
М.глобальна_дійсність.позначено = ні;
М.глобальна_дійсність.кількість_запозичень = 1;
М.глобальна_дійсність.зовні = пусто;
М.глобальна_дійсність.призначення = Призначення { 0, пусто, 0 };
М.перша_дійсність = М.глобальна_дійсність;
М.остання_дійсність = М.глобальна_дійсність;
стала вмісткість_накопичувача_значень = 1024;
М.накопичувач_значень = НакопичувачЗначень {
розмір = 0,
дані = виділити<Значення>(М, вмісткість_накопичувача_значень),
вмісткість = вмісткість_накопичувача_значень
};
стала вмісткість_історії_здійснення = 1024;
М.історія_здійснення = ІсторіяЗдійснення {
розмір = 0,
дані = виділити<Діяльність>(М, вмісткість_історії_здійснення),
вмісткість = вмісткість_історії_здійснення
};
М.стан_падіння = ні;
М.значення_падіння = НЕДІЙСНЕ;
М.місцезнаходження_падіння = Місцезнаходження { пусто, 0 };
М.взяті_значення = ВзятіЗначення {
0,
пусто
};
М.користувацькі_дані_пристрою = пусто;
М.користувацькі_дані_бібліотеки = пусто;
М.черга_здійснення = ЧергаЗдійснення { пусто, пусто };
М.глобальний_притримувач = виділити<Притримувач>(М, 1);
М.глобальний_притримувач.попередній = пусто;
М.глобальний_притримувач.наступний = пусто;
М.глобальний_притримувач.перший = пусто;
М.глобальний_притримувач.останній = пусто;
М.останній_притримувач = М.глобальний_притримувач;
М.клас_Клас = виділити<ПредметКласу>(М, 1);
М.клас_Клас.наступний = пусто;
М.клас_Клас.позначено = ні;
М.клас_Клас.клас = М.клас_Клас;
М.клас_Клас.користувацькі_дані = пусто;
М.клас_Клас.вбудований = так;
М.клас_Клас.заборонити_наслідування = ні;
М.клас_Клас.назва = пусто;
М.клас_Клас.ознаки = пусто;
М.клас_Клас.методи = Методи { 0, пусто };
М.клас_Клас.властивості = Призначення { 0, пусто, 0 };
М.перший_предмет = М.клас_Клас як *Предмет;
М.останній_предмет = М.клас_Клас як *Предмет;
М.кількість_дійсних = 1;
М.кількість_дійсних_для_очищення = 100;
М.потребує_очищення = ні;
М.клас_Текст = створити_клас(М, пусто, пусто);
М.константи_назв = КонстантиНазв {
_значення = створити_текст(М, "значення"),
_недійсне = створити_текст(М, "недійсне"),
_дійсне = створити_текст(М, "дійсне"),
_Послідовність = створити_текст(М, "Послідовність"),
_дійсність = створити_текст(М, "дійсність"),
_Предмет = створити_текст(М, "Предмет"),
_Структура = створити_текст(М, "Структура"),
_Модуль = створити_текст(М, "Модуль"),
_Параметр = створити_текст(М, "Параметр"),
_Ознака = створити_текст(М, "Ознака"),
_Число = створити_текст(М, "Число"),
_Текст = створити_текст(М, "Текст"),
_Код = створити_текст(М, "Код"),
_Дія = створити_текст(М, "Дія"),
_Список = створити_текст(М, "Список"),
_Словник = створити_текст(М, "Словник"),
_Дані = створити_текст(М, "Дані"),
_ПроміжокЧисел = створити_текст(М, "ПроміжокЧисел"),
_ПеребірПроміжкаЧисел = створити_текст(М, "ПеребірПроміжкаЧисел"),
_ПеребірСписку = створити_текст(М, "ПеребірСписку"),
_далі = створити_текст(М, "далі"),
_з = створити_текст(М, "з"),
_довжина = створити_текст(М, "довжина"),
_0 = створити_текст(М, "0"),
_1 = створити_текст(М, "1"),
_модуль = створити_текст(М, "модуль"),
_пак = створити_текст(М, "пак"),
_біб = створити_текст(М, "біб"),
_читати = створити_текст(М, "читати"),
_перед = створити_текст(М, "перед"),
_розмір = створити_текст(М, "розмір"),
_чародія = створити_текст(М, "чародія"),
_чародія_число = створити_текст(М, "чародія_число"),
_чародія_текст = створити_текст(М, "чародія_текст"),
_чародія_межа = створити_текст(М, "чародія_межа"),
_чародія_перебір = створити_текст(М, "чародія_перебір"),
_чародія_послідовність = створити_текст(М, "чародія_послідовність"),
_дія_перевірки = створити_текст(М, "дія_перевірки"),
_дія_перетворення = створити_текст(М, "дія_перетворення"),
_додати = створити_текст(М, "додати"),
_забрати = створити_текст(М, "забрати"),
_знайти = створити_текст(М, "знайти"),
_знайти_позицію = створити_текст(М, "знайти_позицію"),
_відібрати = створити_текст(М, "відібрати"),
_перетворити = створити_текст(М, "перетворити"),
_обернути = створити_текст(М, "обернути"),
_містить = створити_текст(М, "містить"),
_ключ = створити_текст(М, "ключ"),
_ключі = створити_текст(М, "ключі"),
_список = створити_текст(М, "список"),
_словник = створити_текст(М, "словник"),
_послідовність = створити_текст(М, "послідовність"),
_дані = створити_текст(М, "дані"),
_проміжок = створити_текст(М, "проміжок"),
_ПеребірПослідовності = створити_текст(М, "ПеребірПослідовності"),
_ПеребірДаних = створити_текст(М, "ПеребірДаних"),
_назва = створити_текст(М, "назва"),
_параметри = створити_текст(М, "параметри"),
_ознаки = створити_текст(М, "ознаки"),
_тип_результату = створити_текст(М, "тип_результату"),
_код = створити_текст(М, "код"),
_константи = створити_текст(М, "константи"),
_вказівки = створити_текст(М, "вказівки"),
_шлях = створити_текст(М, "шлях"),
_ПеребірСловника = створити_текст(М, "ПеребірСловника"),
_ПеребірТексту = створити_текст(М, "ПеребірТексту"),
_текст = створити_текст(М, "текст"),
_нескінченність = створити_текст(М, "нескінченність"),
_невизначеність = створити_текст(М, "невизначеність"),
_система = створити_текст(М, "система"),
_прочитати = створити_текст(М, "прочитати"),
_тип = створити_текст(М, "тип"),
_записати = створити_текст(М, "записати"),
_куди = створити_текст(М, "куди"),
_дописати = створити_текст(М, "дописати"),
_видалити = створити_текст(М, "видалити"),
_створити_папку = створити_текст(М, "створити_папку"),
_виконати = створити_текст(М, "виконати"),
_аргументи = створити_текст(М, "аргументи"),
_РезультатВиконання = створити_текст(М, "РезультатВиконання"),
_стдвив = створити_текст(М, "стдвив"),
_стдпом = створити_текст(М, "стдпом"),
_команда = створити_текст(М, "команда"),
_с = створити_текст(М, "с"),
_місцезнаходження_вказівок = створити_текст(М, "місцезнаходження_вказівок"),
_від = створити_текст(М, "від"),
_до = створити_текст(М, "до"),
_включно = створити_текст(М, "включно"),
_дія_значення = створити_текст(М, "дія_значення"),
_позиція = створити_текст(М, "позиція"),
_Клас = створити_текст(М, "Клас"),
_предок = створити_текст(М, "предок"),
_Перебір = створити_текст(М, "Перебір"),
_виділити = створити_текст(М, "виділити"),
_обнулено = створити_текст(М, "обнулено"),
_отримати_назву = створити_текст(М, "отримати_назву"),
_фс = створити_текст(М, "фс"),
_мат = створити_текст(М, "мат"),
_Е = створити_текст(М, "Е"),
_ПІ = створити_текст(М, "ПІ"),
_ЛОГ2Е = створити_текст(М, "ЛОГ2Е"),
_ЛОГ10Е = створити_текст(М, "ЛОГ10Е"),
_ЛОГ2 = створити_текст(М, "ЛОГ2"),
_ЛОГ10 = створити_текст(М, "ЛОГ10"),
_КОРІНЬ2 = створити_текст(М, "КОРІНЬ2"),
_КОРІНЬ1_2 = створити_текст(М, "КОРІНЬ1_2"),
_син = створити_текст(М, "син"),
_кос = створити_текст(М, "кос"),
_тан = створити_текст(М, "тан"),
_асин = створити_текст(М, "асин"),
_акос = створити_текст(М, "акос"),
_атан = створити_текст(М, "атан"),
_абс = створити_текст(М, "абс"),
_експ = створити_текст(М, "експ"),
_кор2 = створити_текст(М, "кор2"),
_стеля = створити_текст(М, "стеля"),
_підлога = створити_текст(М, "підлога"),
_округлити = створити_текст(М, "округлити"),
};
М.клас_Послідовність = створити_клас(М, М.константи_назв._Послідовність, пусто);
М.пуста_послідовність = створити_послідовність_без_копіювання(М, 0, пусто);
М.клас_Послідовність.ознаки = М.пуста_послідовність;
М.клас_Клас.ознаки = М.пуста_послідовність;
М.клас_Текст.ознаки = М.пуста_послідовність;
М.клас_Клас.назва = М.константи_назв._Клас;
М.клас_Текст.назва = М.константи_назв._Текст;
М.клас_Число = створити_клас(М, М.константи_назв._Число, М.пуста_послідовність);
М.клас_Дані = створити_клас(М, М.константи_назв._Дані, М.пуста_послідовність);
М.клас_Параметр = створити_клас(М, М.константи_назв._Параметр, М.пуста_послідовність);
М.клас_Ознака = створити_клас(М, М.константи_назв._Ознака, М.пуста_послідовність);
М.клас_Код = створити_клас(М, М.константи_назв._Код, М.пуста_послідовність);
М.клас_Дія = створити_клас(М, М.константи_назв._Дія, М.пуста_послідовність);
М.клас_Словник = створити_клас(М, М.константи_назв._Словник, М.пуста_послідовність);
М.клас_Список = створити_клас(М, М.константи_назв._Список, М.пуста_послідовність);
М.клас_Модуль = створити_клас(М, М.константи_назв._Модуль, М.пуста_послідовність);
М.клас_ПроміжокЧисел = створити_клас(М, М.константи_назв._ПроміжокЧисел, М.пуста_послідовність);
М.клас_ПеребірДаних = створити_клас(М, М.константи_назв._ПеребірДаних, М.пуста_послідовність);
М.клас_ПеребірПроміжкаЧисел = створити_клас(М, М.константи_назв._ПеребірПроміжкаЧисел, М.пуста_послідовність);
М.клас_ПеребірПослідовності = створити_клас(М, М.константи_назв._ПеребірПослідовності, М.пуста_послідовність);
М.клас_ПеребірСловника = створити_клас(М, М.константи_назв._ПеребірСловника, М.пуста_послідовність);
М.клас_ПеребірСписку = створити_клас(М, М.константи_назв._ПеребірСписку, М.пуста_послідовність);
М.клас_ПеребірТексту = створити_клас(М, М.константи_назв._ПеребірТексту, М.пуста_послідовність);
заповнити_клас_Клас(М);
заповнити_клас_Послідовність(М);
заповнити_клас_Дані(М);
заповнити_клас_ПроміжокЧисел(М);
заповнити_клас_Дія(М);
заповнити_клас_Код(М);
заповнити_клас_Модуль(М);
заповнити_клас_Параметр(М);
заповнити_клас_Ознака(М);
заповнити_клас_ПеребірДаних(М);
заповнити_клас_ПеребірПроміжкаЧисел(М);
заповнити_клас_ПеребірПослідовності(М);
заповнити_клас_ПеребірСловника(М);
заповнити_клас_ПеребірСписку(М);
заповнити_клас_ПеребірТексту(М);
заповнити_клас_Словник(М);
заповнити_клас_Список(М);
заповнити_клас_Текст(М);
заповнити_клас_Число(М);
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._недійсне, НЕДІЙСНЕ);
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._дійсне, ДІЙСНЕ);
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._Клас, ПРЕДМЕТ(М.клас_Клас));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._Модуль, ПРЕДМЕТ(М.клас_Модуль));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._Число, ПРЕДМЕТ(М.клас_Число));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._Текст, ПРЕДМЕТ(М.клас_Текст));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._Дія, ПРЕДМЕТ(М.клас_Дія));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._Список, ПРЕДМЕТ(М.клас_Список));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._Словник, ПРЕДМЕТ(М.клас_Словник));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._Дані, ПРЕДМЕТ(М.клас_Дані));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._ПроміжокЧисел, ПРЕДМЕТ(М.клас_ПроміжокЧисел));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._Послідовність, ПРЕДМЕТ(М.клас_Послідовність));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._нескінченність, ЧИСЛО(р64(1.0) / 0.0));
записати_в_дійсність(М, М.глобальна_дійсність, М.константи_назв._невизначеність, ЧИСЛО(р64(0.0) / 0.0));
}
дія розлаштувати_машину(
М: *Машина
) {
// потім: втілити
}
дія увімкнути_стан_падіння(
М: *Машина,
значення_падіння: Значення,
місцезнаходження_падіння: Місцезнаходження
) -> ніщо {
М.стан_падіння = так;
М.значення_падіння = значення_падіння;
М.місцезнаходження_падіння = місцезнаходження_падіння;
}
дія вимкнути_стан_падіння(
М: *Машина
) -> ніщо {
М.стан_падіння = ні;
М.значення_падіння = НЕДІЙСНЕ;
М.місцезнаходження_падіння = Місцезнаходження { пусто, 0 };
}
дія покласти_в_історію_здійснення(
М: *Машина,
дійсність: *Дійсність,
здійснювач: Значення,
предмет_дії: *ПредметДії,
задіяні: Задіяні,
місцезнаходження: Місцезнаходження
) -> *Діяльність {
М.історія_здійснення.дані[М.історія_здійснення.розмір] = Діяльність {
дійсність = дійсність,
здійснювач = здійснювач,
предмет_дії = предмет_дії,
задіяні = задіяні,
місцезнаходження = місцезнаходження,
спроби = Спроби { 0, пусто },
};
М.історія_здійснення.розмір += 1;
якщо дійсність != пусто {
дійсність.кількість_запозичень += 1;
}
вернути М.історія_здійснення.дані[М.історія_здійснення.розмір - 1]::адреса;
}
дія видалити_з_історії_здійснення(
М: *Машина,
кількість: природне
) {
змінна п: природне = 0;
поки п < кількість {
змінна діяльність = М.історія_здійснення.дані[М.історія_здійснення.розмір - 1 - п];
якщо діяльність.дійсність != пусто {
відпустити_дійсність(М, діяльність.дійсність);
}
звільнити(М, діяльність.спроби.дані);
звільнити_задіяні(М, діяльність.задіяні);
п += 1;
}
М.історія_здійснення.розмір -= кількість;
}
дія покласти_в_чергу_здійснення(
М: *Машина,
предмет_дії: *ПредметДії,
задіяні: Задіяні
) {
// ...
}
дія забрати_з_черги_здійснення(
М: *Машина,
вихід: *ЕлементЧергиЗдійснення
) -> логічне {
якщо М.черга_здійснення.перший != пусто {
змінна елемент = М.черга_здійснення.перший;
М.черга_здійснення.перший = елемент.наступний;
вихід::вміст = елемент::вміст;
звільнити(М, елемент);
вернути так;
} інакше {
М.черга_здійснення.останній = пусто;
вернути ні;
}
}
}
простір мавка {
внутрішня дія покласти_в_накопичувач_значень(
М: *Машина,
накопичувач_значень: *НакопичувачЗначень,
значення: Значення
) {
якщо накопичувач_значень.розмір == накопичувач_значень.вмісткість {
ЗАПАНІКУВАТИ(М, "Накопичувач значень заповнено!");
вернути;
}
накопичувач_значень.дані[накопичувач_значень.розмір] = значення;
накопичувач_значень.розмір += 1;
}
внутрішня дія забрати_з_накопичувача_значень(
М: *Машина,
накопичувач_значень: *НакопичувачЗначень
) -> Значення {
якщо накопичувач_значень.розмір == 0 {
ЗАПАНІКУВАТИ(М, "Накопичувач значень порожній 1!");
}
накопичувач_значень.розмір -= 1;
вернути накопичувач_значень.дані[накопичувач_значень.розмір];
}
внутрішня дія отримати_з_накопичувача_значень(
М: *Машина,
накопичувач_значень: *НакопичувачЗначень,
позиція: природне
) -> Значення {
якщо накопичувач_значень.розмір == 0 {
ЗАПАНІКУВАТИ(М, "Накопичувач значень порожній 2!");
}
вернути накопичувач_значень.дані[накопичувач_значень.розмір - 1 - позиція];
}
внутрішня дія видалити_з_накопичувача_значень(
М: *Машина,
накопичувач_значень: *НакопичувачЗначень,
кількість: природне
) {
якщо накопичувач_значень.розмір == 0 {
ЗАПАНІКУВАТИ(М, "Накопичувач значень порожній 3!");
}
накопичувач_значень.розмір -= кількість;
}
внутрішня дія обробити_стан_падіння(
М: *Машина,
спроби: *Спроби,
дійсність: *Дійсність,
предмет_коду: *ПредметКоду,
позиція_вказівки_падіння: природне,
позиція: *природне
) -> логічне {
якщо спроби.розмір > 0 {
спроби.розмір -= 1;
змінна спроба = спроби.дані[спроби.розмір];
якщо спроба.назва_зловити != пусто {
записати_в_дійсність(М, дійсність, спроба.назва_зловити, М.значення_падіння);
}
позиція::вміст = спроба.позиція_вказівки_зловити;
М.історія_здійснення.розмір = спроба.розмір_історії_здійснення;
М.накопичувач_значень.розмір = спроба.розмір_накопичувача_значень;
М.стан_падіння = ні;
М.значення_падіння = НЕДІЙСНЕ;
М.місцезнаходження_падіння = Місцезнаходження { пусто, 0 };
вернути так;
}
якщо (М.місцезнаходження_падіння.шлях_або_код як *ПредметДаних) == пусто {
М.місцезнаходження_падіння = Місцезнаходження { предмет_коду, позиція_вказівки_падіння };
}
вернути ні;
}
внутрішня дія прочитати_аргумент_вказівки(вказівки: *ПредметДаних, позиція: *природне) -> п32 {
позиція::вміст += 1;
змінна адреса_аргумента = вказівки.дані[позиція::вміст]::адреса як *п32;
позиція::вміст += 3;
вернути адреса_аргумента::вміст;
}
внутрішня дія виконати_код(
М: *Машина,
накопичувач_значень: *НакопичувачЗначень,
спроби: *Спроби,
дійсність: *Дійсність,
здійснювач: Значення,
предмет_коду: *ПредметКоду,
початкова_позиція_вказівки: природне,
шлях_до_теки_модулів: *ПредметДаних
) -> ЗначенняАбоСтанПадіння {
// надрукувати_кд(М, "виконати_код");
змінна константи = предмет_коду.константи;
змінна вказівки = предмет_коду.вказівки;
змінна результат_вернути = НЕДІЙСНЕ;
змінна результат = НЕДІЙСНЕ;
змінна позиція = початкова_позиція_вказівки;
змінна позиція_поточної_вказівки: природне;
змінна вказівка: п8;
змінна а1: природне;
змінна а2: природне;
змінна а3: природне;
змінна з1: Значення;
змінна з2: Значення;
змінна з3: Значення;
змінна з4: Значення;
змінна назва: *ПредметТексту;
змінна модл1: *ПредметМодуля;
змінна спис1: *ПредметСписку;
змінна слов1: *ПредметСловника;
змінна посл1: *ПредметПослідовності;
змінна дія1: *ПредметДії;
змінна клас1: *ПредметКласу;
змінна ткст1: *ПредметТексту;
змінна ткст2: *ПредметТексту;
змінна пред1: *Предмет;
змінна пред2: *Предмет;
змінна накопичувач_тексту: НакопичувачТексту;
змінна дані_назв: **ПредметТексту;
змінна дані: *п8;
змінна п: природне = 0; // спільний лічильник
змінна п1: природне = 0; // спільний лічильник 1
// надрукувати_кд(М, "Початок виконання коду");
// надрукувати_п64(М, п64(вказівки.розмір));
поки позиція < вказівки.розмір {
крок_виконання_вказівки:
якщо М.потребує_очищення {
запустити_очищувач(М);
}
позиція_поточної_вказівки = позиція;
вказівка = вказівки.дані[позиція_поточної_вказівки];
// вивести_кд(М, "Виконується вказівка: ");
// надрукувати_п64(М, п64(вказівка));
якщо вказівка == ВПокластиНедійсне {
покласти_в_накопичувач_значень(М, накопичувач_значень, НЕДІЙСНЕ);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВПокластиДійсне {
покласти_в_накопичувач_значень(М, накопичувач_значень, ДІЙСНЕ);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВПокластиПредмет {
покласти_в_накопичувач_значень(М, накопичувач_значень, ДІЙСНЕ);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВПокластиЯ {
покласти_в_накопичувач_значень(М, накопичувач_значень, здійснювач);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВПокластиКонстанту {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // позиція_константи
покласти_в_накопичувач_значень(М, накопичувач_значень, константи.елементи[а1]);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтворитиДію {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_параметрів
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // код
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // тип_результату
посл1 = М.пуста_послідовність; // параметри
якщо а1 > 0 {
посл1 = створити_сиру_послідовність(М, а1);
п = 0;
поки п < а1 {
посл1.елементи[а1 - п - 1] = забрати_з_накопичувача_значень(М, накопичувач_значень);
п += 1;
}
}
з3 = забрати_з_накопичувача_значень(М, накопичувач_значень); // назва
покласти_в_накопичувач_значень(
М,
накопичувач_значень,
ПРЕДМЕТ(створити_дію(
М,
дійсність,
з3.дані як *Предмет як *ПредметТексту,
посл1,
пусто,
з1.дані як *Предмет як *ПредметКоду,
шлях_до_теки_модулів
))
);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтворитиКлас {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_параметрів
посл1 = М.пуста_послідовність;
якщо а1 > 0 {
посл1 = створити_сиру_послідовність(М, а1);
п = 0;
поки п < а1 {
посл1.елементи[а1 - п - 1] = забрати_з_накопичувача_значень(М, накопичувач_значень);
п += 1;
}
}
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // назва
покласти_в_накопичувач_значень(
М,
накопичувач_значень,
ПРЕДМЕТ(створити_клас(
М,
з1.дані як *Предмет як *ПредметТексту,
посл1
))
);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтворитиМодуль {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // код
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // назва
модл1 = створити_модуль(
М,
з2.дані як *Предмет як *ПредметТексту
);
здійснити(
М,
ПРЕДМЕТ(модл1),
ПРЕДМЕТ(створити_дію(
М,
дійсність,
з2.дані як *Предмет як *ПредметТексту,
М.пуста_послідовність,
пусто,
з1.дані як *Предмет як *ПредметКоду,
шлях_до_теки_модулів
)),
Задіяні { ВидЗадіяних2, 0, пусто, 0 },
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ПРЕДМЕТ(модл1));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтворитиСписок {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_елементів
спис1 = створити_список(М, а1);
п = 0;
поки п < а1 {
записати_в_список(
М,
спис1,
а1 - п - 1,
забрати_з_накопичувача_значень(М, накопичувач_значень)
);
п += 1;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ПРЕДМЕТ(спис1));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтворитиСловник {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_елементів
слов1 = створити_словник(М);
п = 0;
поки п < а1 {
записати_в_словник(
М,
слов1,
отримати_з_накопичувача_значень(М, накопичувач_значень, (а1 * 2) - (п * 2) - 1), // ключ
отримати_з_накопичувача_значень(М, накопичувач_значень, (а1 * 2) - (п * 2) - 2) // значення
);
п += 1;
}
видалити_з_накопичувача_значень(М, накопичувач_значень, а1 * 2);
покласти_в_накопичувач_значень(М, накопичувач_значень, ПРЕДМЕТ(слов1));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтворитиПослідовність {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_елементів
посл1 = створити_сиру_послідовність(М, а1);
п = 0;
поки п < а1 {
посл1.елементи[а1 - п - 1] = забрати_з_накопичувача_значень(М, накопичувач_значень);
п += 1;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ПРЕДМЕТ(посл1));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтворитиПроміжок {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // до
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // включно
з3 = забрати_з_накопичувача_значень(М, накопичувач_значень); // від
з4 = отримати_проміжок(
М,
з3,
з1,
з2.вид == ЗДійсне,
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, з4);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтворитиПараметр {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // тип
з3 = забрати_з_накопичувача_значень(М, накопичувач_значень); // назва
// потім: втілити тип
покласти_в_накопичувач_значень(
М,
накопичувач_значень,
ПРЕДМЕТ(створити_параметр(
М,
з3.дані як *Предмет як *ПредметТексту,
пусто,
з1
))
);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтворитиОзнаку {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // тип
з3 = забрати_з_накопичувача_значень(М, накопичувач_значень); // назва
// потім: втілити тип
покласти_в_накопичувач_значень(
М,
накопичувач_значень,
ПРЕДМЕТ(створити_ознаку(
М,
з3.дані як *Предмет як *ПредметТексту,
пусто,
з1
))
);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗаписатиМетод {
дія1 = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметДії;
назва = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту;
з3 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення_класу
якщо з3.вид != ЗПредмет {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Неможливо записати метод.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
клас1 = з3.дані як *Предмет як *ПредметКласу;
якщо клас1.клас != М.клас_Клас {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Метод можна записати лише в клас.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
дія1.метод_класу = клас1;
записати_метод_класу(М, клас1, назва, дія1);
покласти_в_накопичувач_значень(М, накопичувач_значень, ПРЕДМЕТ(дія1));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВВизначити {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень);
назва = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту;
записати_в_дійсність(М, дійсність, назва, з1);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВВизначитиНавпаки {
назва = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту;
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень);
записати_в_дійсність(М, дійсність, назва, з1);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗвернутись {
назва = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту;
якщо не знайти_в_дійсності(М, дійсність, назва, з1::адреса) {
накопичувач_тексту = зробити_накопичувач_тексту(М, 32);
покласти_в_накопичувач_тексту(М, накопичувач_тексту::адреса, "Діяча \"");
покласти_в_накопичувач_тексту(М, накопичувач_тексту::адреса, назва.значення);
покласти_в_накопичувач_тексту(М, накопичувач_тексту::адреса, "\" не призначено.");
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст_без_копіювання(М, накопичувач_тексту.розмір, накопичувач_тексту.дані)),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, з1);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗдійснити {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_задіяних
а2 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_імен
а3 = а1 + а2; // загальна_кількість_задіяних
результат = здійснити(
М,
НЕДІЙСНЕ,
накопичувач_значень.дані[накопичувач_значень.розмір - а3 - 1], // значення
Задіяні { ВидЗадіяних1, п32(а3), накопичувач_значень.дані[накопичувач_значень.розмір - а3]::адреса, п32(а2) },
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
видалити_з_накопичувача_значень(М, накопичувач_значень, природне(а3 + 1));
покласти_в_накопичувач_значень(М, накопичувач_значень, результат);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВОтриматиВластивість {
назва = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту;
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень);
результат = отримати_властивість(М, з1, назва, Місцезнаходження { предмет_коду, позиція_поточної_вказівки });
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, результат);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗмінитиВластивість {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень);
назва = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту;
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень);
змінити_властивість(
М,
з2,
назва,
з1,
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗдійснитиВластивість {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_задіяних
а2 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_імен
а3 = а1 + а2;
назва = накопичувач_значень.дані[накопичувач_значень.розмір - а3 - 1].дані як *Предмет як *ПредметТексту;
з1 = накопичувач_значень.дані[накопичувач_значень.розмір - а3 - 2]; // значення
результат = здійснити_властивість(
М,
з1,
назва,
Задіяні { ВидЗадіяних1, п32(а3), накопичувач_значень.дані[накопичувач_значень.розмір - а3]::адреса, п32(а2) },
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
видалити_з_накопичувача_значень(М, накопичувач_значень, природне(а3 + 2));
покласти_в_накопичувач_значень(М, накопичувач_значень, результат);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВОтриматиЕлемент {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ключ
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // предмет
результат = отримати_елемент(
М,
з2,
з1,
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, результат);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗмінитиЕлемент {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ключ
з3 = забрати_з_накопичувача_значень(М, накопичувач_значень); // предмет
змінити_елемент(М, з3, з2, з1, Місцезнаходження { предмет_коду, позиція_поточної_вказівки });
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
стрибнути крок_виконати_далі;
}
якщо вказівка == ВОтриматиПеребір {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
результат = отримати_перебір(М, з1, Місцезнаходження { предмет_коду, позиція_поточної_вказівки });
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, результат);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВДодати {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид == ЗПредмет {
ткст2 = з2.дані як *Предмет як *ПредметТексту;
якщо ткст2.клас != М.клас_Текст {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Додати можна лише числа або тексти.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗПредмет {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Додати до тексту можна лише текст (праворуч не текст).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
ткст1 = з1.дані як *Предмет як *ПредметТексту;
якщо ткст1.клас != М.клас_Текст {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Додати до тексту можна лише текст (праворуч не текст).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
а1 = ткст2.значення.розмір + ткст1.значення.розмір;
дані = виділити<п8>(М, а1);
п1 = 0;
поки п1 < ткст2.значення.розмір {
дані[п1] = ткст2.значення.дані[п1];
п1 += 1;
}
п1 = 0;
поки п1 < ткст1.значення.розмір {
дані[ткст2.значення.розмір + п1] = ткст1.значення.дані[п1];
п1 += 1;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ПРЕДМЕТ(створити_текст_без_копіювання(
М,
а1,
дані
)));
стрибнути крок_виконати_далі;
}
якщо з2.вид == ЗЧисло {
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Додати до числа можна лише число (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО((з2.дані як р64) + (з1.дані як р64)));
стрибнути крок_виконати_далі;
}
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Додати можна лише числа або тексти.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо вказівка == ВВідняти {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Відняти можна лише числа (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Відняти можна лише числа (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО((з2.дані як р64) - (з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВПомножити {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Помножити можна лише числа (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Помножити можна лише числа (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО((з2.дані як р64) * (з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВПоділити {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Поділити можна лише числа (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Поділити можна лише числа (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО((з2.дані як р64) / (з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВОтриматиОстачуДілення {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Поділити з остачею можна лише числа (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Поділити з остаченю можна лише числа (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО((з2.дані як р64) % (з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВОтриматиНеповнуЧасткуДілення {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Операція отримання неповної частки ділення не підтримується.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо вказівка == ВПіднестиДоСтепеня {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Піднести до степеня можна лише числа (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Піднести до степеня можна лише числа (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО(піднести_до_степеня_р64(М, з2.дані як р64, з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗсунутиВліво {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Зсунути вліво можна лише числа (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Зсунути вліво можна лише числа (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО(р64(ц32(з2.дані як р64) << ц32(з1.дані як р64))));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗсунутиВправо {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Зсунути вправо можна лише числа (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Зсунути вправо можна лише числа (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО(р64(ц32(з2.дані як р64) >> ц32(з1.дані як р64))));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВДвійковеІ {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Здійснити двійкове І можна лише з числами (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Здійснити двійкове І можна лише з числами (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО(р64(ц32(з2.дані як р64) & ц32(з1.дані як р64))));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВДвійковеАБО {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Здійснити двійкове АБО можна лише з числами (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Здійснити двійкове АБО можна лише з числами (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО(р64(ц32(з2.дані як р64) | ц32(з1.дані як р64))));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВДвійковеВиключнеАБО {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Здійснити двійкове ВАБО можна лише з числами (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Здійснити двійкове ВАБО можна лише з числами (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО(р64(ц32(з2.дані як р64) вабо ц32(з1.дані як р64))));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВМенше {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Перевірити чи менше можна лише з числами (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Перевірити чи менше можна лише з числами (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЛОГЛОГ((з2.дані як р64) < (з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВБільше {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Перевірити чи більше можна лише з числами (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Перевірити чи більше можна лише з числами (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЛОГЛОГ((з2.дані як р64) > (з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВНеБільше {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Перевірити чи не більше можна лише з числами (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Перевірити чи не більше можна лише з числами (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЛОГЛОГ((з2.дані як р64) <= (з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВНеМенше {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Перевірити чи не менше можна лише з числами (ліворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Перевірити чи не менше можна лише з числами (праворуч не число).")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЛОГЛОГ((з2.дані як р64) >= (з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВРівно {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо порівняти_значення(М, з2, з1) {
покласти_в_накопичувач_значень(М, накопичувач_значень, ДІЙСНЕ);
} інакше {
покласти_в_накопичувач_значень(М, накопичувач_значень, НЕДІЙСНЕ);
}
стрибнути крок_виконати_далі;
}
якщо вказівка == ВНеРівно {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо порівняти_значення(М, з2, з1) {
покласти_в_накопичувач_значень(М, накопичувач_значень, НЕДІЙСНЕ);
} інакше {
покласти_в_накопичувач_значень(М, накопичувач_значень, ДІЙСНЕ);
}
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЄ {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид == ЗНедійсне {
якщо з1.вид == ЗНедійсне {
результат = ДІЙСНЕ;
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше якщо з2.вид == ЗДійсне {
якщо з1.вид == ЗДійсне {
результат = ДІЙСНЕ;
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше якщо з2.вид == ЗЧисло {
якщо з1.вид == ЗДійсне {
результат = ДІЙСНЕ;
} інакше якщо з1.вид == ЗПредмет {
якщо (з1.дані як *Предмет) == М.клас_Число {
результат = ДІЙСНЕ;
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше якщо з2.вид == ЗПредмет {
якщо з1.вид == ЗДійсне {
результат = ДІЙСНЕ;
} інакше якщо з1.вид == ЗПредмет {
пред2 = з1.дані як *Предмет;
якщо пред2.клас == М.клас_Клас {
якщо перевірити_чи_предмет_є(М, з2.дані як *Предмет, пред2 як *ПредметКласу) {
результат = ДІЙСНЕ;
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше {
ЗАПАНІКУВАТИ(М, "Невідомий вид значення ліво операції є");
}
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, результат);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВНеЄ {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // право
з2 = забрати_з_накопичувача_значень(М, накопичувач_значень); // ліво
якщо з2.вид == ЗНедійсне {
якщо з1.вид == ЗНедійсне {
результат = ДІЙСНЕ;
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше якщо з2.вид == ЗДійсне {
якщо з1.вид == ЗДійсне {
результат = ДІЙСНЕ;
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше якщо з2.вид == ЗЧисло {
якщо з1.вид == ЗДійсне {
результат = ДІЙСНЕ;
} інакше якщо з1.вид == ЗПредмет {
якщо (з1.дані як *Предмет) == М.клас_Число {
результат = ДІЙСНЕ;
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше якщо з2.вид == ЗПредмет {
якщо з1.вид == ЗДійсне {
результат = ДІЙСНЕ;
} інакше якщо з1.вид == ЗПредмет {
пред2 = з1.дані як *Предмет;
якщо пред2.клас == М.клас_Клас {
якщо перевірити_чи_предмет_є(М, з2.дані як *Предмет, пред2 як *ПредметКласу) {
результат = ДІЙСНЕ;
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше {
результат = НЕДІЙСНЕ;
}
} інакше {
ЗАПАНІКУВАТИ(М, "Невідомий вид значення ліво операції є");
}
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо результат.вид == ЗДійсне {
покласти_в_накопичувач_значень(М, накопичувач_значень, НЕДІЙСНЕ);
} інакше {
покласти_в_накопичувач_значень(М, накопичувач_значень, ДІЙСНЕ);
}
стрибнути крок_виконати_далі;
}
якщо вказівка == ВДвійковеНЕ {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Застосувати двійкове НЕ можна лише для числа.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО(р64(~ц32(з1.дані як р64))));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВВідʼємне {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
якщо з1.вид != ЗЧисло {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Застосувати негацію можна лише для числа.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, ЧИСЛО(-(з1.дані як р64)));
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗаперечити {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
якщо з1.вид == ЗНедійсне {
покласти_в_накопичувач_значень(М, накопичувач_значень, ДІЙСНЕ);
} інакше {
покласти_в_накопичувач_значень(М, накопичувач_значень, НЕДІЙСНЕ);
}
стрибнути крок_виконати_далі;
}
якщо вказівка == ВПочатиСпробу {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // позиція_вказівки_зловити
назва = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту;
покласти_спробу(М, спроби, назва, а1);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВВпасти {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
увімкнути_стан_падіння(
М,
з1,
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
якщо вказівка == ВЗакінчитиСпробу {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // позиція_вказівки_виходу
видалити_останню_спробу(М, спроби);
позиція = а1;
стрибнути крок_виконання_вказівки;
}
якщо вказівка == ВВзяти {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_назв
дані_назв = пусто;
якщо а1 > 0 {
дані_назв = виділити<*ПредметТексту>(М, а1);
п1 = 0;
поки п1 < а1 {
дані_назв[а1 - п1 - 1] = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту; // назва
п1 += 1;
}
}
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // звідки
ткст1 = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту; // звідки
якщо порівняти_тексти(М, ткст1, М.константи_назв._модуль) {
результат = взяти_модуль(
М,
шлях_до_теки_модулів,
з1.вид != ЗНедійсне,
а1,
дані_назв,
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
} інакше якщо порівняти_тексти(М, ткст1, М.константи_назв._пак) {
результат = взяти_пак(
М,
а1,
дані_назв,
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
} інакше якщо порівняти_тексти(М, ткст1, М.константи_назв._біб) {
результат = взяти_біб(
М,
а1,
дані_назв,
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
} інакше {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Взяти можна лише модуль, пак або біб.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
}
звільнити(М, дані_назв);
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, результат);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВДати {
назва = забрати_з_накопичувача_значень(М, накопичувач_значень).дані як *Предмет як *ПредметТексту;
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
якщо здійснювач.вид != ЗПредмет {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Неможливо дати.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
модл1 = здійснювач.дані як *Предмет як *ПредметМодуля;
якщо модл1.клас != М.клас_Модуль {
увімкнути_стан_падіння(
М,
ПРЕДМЕТ(створити_текст(М, "Неможливо дати.")),
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
записати_властивість_модуля(
М,
модл1,
назва,
з1
);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВПеребратиДалі {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
покласти_в_накопичувач_значень(М, накопичувач_значень, з1);
результат = здійснити_властивість(
М,
з1,
М.константи_назв._далі,
Задіяні { ВидЗадіяних2, 0, пусто, 0 },
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо М.стан_падіння {
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_значень(М, накопичувач_значень, результат);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗбитиТекст {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // кількість_предметів
накопичувач_тексту = зробити_накопичувач_тексту(М, а1);
п = 0;
поки п < а1 {
з1 = отримати_з_накопичувача_значень(М, накопичувач_значень, а1 - п - 1); // значення
ткст1 = отримати_текст(
М,
з1,
Місцезнаходження { предмет_коду, позиція_поточної_вказівки }
);
якщо М.стан_падіння {
звільнити(М, накопичувач_тексту.дані);
якщо обробити_стан_падіння(М, спроби, дійсність, предмет_коду, позиція_поточної_вказівки, позиція::адреса) {
стрибнути крок_виконання_вказівки;
}
стрибнути крок_вихід;
}
покласти_в_накопичувач_тексту(М, накопичувач_тексту::адреса, ткст1.значення);
п += 1;
}
видалити_з_накопичувача_значень(М, накопичувач_значень, а1);
покласти_в_накопичувач_значень(
М,
накопичувач_значень,
ПРЕДМЕТ(створити_текст_без_копіювання(М, накопичувач_тексту.розмір, накопичувач_тексту.дані))
);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтрибнути {
позиція = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // позиція_вказівки_стрибка;
стрибнути крок_виконання_вказівки;
}
якщо вказівка == ВСтрибнутиЯкщоДійсне {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // позиція_вказівки_стрибка
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
якщо з1.вид != ЗНедійсне {
позиція = а1;
стрибнути крок_виконання_вказівки;
}
стрибнути крок_виконати_далі;
}
якщо вказівка == ВСтрибнутиЯкщоНедійсне {
а1 = природне(прочитати_аргумент_вказівки(вказівки, позиція::адреса)); // позиція_вказівки_стрибка
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
якщо з1.вид == ЗНедійсне {
позиція = а1;
стрибнути крок_виконання_вказівки;
}
стрибнути крок_виконати_далі;
}
якщо вказівка == ВЗабрати {
видалити_з_накопичувача_значень(М, накопичувач_значень, 1);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВДублювати {
з1 = забрати_з_накопичувача_значень(М, накопичувач_значень); // значення
покласти_в_накопичувач_значень(М, накопичувач_значень, з1);
покласти_в_накопичувач_значень(М, накопичувач_значень, з1);
стрибнути крок_виконати_далі;
}
якщо вказівка == ВВернути {
результат_вернути = забрати_з_накопичувача_значень(М, накопичувач_значень);
стрибнути крок_вихід;
}
надрукувати_п64(М, п64(вказівка));
ЗАПАНІКУВАТИ(М, "Невідома вказівка під час виконання коду.");
крок_виконати_далі:
позиція += 1;
}
крок_вихід:
вернути результат_вернути;
}
}
простір мавка {
дія предмет_дії_здійснити(
М: *Машина,
здійснювач: Значення,
предмет_дії: *ПредметДії,
задіяні: Задіяні,
місцезнаходження: Місцезнаходження
) -> ЗначенняАбоСтанПадіння {
якщо предмет_дії.рідна {
змінна рідна_дія = предмет_дії.код як РіднаДія;
змінна діяльність = покласти_в_історію_здійснення(
М,
пусто,
здійснювач,
предмет_дії,
задіяні,
місцезнаходження
);
змінна результат = рідна_дія(
М,
діяльність
);
якщо не М.стан_падіння {
видалити_з_історії_здійснення(М, 1);
}
вернути результат;
} інакше {
змінна дійсність = створити_дійсність(
М,
предмет_дії.дійсність_створення
);
змінна діяльність = покласти_в_історію_здійснення(
М,
дійсність,
здійснювач,
предмет_дії,
задіяні,
місцезнаходження
);
змінна розмір_позиційних = задіяні.розмір - (задіяні.кількість_імен * 2);
якщо предмет_дії.параметри.розмір > 0 {
змінна п: п32 = 0;
поки п < п32(предмет_дії.параметри.розмір) {
змінна параметр = предмет_дії.параметри.елементи[п].дані як *Предмет як *ПредметПараметра;
якщо п < розмір_позиційних {
записати_в_дійсність(
М,
дійсність,
параметр.назва,
задіяні.дані[п]
);
} інакше {
записати_в_дійсність(
М,
дійсність,
параметр.назва,
параметр.значення
);
}
п += 1;
}
якщо задіяні.кількість_імен > 0 {
п = 0;
поки п < задіяні.кількість_імен {
змінна назва = задіяні.дані[розмір_позиційних + задіяні.кількість_імен + п].дані як *Предмет як *ПредметТексту;
змінна значення = задіяні.дані[розмір_позиційних + п];
записати_в_дійсність(
М,
дійсність,
назва,
значення
);
п += 1;
}
}
}
змінна результат = виконати_код(
М,
М.накопичувач_значень::адреса,
діяльність.спроби::адреса,
дійсність,
здійснювач,
предмет_дії.код як *ПредметКоду,
0,
предмет_дії.шлях_до_теки_модулів
);
якщо М.стан_падіння {
вернути НЕДІЙСНЕ;
}
видалити_з_історії_здійснення(М, 1);
вернути результат;
}
}
}
простір мавка {
дія обробник_прочитання(сирий_текст: кд, кінець_файлу: логічне, помилка: природне, позиція_помилки: природне, аргумент: адреса) {
змінна розмова = аргумент як *Розмова;
змінна М = розмова.М;
якщо помилка {
змінна текст_помилки: кд;
якщо помилка == 1 {
текст_помилки = "Не вдалось перекодувати текст входу розмови.";
} інакше {
текст_помилки = "Невідома помилка.";
}
надрукувати_кд(М, текст_помилки);
стрибнути ще_раз;
}
якщо кінець_файлу {
відпустити_дійсність(М, розмова.дійсність);
звільнити(М, розмова);
М.розмова = пусто;
вернути;
}
якщо сирий_текст.розмір == 0 {
стрибнути ще_раз;
}
змінна успіх = ні;
змінна знаки: розбирач::Знаки;
змінна помилка_розбору_на_знаки: розбирач::ПомилкаРозборуНаЗнаки;
змінна сполуки: розбирач::Сполуки;
змінна помилка_розбору_на_сполуки: розбирач::ПомилкаРозборуНаСполуки;
змінна скомпільований_код: *ПредметКоду = пусто;
змінна помилка_компілювання: компілювач::ПомилкаКомпілювання;
змінна інформація_падіння: ІнформаціяПадіння;
успіх = розбирач::розібрати_на_знаки(
М,
сирий_текст,
знаки::адреса,
помилка_розбору_на_знаки::адреса
);
якщо не успіх {
змінна рядок = розбирач::отримати_рядок_помилки_розбору_на_знаки(
М,
помилка_розбору_на_знаки
);
змінна помилка = "Не вдалось розібрати текст входу розмови.";
надрукувати_кд(М, помилка);
стрибнути ще_раз;
}
успіх = розбирач::розібрати_знаки_на_сполуки(
М,
сирий_текст,
знаки,
сполуки::адреса,
помилка_розбору_на_сполуки::адреса
);
якщо не успіх {
змінна рядок = розбирач::отримати_рядок_помилки_розбору_на_сполуки(
М,
помилка_розбору_на_сполуки
);
змінна помилка = "Не вдалось розібрати знаки входу розмови.";
надрукувати_кд(М, помилка);
стрибнути ще_раз;
}
успіх = перекласти_в_код(
М,
розмова.шлях_до_стандартного_вводу,
сирий_текст,
знаки,
сполуки,
скомпільований_код::адреса,
помилка_компілювання::адреса
);
якщо не успіх {
змінна помилка = "Не вдалось перекласти сполуки на код.";
надрукувати_кд(М, помилка);
стрибнути ще_раз;
}
змінна предмет_дії = створити_дію(
М,
розмова.дійсність,
створити_текст(М, "розмова"),
М.пуста_послідовність,
пусто,
скомпільований_код,
М.шлях_до_теки_модулів
);
змінна розмір_історії = М.історія_здійснення.розмір;
змінна розмір_накопичувача_значень = М.накопичувач_значень.розмір;
змінна елемент_історії = покласти_в_історію_здійснення(
М,
розмова.дійсність,
ПРЕДМЕТ(розмова.предмет_модуля),
предмет_дії,
Задіяні { ВидЗадіяних2, 0, пусто, 0 },
Місцезнаходження { розмова.шлях_до_стандартного_вводу, 0 }
);
змінна результат = виконати_код(
М,
М.накопичувач_значень::адреса,
елемент_історії.спроби::адреса,
розмова.дійсність,
ПРЕДМЕТ(розмова.предмет_модуля),
скомпільований_код,
0,
предмет_дії.шлях_до_теки_модулів
);
якщо отримати_інформацію_падіння(М, інформація_падіння::адреса) {
розмова.обробити_падіння(
М,
інформація_падіння
);
знищити_інформацію_падіння(М, інформація_падіння);
вимкнути_стан_падіння(М);
} інакше {
розмова.обробити_значення(М, результат);
}
видалити_з_історії_здійснення(М, М.історія_здійснення.розмір - розмір_історії);
М.накопичувач_значень.розмір = розмір_накопичувача_значень;
ще_раз:
розмова.читати(
М,
"- ",
так,
обробник_прочитання,
розмова
);
}
дія почати_розмову(
М: *Машина,
шлях_до_стандартного_вводу: *ПредметДаних,
читати: ПочатиРозмовуДіяЧитати,
обробити_значення: ПочатиРозмовуДіяОбробитиЗначення,
обробити_падіння: ПочатиРозмовуДіяОбробитиПадіння,
) {
якщо М.розмова != пусто {
вернути; // потім: помилка?
}
змінна предмет_модуля = створити_модуль(
М,
створити_текст(М, "розмова")
);
змінна дійсність = створити_дійсність(
М,
М.глобальна_дійсність
);
дійсність.кількість_запозичень += 1;
М.розмова = виділити<Розмова>(М, 1);
М.розмова.М = М;
М.розмова.читати = читати;
М.розмова.шлях_до_стандартного_вводу = шлях_до_стандартного_вводу;
М.розмова.обробити_значення = обробити_значення;
М.розмова.обробити_падіння = обробити_падіння;
М.розмова.предмет_модуля = предмет_модуля;
М.розмова.дійсність = дійсність;
читати(
М,
"- ",
так,
обробник_прочитання,
М.розмова
);
}
}