// 2025-2026 Богданович Давид Когут Прихожденко (кдб.дійсність.укр)
взяти визначення мавка/перекладач;
дія перевірити_чи_кд_рівні(а: кд, б: кд) -> логічне {
якщо а.розмір != б.розмір {
вернути ні;
}
змінна п: природне = 0;
поки п < а.розмір {
якщо а.дані[п] != б.дані[п] {
вернути ні;
}
п += 1;
}
вернути так;
}
дія перевірити_чи_починається_на(значення: кд, починається_на: кд, п: *природне) -> логічне {
змінна пп: природне = 0;
поки пп < починається_на.розмір {
змінна ппп = п::вміст + пп;
якщо ппп >= значення.розмір {
вернути ні;
}
якщо значення.дані[ппп] != починається_на.дані[пп] {
вернути ні;
}
пп += 1;
}
п::вміст = п::вміст + пп - 1;
вернути так;
}
простір мавка {
простір перекладач {
внутрішня дія клонувати_кд(М: *Машина, значення: кд) -> кд {
змінна дані_клону_значення = виділити<п8>(М, значення.розмір);
змінна п: природне = 0;
поки п < значення.розмір {
дані_клону_значення[п] = значення.дані[п];
п += 1;
}
вернути кд {
значення.розмір,
дані_клону_значення
};
}
внутрішня дія отримати_оброблену_копію_кд_тексту(М: *Машина, значення_кд: кд, вихід: *кд) -> логічне {
змінна новий_розмір: природне = 0;
змінна нові_дані = виділити<п8>(М, значення_кд.розмір);
змінна п: природне = 0;
поки п < значення_кд.розмір {
змінна символ = значення_кд.дані[п];
якщо символ == розбирач::КД_ОБЕРНЕНА_ПОХИЛА {
якщо (п + 1) < значення_кд.розмір {
змінна наступний_символ = значення_кд.дані[п + 1];
якщо наступний_символ == розбирач::КД_ОБЕРНЕНА_ПОХИЛА {
нові_дані[новий_розмір] = розбирач::КД_ОБЕРНЕНА_ПОХИЛА;
новий_розмір += 1;
п += 1;
} інакше якщо наступний_символ == розбирач::КД_ДВОЛАПКА {
нові_дані[новий_розмір] = розбирач::КД_ДВОЛАПКА;
новий_розмір += 1;
п += 1;
} інакше якщо наступний_символ == розбирач::КД_ЛАПКА {
нові_дані[новий_розмір] = розбирач::КД_ЛАПКА;
новий_розмір += 1;
п += 1;
} інакше якщо наступний_символ == розбирач::КД_р {
нові_дані[новий_розмір] = розбирач::КД_РОЗРИВ;
новий_розмір += 1;
п += 1;
} інакше якщо наступний_символ == розбирач::КД_д {
нові_дані[новий_розмір] = розбирач::КД_ДІЯ;
новий_розмір += 1;
п += 1;
} інакше {
вернути ні;
}
} інакше {
вернути ні;
}
} інакше {
нові_дані[новий_розмір] = значення_кд.дані[п];
новий_розмір += 1;
}
п += 1;
}
вихід::вміст = кд {
новий_розмір,
нові_дані
};
вернути так;
}
внутрішня дія покласти_вказівку_ПокластиДійсне(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВПокластиДійсне);
}
внутрішня дія покласти_вказівку_ПокластиНедійсне(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВПокластиНедійсне);
}
внутрішня дія покласти_вказівку_ПокластиПредмет(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВПокластиПредмет);
}
внутрішня дія покласти_вказівку_ПокластиЯ(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВПокластиЯ);
}
внутрішня дія покласти_вказівку_ПокластиКонстанту(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, позиція_константи: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВПокластиКонстанту, позиція_константи);
}
внутрішня дія покласти_вказівку_Звернутись(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЗвернутись);
}
внутрішня дія покласти_вказівку_ОтриматиВластивість(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВОтриматиВластивість);
}
внутрішня дія покласти_вказівку_ОтриматиЕлемент(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВОтриматиЕлемент);
}
внутрішня дія покласти_вказівку_Здійснити(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, кількість_аргументів: п32, кількість_іменованих_аргументів: п32) -> п32 {
вернути дії.покласти_вказівку_з_двома_аргументами(М, код, рядок, ВЗдійснити, кількість_аргументів, кількість_іменованих_аргументів);
}
внутрішня дія покласти_вказівку_ЗдійснитиВластивість(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, кількість_аргументів: п32, кількість_іменованих_аргументів: п32) -> п32 {
вернути дії.покласти_вказівку_з_двома_аргументами(М, код, рядок, ВЗдійснитиВластивість, кількість_аргументів, кількість_іменованих_аргументів);
}
внутрішня дія покласти_вказівку_СтворитиПараметр(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВСтворитиПараметр);
}
внутрішня дія покласти_вказівку_СтворитиДію(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, кількість_параметрів: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВСтворитиДію, кількість_параметрів);
}
внутрішня дія покласти_вказівку_СтворитиМодуль(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВСтворитиМодуль);
}
внутрішня дія покласти_вказівку_СтворитиКлас(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, кількість_параметрів: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВСтворитиКлас, кількість_параметрів);
}
внутрішня дія покласти_вказівку_СтворитиСписок(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, кількість_елементів: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВСтворитиСписок, кількість_елементів);
}
внутрішня дія покласти_вказівку_СтворитиСловник(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, кількість_елементів: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВСтворитиСловник, кількість_елементів);
}
внутрішня дія покласти_вказівку_СтворитиДіапазон(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВСтворитиДіапазон);
}
внутрішня дія покласти_вказівку_ЗбитиТекст(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, кількість_елементів: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВЗбитиТекст, кількість_елементів);
}
внутрішня дія покласти_вказівку_Дублювати(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВДублювати);
}
внутрішня дія покласти_вказівку_Забрати(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЗабрати);
}
внутрішня дія покласти_вказівку_Стрибнути(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, позиція_вказівки: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВСтрибнути, позиція_вказівки);
}
внутрішня дія покласти_вказівку_СтрибнутиЯкщоНедійсне(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, позиція_вказівки: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВСтрибнутиЯкщоНедійсне, позиція_вказівки);
}
внутрішня дія покласти_вказівку_СтрибнутиЯкщоДійсне(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, позиція_вказівки: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВСтрибнутиЯкщоДійсне, позиція_вказівки);
}
внутрішня дія покласти_вказівку_Взяти(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, кількість_назв: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВВзяти, кількість_назв);
}
внутрішня дія покласти_вказівку_ПочатиСпробу(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, позиція_вказівки_зловити: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВПочатиСпробу, позиція_вказівки_зловити);
}
внутрішня дія покласти_вказівку_ЗакінчитиСпробу(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32, позиція_вказівки_виходу: п32) -> п32 {
вернути дії.покласти_вказівку_з_аргументом(М, код, рядок, ВЗакінчитиСпробу, позиція_вказівки_виходу);
}
внутрішня дія покласти_вказівку_Додати(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВДодати);
}
внутрішня дія покласти_вказівку_Відняти(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВВідняти);
}
внутрішня дія покласти_вказівку_Помножити(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВПомножити);
}
внутрішня дія покласти_вказівку_Поділити(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВПоділити);
}
внутрішня дія покласти_вказівку_ОтриматиОстачуДілення(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВОтриматиОстачуДілення);
}
внутрішня дія покласти_вказівку_ОтриматиНеповнуЧасткуДілення(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВОтриматиНеповнуЧасткуДілення);
}
внутрішня дія покласти_вказівку_ПіднестиДоСтепеня(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВПіднестиДоСтепеня);
}
внутрішня дія покласти_вказівку_ЗсунутиВліво(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЗсунутиВліво);
}
внутрішня дія покласти_вказівку_ЗсунутиВправо(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЗсунутиВправо);
}
внутрішня дія покласти_вказівку_ЗсунутиВправо2(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЗсунутиВправо2);
}
внутрішня дія покласти_вказівку_ДвійковеІ(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВДвійковеІ);
}
внутрішня дія покласти_вказівку_ДвійковеАБО(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВДвійковеАБО);
}
внутрішня дія покласти_вказівку_ДвійковеВиключнеАБО(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВДвійковеВиключнеАБО);
}
внутрішня дія покласти_вказівку_ДвійковеНЕ(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВДвійковеНЕ);
}
внутрішня дія покласти_вказівку_Менше(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВМенше);
}
внутрішня дія покласти_вказівку_Більше(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВБільше);
}
внутрішня дія покласти_вказівку_НеБільше(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВНеБільше);
}
внутрішня дія покласти_вказівку_НеМенше(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВНеМенше);
}
внутрішня дія покласти_вказівку_Рівно(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВРівно);
}
внутрішня дія покласти_вказівку_НеРівно(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВНеРівно);
}
внутрішня дія покласти_вказівку_Є(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЄ);
}
внутрішня дія покласти_вказівку_НеЄ(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВНеЄ);
}
внутрішня дія покласти_вказівку_Відʼємне(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВВідʼємне);
}
внутрішня дія покласти_вказівку_Заперечити(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЗаперечити);
}
внутрішня дія покласти_вказівку_Визначити(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВВизначити);
}
внутрішня дія покласти_вказівку_ВизначитиНавпаки(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВВизначитиНавпаки);
}
внутрішня дія покласти_вказівку_ЗаписатиМетод(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЗаписатиМетод);
}
внутрішня дія покласти_вказівку_ЗмінитиВластивість(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЗмінитиВластивість);
}
внутрішня дія покласти_вказівку_ЗмінитиЕлемент(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВЗмінитиЕлемент);
}
внутрішня дія покласти_вказівку_Вернути(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВВернути);
}
внутрішня дія покласти_вказівку_Впасти(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВВпасти);
}
внутрішня дія покласти_вказівку_Дати(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВДати);
}
внутрішня дія покласти_вказівку_ОтриматиПеребір(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВОтриматиПеребір);
}
внутрішня дія покласти_вказівку_ПеребратиДалі(М: *Машина, код: невідома_адреса, дії: Дії, рядок: п32) -> п32 {
вернути дії.покласти_вказівку(М, код, рядок, ВПеребратиДалі);
}
}
простір перекладач {
внутрішня дія зробити_помилку_перекладу(М: *Машина, текст: кд, знаки: розбирач::Знаки, місцезнаходження: розбирач::Місцезнаходження, повідомлення: кд) -> ПомилкаПерекладу;
внутрішня дія перекласти_сполуку_визначити(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиВизначити, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_звернутись(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиЗвернутись, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_отримати_властивість(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиОтриматиВластивість, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_отримати_елемент(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиОтриматиЕлемент, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_змінити_властивість(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиЗмінитиВластивість, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_змінити_елемент(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиЗмінитиЕлемент, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_виконати(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиВиконати, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_дія(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиДія, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_клас(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиКлас, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_число(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиЧисло, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_текст(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиТекст, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_операція(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиОперація, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_якщо(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиЯкщо, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_поки(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиПоки, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_вернути(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиВернути, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_значення_якщо(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиЗначенняЯкщо, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_само_операція(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиСамоОперація, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_взяти(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиВзяти, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_спробувати(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиСпробувати, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_впасти(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиВпасти, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_дати(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиДати, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_модуль(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиМодуль, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_список(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиСписок, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_словник(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиСловник, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилок: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_символ(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиСимвол, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилок: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_перебрати(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиПеребрати, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилок: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_цикл(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиЦикл, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилок: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_вічний_цикл(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиВічнийЦикл, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилок: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_чекати(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиЧекати, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилок: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_діапазон(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиДіапазон, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилок: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку_збитий_текст(М: *Машина, текст: кд, знаки: розбирач::Знаки, дані: розбирач::ДаніСполукиЗбитийТекст, місцезнаходження: розбирач::Місцезнаходження, код: невідома_адреса, дії: Дії, вихід_помилок: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_сполуку(М: *Машина, текст: кд, знаки: розбирач::Знаки, сполука: *розбирач::Сполука, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія перекласти_тіло(М: *Машина, сирий_текст: кд, знаки: розбирач::Знаки, сполуки: розбирач::Сполуки, вернути_в_кінці: логічне, код: невідома_адреса, дії: Дії, вихід_помилки: *ПомилкаПерекладу) -> логічне;
внутрішня дія зробити_помилку_перекладу(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
місцезнаходження: розбирач::Місцезнаходження,
повідомлення: кд
) -> ПомилкаПерекладу {
змінна знак = знаки.дані[місцезнаходження.позиція_знаку];
змінна рядок = розбирач::отримати_рядок_з_місцезнаходження(текст, знаки, місцезнаходження);
змінна стовпець = розбирач::отримати_стовпець_з_місцезнаходження(текст, знаки, місцезнаходження);
вернути ПомилкаПерекладу {
позиція_в_тексті = знак.позиція_початку.позиція_в_тексті,
рядок = рядок,
стовпець = стовпець,
повідомлення = повідомлення,
};
}
внутрішня дія перекласти_сполуку_визначити(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиВизначити,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
дані.ідентифікатор
);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.значення,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_Визначити(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_звернутись(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиЗвернутись,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
дані.ідентифікатор
);
якщо перевірити_чи_кд_рівні(текст_ідентифікатора, "дійсне") {
покласти_вказівку_ПокластиДійсне(М, код, дії, рядок);
} інакше якщо перевірити_чи_кд_рівні(текст_ідентифікатора, "недійсне") {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
} інакше якщо перевірити_чи_кд_рівні(текст_ідентифікатора, "я") {
покласти_вказівку_ПокластиЯ(М, код, дії, рядок);
} інакше {
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
покласти_вказівку_Звернутись(М, код, дії, рядок);
}
вернути так;
}
внутрішня дія перекласти_сполуку_отримати_властивість(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиОтриматиВластивість,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
дані.ідентифікатор
);
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.предмет,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
покласти_вказівку_ОтриматиВластивість(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_отримати_елемент(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиОтриматиЕлемент,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.предмет,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.ключ,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_ОтриматиЕлемент(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_змінити_властивість(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиЗмінитиВластивість,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.предмет,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
дані.ідентифікатор
);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.значення,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_ЗмінитиВластивість(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_змінити_елемент(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиЗмінитиЕлемент,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.предмет,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.ключ,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.значення,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_ЗмінитиЕлемент(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_виконати(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиВиконати,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
якщо дані.предмет.вид == розбирач::ВидСполукиОтриматиВластивість {
змінна дані_отримання = дані.предмет.дані як розбирач::ДаніСполукиОтриматиВластивість;
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані_отримання.предмет,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
дані_отримання.ідентифікатор
);
змінна позиція_назви_властивості = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви_властивості);
} інакше {
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.предмет,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
}
змінна початок_назв: п32 = 0;
змінна є_назви = ні;
змінна п: п32 = 0;
поки п < п32(дані.кількість_аргументів) {
змінна аргумент = дані.аргументи[п];
змінна рядок_аргумента = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
аргумент.місцезнаходження
));
якщо аргумент.ідентифікатор.заповнено {
якщо не є_назви {
початок_назв = п;
є_назви = так;
}
успіх = перекласти_сполуку(
М,
текст,
знаки,
аргумент.значення,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
} інакше {
якщо є_назви {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
аргумент.місцезнаходження,
клонувати_кд(М, "Безіменні задіяні не можуть йти після іменованих задіяних.")
);
вернути ні;
}
успіх = перекласти_сполуку(
М,
текст,
знаки,
аргумент.значення,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
}
п += 1;
}
якщо є_назви {
п = початок_назв;
поки п < п32(дані.кількість_аргументів) {
змінна аргумент = дані.аргументи[п];
змінна рядок_аргумента = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
аргумент.місцезнаходження
));
змінна текст_ідентифікатора_аргумента = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
аргумент.ідентифікатор.значення
);
змінна позиція_назви_аргумента = дії.покласти_константу_тексту(М, код, текст_ідентифікатора_аргумента);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок_аргумента, позиція_назви_аргумента);
п += 1;
}
}
змінна кількість_назв: п32 = 0;
якщо є_назви {
кількість_назв = п32(дані.кількість_аргументів) - початок_назв;
}
якщо дані.предмет.вид == розбирач::ВидСполукиОтриматиВластивість {
покласти_вказівку_ЗдійснитиВластивість(М, код, дії, рядок, п32(дані.кількість_аргументів), кількість_назв);
} інакше {
покласти_вказівку_Здійснити(М, код, дії, рядок, п32(дані.кількість_аргументів), кількість_назв);
}
вернути так;
}
внутрішня дія перекласти_сполуку_дія(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиДія,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
якщо дані.ідентифікатор.заповнено {
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
дані.ідентифікатор.значення
);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви); // назва
} інакше {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок); // назва
}
змінна п: природне = 0;
поки п < дані.кількість_параметрів {
змінна параметр = дані.параметри[п];
змінна рядок_параметра = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
параметр.місцезнаходження
));
змінна значення_ідентифікатора_параметра = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
параметр.ідентифікатор
);
змінна позиція_назви_параметра = дії.покласти_константу_тексту(М, код, значення_ідентифікатора_параметра);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви_параметра);
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок); // тип параметра
якщо параметр.значення == пусто {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок); // дія значення
} інакше {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Значення параметра зараз не підтримується.")
);
вернути ні;
}
покласти_вказівку_СтворитиПараметр(М, код, дії, рядок);
п += 1;
}
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок); // тип результату
змінна код_дії = дії.створити_код(М, дії.отримати_шлях_коду(М, код));
успіх = перекласти_тіло(
М,
текст,
знаки,
дані.тіло,
так,
код_дії,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна позиція_коду_дії = дії.покласти_константу_коду(М, код, код_дії);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_коду_дії); // код
покласти_вказівку_СтворитиДію(М, код, дії, рядок, п32(дані.кількість_параметрів));
вернути так;
}
внутрішня дія перекласти_сполуку_клас(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиКлас,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
якщо дані.ідентифікатор.заповнено {
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
дані.ідентифікатор.значення
);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви); // назва
} інакше {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок); // назва
}
якщо дані.предок != пусто {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Спадкування структур зараз не підтримується.")
);
вернути ні;
}
змінна п: природне = 0;
поки п < дані.кількість_параметрів {
змінна параметр = дані.параметри[п];
змінна рядок_параметра = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
параметр.місцезнаходження
));
змінна текст_ідентифікатора_параметра = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
параметр.ідентифікатор
);
змінна позиція_назви_параметра = дії.покласти_константу_тексту(М, код, текст_ідентифікатора_параметра);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви_параметра); // назва параметра
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок); // тип параметра
якщо параметр.значення == пусто {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок); // дія значення
} інакше {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Значення параметра зараз не підтримується.")
);
вернути ні;
}
покласти_вказівку_СтворитиПараметр(М, код, дії, рядок);
п += 1;
}
покласти_вказівку_СтворитиКлас(М, код, дії, рядок, п32(дані.кількість_параметрів));
п = 0;
поки п < дані.методи.розмір {
змінна сполука_дії = дані.методи.дані[п];
змінна дані_дії = сполука_дії.дані як розбирач::ДаніСполукиДія;
якщо дані_дії.клас != пусто {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
сполука_дії.місцезнаходження,
клонувати_кд(М, "Метод всередині тіла класу не може посилатись на клас.")
);
вернути ні;
}
якщо не дані_дії.ідентифікатор.заповнено {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
сполука_дії.місцезнаходження,
клонувати_кд(М, "Метод класу має мати назву.")
);
вернути ні;
}
покласти_вказівку_Дублювати(М, код, дії, рядок);
змінна текст_ідентифікатора_метода = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
дані_дії.ідентифікатор.значення
);
змінна позиція_назви_метода = дії.покласти_константу_тексту(М, код, текст_ідентифікатора_метода);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви_метода);
успіх = перекласти_сполуку_дія(
М,
текст,
знаки,
дані_дії,
сполука_дії.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_ЗаписатиМетод(М, код, дії, рядок);
покласти_вказівку_Забрати(М, код, дії, рядок);
п += 1;
}
вернути так;
}
внутрішня дія перекласти_сполуку_число(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиЧисло,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна знак = знаки.дані[дані.позиція_знаку];
змінна текст_знаку = розбирач::отримати_значення_знаку(
текст,
знаки,
знак
);
змінна розібране_число: р64;
успіх = розібрати_число_з_кд(М, текст_знаку, розібране_число::адреса);
якщо не успіх {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Не вдалось розібрати число.")
);
вернути ні;
}
змінна позиція_константи = дії.покласти_константу_числа(М, код, розібране_число);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_константи);
вернути так;
}
внутрішня дія перекласти_сполуку_текст(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиТекст,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна знак = знаки.дані[дані.позиція_знаку];
змінна значення_тексту = розбирач::отримати_значення_тексту(текст, знаки, знак);
змінна оброблене_значення_тексту_кд = кд { 0, пусто };
успіх = отримати_оброблену_копію_кд_тексту(М, значення_тексту, оброблене_значення_тексту_кд::адреса);
якщо не успіх {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Не вдалось розібрати текст.")
);
вернути ні;
}
змінна позиція_константи = дії.покласти_константу_тексту(М, код, оброблене_значення_тексту_кд);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_константи);
звільнити(М, оброблене_значення_тексту_кд.дані);
вернути так;
}
внутрішня дія перекласти_сполуку_операція(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиОперація,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.ліво,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо дані.операція == розбирач::ВидОпераціїІ {
покласти_вказівку_Дублювати(М, код, дії, рядок);
змінна позиція_вказівки_стрибнути_якщо_недійсне = покласти_вказівку_СтрибнутиЯкщоНедійсне(М, код, дії, рядок, 0);
покласти_вказівку_Забрати(М, код, дії, рядок);
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.право,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_стрибнути_якщо_недійсне,
0,
дії.отримати_розмір_вказівок(М, код)
);
вернути так;
}
якщо дані.операція == розбирач::ВидОпераціїАБО {
покласти_вказівку_Дублювати(М, код, дії, рядок);
змінна позиція_вказівки_стрибнути_якщо_дійсне = покласти_вказівку_СтрибнутиЯкщоДійсне(М, код, дії, рядок, 0);
покласти_вказівку_Забрати(М, код, дії, рядок);
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.право,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_стрибнути_якщо_дійсне,
0,
дії.отримати_розмір_вказівок(М, код)
);
вернути так;
}
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.право,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо дані.операція == розбирач::ВидОпераціїДодавання {
покласти_вказівку_Додати(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїВіднімання {
покласти_вказівку_Відняти(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїМноження {
покласти_вказівку_Помножити(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїДілення {
покласти_вказівку_Поділити(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїМодуль {
покласти_вказівку_ОтриматиОстачуДілення(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїДіленняНаціло {
покласти_вказівку_ОтриматиНеповнуЧасткуДілення(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїПіднесенняДоСтепеня {
покласти_вказівку_ПіднестиДоСтепеня(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїЗсувВліво {
покласти_вказівку_ЗсунутиВліво(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїЗсувВправо {
покласти_вказівку_ЗсунутиВправо(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїЗсувВправоЗнаковий {
покласти_вказівку_ЗсунутиВправо2(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїДІ {
покласти_вказівку_ДвійковеІ(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїДАБО {
покласти_вказівку_ДвійковеАБО(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїВАБО {
покласти_вказівку_ДвійковеВиключнеАБО(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїМенше {
покласти_вказівку_Менше(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїБільше {
покласти_вказівку_Більше(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїМеншеРівне {
покласти_вказівку_НеБільше(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїБільшеРівне {
покласти_вказівку_НеМенше(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїРівне {
покласти_вказівку_Рівно(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїНерівне {
покласти_вказівку_НеРівно(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїЄ {
покласти_вказівку_Є(М, код, дії, рядок);
вернути так;
} інакше якщо дані.операція == розбирач::ВидОпераціїНеЄ {
покласти_вказівку_НеЄ(М, код, дії, рядок);
вернути так;
}
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Невідома операція.")
);
вернути ні;
}
внутрішня дія перекласти_сполуку_якщо(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиЯкщо,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.умова,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна позиція_вказівки_якщо_недійсне = покласти_вказівку_СтрибнутиЯкщоНедійсне(М, код, дії, рядок, 0);
якщо дані.тіло.розмір != 0 {
успіх = перекласти_тіло(
М,
текст,
знаки,
дані.тіло,
ні,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
}
змінна позиція_вказівки_якщо_дійсне = покласти_вказівку_Стрибнути(М, код, дії, рядок, 0);
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_якщо_недійсне,
0,
дії.отримати_розмір_вказівок(М, код)
);
якщо дані.тіло_інакше.розмір != 0 {
успіх = перекласти_тіло(
М,
текст,
знаки,
дані.тіло_інакше,
ні,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
}
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_якщо_дійсне,
0,
дії.отримати_розмір_вказівок(М, код)
);
вернути так;
}
внутрішня дія перекласти_сполуку_поки(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиПоки,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна позиція_вказівки_початку_поки = дії.отримати_розмір_вказівок(М, код);
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.умова,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна позиція_вказівки_якщо_недійсне = покласти_вказівку_СтрибнутиЯкщоНедійсне(М, код, дії, рядок, 0);
успіх = перекласти_тіло(
М,
текст,
знаки,
дані.тіло,
ні,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_Стрибнути(М, код, дії, рядок, позиція_вказівки_початку_поки);
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_якщо_недійсне,
0,
дії.отримати_розмір_вказівок(М, код)
);
вернути так;
}
внутрішня дія перекласти_сполуку_вернути(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиВернути,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
якщо дані.значення == пусто {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
} інакше {
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.значення,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
}
покласти_вказівку_Вернути(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_значення_якщо(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиЗначенняЯкщо,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.умова,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна позиція_вказівки_стрибнути_якщо_недійсне = покласти_вказівку_СтрибнутиЯкщоНедійсне(М, код, дії, рядок, 0);
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.значення_так,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна позиція_вказівки_виходу_з_так = покласти_вказівку_Стрибнути(М, код, дії, рядок, 0);
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_стрибнути_якщо_недійсне,
0,
дії.отримати_розмір_вказівок(М, код)
);
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.значення_ні,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_виходу_з_так,
0,
дії.отримати_розмір_вказівок(М, код)
);
вернути так;
}
внутрішня дія перекласти_сполуку_само_операція(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиСамоОперація,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.предмет,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо дані.операція == розбирач::ВидСамоОпераціїЛогічнеНі {
покласти_вказівку_Заперечити(М, код, дії, рядок);
вернути так;
}
якщо дані.операція == розбирач::ВидСамоОпераціїДвійковеНі {
покласти_вказівку_ДвійковеНЕ(М, код, дії, рядок);
вернути так;
}
якщо дані.операція == розбирач::ВидСамоОпераціїМінус {
покласти_вказівку_Відʼємне(М, код, дії, рядок);
вернути так;
}
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Невідома самооперація.")
);
вернути ні;
}
внутрішня дія перекласти_сполуку_взяти(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиВзяти,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, дані.тип.значення);
змінна позиція_назви_типу = дії.покласти_константу_тексту(М, код, назва);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви_типу);
змінна позиція_останьої_назви: п32 = 0;
змінна пп: п32 = 0;
поки пп < п32(дані.довжина_шляху) {
змінна елемент_шляху = дані.шлях[пп];
змінна назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, елемент_шляху);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, назва );
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
якщо пп == п32(дані.довжина_шляху) - 1 {
позиція_останьої_назви = позиція_назви;
}
пп += 1;
}
покласти_вказівку_Взяти(М, код, дії, рядок, п32(дані.довжина_шляху));
якщо не дані.ідентифікатор_як.заповнено {
якщо дані.кількість_елементів == 0 {
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_останьої_назви);
покласти_вказівку_ВизначитиНавпаки(М, код, дії, рядок);
} інакше {
змінна пе: п32 = 0;
поки пе < п32(дані.кількість_елементів) {
змінна елемент = дані.елементи[пе];
покласти_вказівку_Дублювати(М, код, дії, рядок);
змінна назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, елемент.ідентифікатор);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, назва);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
покласти_вказівку_ОтриматиВластивість(М, код, дії, рядок);
якщо елемент.ідентифікатор_як.заповнено {
змінна назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, елемент.ідентифікатор_як.значення);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, назва);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
покласти_вказівку_ВизначитиНавпаки(М, код, дії, рядок);
} інакше {
змінна назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, елемент.ідентифікатор);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, назва);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
покласти_вказівку_ВизначитиНавпаки(М, код, дії, рядок);
}
пе += 1;
}
}
} інакше {
змінна назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, дані.ідентифікатор_як.значення);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, назва);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
покласти_вказівку_ВизначитиНавпаки(М, код, дії, рядок);
}
вернути так;
}
внутрішня дія перекласти_сполуку_спробувати(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиСпробувати,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
якщо дані.ідентифікатор_зловити.заповнено {
змінна назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, дані.ідентифікатор_зловити.значення);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, назва);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
} інакше {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
}
змінна позиція_вказівки_почати_спробу = покласти_вказівку_ПочатиСпробу(М, код, дії, рядок, 0);
успіх = перекласти_тіло(
М,
текст,
знаки,
дані.тіло,
ні,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна позиція_вказівки_закінчити_спробу = покласти_вказівку_ЗакінчитиСпробу(М, код, дії, рядок, 0);
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_почати_спробу,
0,
дії.отримати_розмір_вказівок(М, код)
);
успіх = перекласти_тіло(
М,
текст,
знаки,
дані.тіло_зловити,
ні,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_закінчити_спробу,
0,
дії.отримати_розмір_вказівок(М, код)
);
вернути так;
}
внутрішня дія перекласти_сполуку_впасти(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиВпасти,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
якщо дані.значення == пусто {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
} інакше {
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.значення,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
}
покласти_вказівку_Впасти(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_дати(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиДати,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна пп: п32 = 0;
поки пп < п32(дані.кількість_елементів) {
змінна елемент = дані.елементи[пп];
змінна назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, елемент.ідентифікатор);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, назва);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви); // назва
покласти_вказівку_Звернутись(М, код, дії, рядок); // предмет
якщо елемент.ідентифікатор_як.заповнено {
змінна назва_як = розбирач::отримати_значення_ідентифікатора(текст, знаки, елемент.ідентифікатор_як.значення);
змінна позиція_назви_як = дії.покласти_константу_тексту(М, код, назва_як);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви_як); // назва
} інакше {
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви); // назва
}
покласти_вказівку_Дати(М, код, дії, рядок);
пп += 1;
}
вернути так;
}
внутрішня дія перекласти_сполуку_модуль(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиМодуль,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
якщо дані.ідентифікатор.заповнено {
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
текст,
знаки,
дані.ідентифікатор.значення
);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви); // назва
} інакше {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок); // назва
}
змінна код_модуля = дії.створити_код(М, дії.отримати_шлях_коду(М, код));
успіх = перекласти_тіло(
М,
текст,
знаки,
дані.тіло,
так,
код_модуля,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
змінна позиція_коду_модуля = дії.покласти_константу_коду(М, код, код_модуля);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_коду_модуля); // код
покласти_вказівку_СтворитиМодуль(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_список(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиСписок,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна п: природне = 0;
поки п < дані.кількість_елементів {
змінна елемент_списку = дані.елементи[п];
успіх = перекласти_сполуку(
М,
текст,
знаки,
елемент_списку,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
п += 1;
}
покласти_вказівку_СтворитиСписок(М, код, дії, рядок, п32(дані.кількість_елементів));
вернути так;
}
внутрішня дія перекласти_сполуку_словник(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиСловник,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна п: п32 = 0;
поки п < п32(дані.кількість_елементів) {
змінна елемент_словника = дані.елементи[п];
успіх = перекласти_сполуку(
М,
текст,
знаки,
елемент_словника.ключ,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
успіх = перекласти_сполуку(
М,
текст,
знаки,
елемент_словника.значення,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
п += 1;
}
покласти_вказівку_СтворитиСловник(М, код, дії, рядок, п32(дані.кількість_елементів));
вернути так;
}
внутрішня дія перекласти_сполуку_символ(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиСимвол,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна знак = знаки.дані[дані.позиція_знаку];
змінна значення_символа_кд = розбирач::отримати_значення_символу(
текст,
знаки,
знак
);
змінна оброблене_значення_символу_кд = кд { 0, пусто };
успіх = отримати_оброблену_копію_кд_тексту(М, значення_символа_кд, оброблене_значення_символу_кд::адреса);
якщо не успіх {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Не вдалось розібрати символ.")
);
вернути ні;
}
змінна позиція_константи: п32 = 0;
якщо оброблене_значення_символу_кд.розмір == 0 {
звільнити(М, оброблене_значення_символу_кд.дані);
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Символ не може бути порожнім.")
);
вернути ні;
} інакше {
позиція_константи = дії.покласти_константу_числа(
М,
код,
р64(оброблене_значення_символу_кд.дані[0])
);
}
звільнити(М, оброблене_значення_символу_кд.дані);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_константи);
вернути так;
}
внутрішня дія перекласти_сполуку_перебрати(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиПеребрати,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.предмет,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_ОтриматиПеребір(М, код, дії, рядок);
змінна позиція_вказівки_початку_перебору = покласти_вказівку_ПеребратиДалі(М, код, дії, рядок);
змінна позиція_вказівки_якщо_недійсне = покласти_вказівку_СтрибнутиЯкщоНедійсне(М, код, дії, рядок, 0);
покласти_вказівку_Дублювати(М, код, дії, рядок);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, дії.покласти_константу_тексту(М, код, "значення"));
покласти_вказівку_ОтриматиВластивість(М, код, дії, рядок);
змінна назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, дані.ідентифікатор.значення);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, назва);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
покласти_вказівку_ВизначитиНавпаки(М, код, дії, рядок);
успіх = перекласти_тіло(
М,
текст,
знаки,
дані.тіло,
ні,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_Стрибнути(М, код, дії, рядок, позиція_вказівки_початку_перебору);
дії.змінити_аргумент_вказівки(
М,
код,
позиція_вказівки_якщо_недійсне,
0,
дії.отримати_розмір_вказівок(М, код)
);
назва = розбирач::отримати_значення_ідентифікатора(текст, знаки, дані.ідентифікатор.значення);
позиція_назви = дії.покласти_константу_тексту(М, код, назва);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Визначити(М, код, дії, рядок);
покласти_вказівку_Забрати(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_цикл(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиЦикл,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
місцезнаходження,
клонувати_кд(М, "Цикл не втілено.")
);
вернути ні;
}
внутрішня дія перекласти_сполуку_вічний_цикл(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиВічнийЦикл,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна позиція_вказівки_початку_циклу = дії.отримати_розмір_вказівок(М, код);
успіх = перекласти_тіло(
М,
текст,
знаки,
дані.тіло,
ні,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_Стрибнути(М, код, дії, рядок, позиція_вказівки_початку_циклу);
вернути так;
}
внутрішня дія перекласти_сполуку_чекати(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиЧекати,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
// ...
}
внутрішня дія перекласти_сполуку_діапазон(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиДіапазон,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.від,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо дані.включно {
покласти_вказівку_ПокластиДійсне(М, код, дії, рядок);
} інакше {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
}
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.до,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
покласти_вказівку_СтворитиДіапазон(М, код, дії, рядок);
вернути так;
}
внутрішня дія перекласти_сполуку_збитий_текст(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
дані: розбирач::ДаніСполукиЗбитийТекст,
місцезнаходження: розбирач::Місцезнаходження,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
текст,
знаки,
місцезнаходження
));
змінна п: природне = 0;
поки п < дані.кількість_гілок {
успіх = перекласти_сполуку(
М,
текст,
знаки,
дані.сполуки[п],
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
п += 1;
}
покласти_вказівку_ЗбитиТекст(М, код, дії, рядок, п32(дані.кількість_гілок));
вернути так;
}
внутрішня дія перекласти_сполуку(
М: *Машина,
текст: кд,
знаки: розбирач::Знаки,
сполука: *розбирач::Сполука,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
якщо сполука.вид == розбирач::ВидСполукиЗвернутись {
вернути перекласти_сполуку_звернутись(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиЗвернутись,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиОтриматиВластивість {
вернути перекласти_сполуку_отримати_властивість(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиОтриматиВластивість,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиОтриматиЕлемент {
вернути перекласти_сполуку_отримати_елемент(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиОтриматиЕлемент,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиВиконати {
вернути перекласти_сполуку_виконати(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиВиконати,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиДія {
вернути перекласти_сполуку_дія(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиДія,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиКлас {
вернути перекласти_сполуку_клас(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиКлас,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиЧисло {
вернути перекласти_сполуку_число(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиЧисло,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиТекст {
вернути перекласти_сполуку_текст(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиТекст,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиОперація {
вернути перекласти_сполуку_операція(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиОперація,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиЗначенняЯкщо {
вернути перекласти_сполуку_значення_якщо(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиЗначенняЯкщо,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиСамоОперація {
вернути перекласти_сполуку_само_операція(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиСамоОперація,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиМодуль {
вернути перекласти_сполуку_модуль(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиМодуль,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиСписок {
вернути перекласти_сполуку_список(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиСписок,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиСловник {
вернути перекласти_сполуку_словник(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиСловник,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиСимвол {
вернути перекласти_сполуку_символ(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиСимвол,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиЧекати {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
сполука.місцезнаходження,
клонувати_кд(М, "Чекати зараз не підтримується.")
);
вернути ні;
}
якщо сполука.вид == розбирач::ВидСполукиДіапазон {
вернути перекласти_сполуку_діапазон(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиДіапазон,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
якщо сполука.вид == розбирач::ВидСполукиЗбитийТекст {
вернути перекласти_сполуку_збитий_текст(
М,
текст,
знаки,
сполука.дані як розбирач::ДаніСполукиЗбитийТекст,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
}
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
текст,
знаки,
сполука.місцезнаходження,
клонувати_кд(М, "Неочікувана сполука для перекладу.")
);
вернути ні;
}
внутрішня дія перекласти_тіло(
М: *Машина,
сирий_текст: кд,
знаки: розбирач::Знаки,
сполуки: розбирач::Сполуки,
вернути_в_кінці: логічне,
код: невідома_адреса,
дії: Дії,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна успіх = ні;
змінна п: природне = 0;
поки п < сполуки.розмір {
змінна сполука = сполуки.дані[п];
змінна рядок = п32(розбирач::отримати_рядок_з_місцезнаходження(
сирий_текст,
знаки,
сполука.місцезнаходження
));
якщо сполука.вид == розбирач::ВидСполукиВизначити {
успіх = перекласти_сполуку_визначити(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиВизначити,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиДія {
змінна дані = сполука.дані як розбирач::ДаніСполукиДія;
якщо дані.ідентифікатор.заповнено {
якщо дані.клас != пусто {
успіх = перекласти_сполуку(
М,
сирий_текст,
знаки,
дані.клас,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
}
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
сирий_текст,
знаки,
дані.ідентифікатор.значення
);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
}
успіх = перекласти_сполуку(
М,
сирий_текст,
знаки,
сполука,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо дані.ідентифікатор.заповнено {
якщо дані.клас == пусто {
покласти_вказівку_Визначити(М, код, дії, рядок);
// потім: обробити це
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше {
покласти_вказівку_ЗаписатиМетод(М, код, дії, рядок);
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_Вернути(М, код, дії, рядок);
} інакше {
покласти_вказівку_Забрати(М, код, дії, рядок);
}
}
} інакше {
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_Вернути(М, код, дії, рядок);
} інакше {
покласти_вказівку_Забрати(М, код, дії, рядок);
}
}
} інакше якщо сполука.вид == розбирач::ВидСполукиКлас {
змінна дані = сполука.дані як розбирач::ДаніСполукиКлас;
якщо дані.ідентифікатор.заповнено {
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
сирий_текст,
знаки,
дані.ідентифікатор.значення
);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
}
успіх = перекласти_сполуку(
М,
сирий_текст,
знаки,
сполука,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо дані.ідентифікатор.заповнено {
покласти_вказівку_Визначити(М, код, дії, рядок);
// потім: обробити це
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше {
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_Вернути(М, код, дії, рядок);
} інакше {
покласти_вказівку_Забрати(М, код, дії, рядок);
}
}
} інакше якщо сполука.вид == розбирач::ВидСполукиМодуль {
змінна дані = сполука.дані як розбирач::ДаніСполукиМодуль;
якщо дані.ідентифікатор.заповнено {
змінна текст_ідентифікатора = розбирач::отримати_значення_ідентифікатора(
сирий_текст,
знаки,
дані.ідентифікатор.значення
);
змінна позиція_назви = дії.покласти_константу_тексту(М, код, текст_ідентифікатора);
покласти_вказівку_ПокластиКонстанту(М, код, дії, рядок, позиція_назви);
}
успіх = перекласти_сполуку(
М,
сирий_текст,
знаки,
сполука,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо дані.ідентифікатор.заповнено {
покласти_вказівку_Визначити(М, код, дії, рядок);
// потім: обробити це
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше {
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_Вернути(М, код, дії, рядок);
} інакше {
покласти_вказівку_Забрати(М, код, дії, рядок);
}
}
} інакше якщо сполука.вид == розбирач::ВидСполукиЗвернутись
або сполука.вид == розбирач::ВидСполукиОтриматиВластивість
або сполука.вид == розбирач::ВидСполукиОтриматиЕлемент
або сполука.вид == розбирач::ВидСполукиВиконати
або сполука.вид == розбирач::ВидСполукиЧисло
або сполука.вид == розбирач::ВидСполукиТекст
або сполука.вид == розбирач::ВидСполукиОперація
або сполука.вид == розбирач::ВидСполукиЗначенняЯкщо
або сполука.вид == розбирач::ВидСполукиСписок
або сполука.вид == розбирач::ВидСполукиСловник
або сполука.вид == розбирач::ВидСполукиСимвол
або сполука.вид == розбирач::ВидСполукиЧекати
або сполука.вид == розбирач::ВидСполукиДіапазон
або сполука.вид == розбирач::ВидСполукиЗбитийТекст
або сполука.вид == розбирач::ВидСполукиСамоОперація {
успіх = перекласти_сполуку(
М,
сирий_текст,
знаки,
сполука,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_Вернути(М, код, дії, рядок);
} інакше {
покласти_вказівку_Забрати(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиЗмінитиВластивість {
успіх = перекласти_сполуку_змінити_властивість(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиЗмінитиВластивість,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиЗмінитиЕлемент {
успіх = перекласти_сполуку_змінити_елемент(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиЗмінитиЕлемент,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиЯкщо {
успіх = перекласти_сполуку_якщо(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиЯкщо,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиПоки {
успіх = перекласти_сполуку_поки(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиПоки,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиВернути {
успіх = перекласти_сполуку_вернути(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиВернути,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
} інакше якщо сполука.вид == розбирач::ВидСполукиВзяти {
успіх = перекласти_сполуку_взяти(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиВзяти,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиСпробувати {
успіх = перекласти_сполуку_спробувати(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиСпробувати,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиВпасти {
успіх = перекласти_сполуку_впасти(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиВпасти,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
} інакше якщо сполука.вид == розбирач::ВидСполукиДати {
успіх = перекласти_сполуку_дати(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиДати,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиПеребрати {
успіх = перекласти_сполуку_перебрати(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиПеребрати,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиЦикл {
успіх = перекласти_сполуку_цикл(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиЦикл,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше якщо сполука.вид == розбирач::ВидСполукиВічнийЦикл {
успіх = перекласти_сполуку_вічний_цикл(
М,
сирий_текст,
знаки,
сполука.дані як розбирач::ДаніСполукиВічнийЦикл,
сполука.місцезнаходження,
код,
дії,
вихід_помилки
);
якщо не успіх {
вернути ні;
}
якщо вернути_в_кінці і п == сполуки.розмір - 1 {
покласти_вказівку_ПокластиНедійсне(М, код, дії, рядок);
покласти_вказівку_Вернути(М, код, дії, рядок);
}
} інакше {
вихід_помилки::вміст = зробити_помилку_перекладу(
М,
сирий_текст,
знаки,
сполука.місцезнаходження,
клонувати_кд(М, "Невідома сполука.")
);
вернути ні;
}
п += 1;
}
вернути так;
}
дія перекласти(
М: *Машина,
шлях: невідома_адреса,
сирий_текст: кд,
знаки: розбирач::Знаки,
сполуки: розбирач::Сполуки,
дії: Дії,
вихід_коду: *адреса,
вихід_помилки: *ПомилкаПерекладу
) -> логічне {
змінна код = дії.створити_код(М, шлях);
змінна успіх_перекладу_тіла = перекласти_тіло(
М,
сирий_текст,
знаки,
сполуки,
так,
код,
дії,
вихід_помилки
);
якщо не успіх_перекладу_тіла {
вернути успіх_перекладу_тіла;
}
вихід_коду::вміст = код;
вернути так;
}
}
простір перекладач_в_код {
структура Константи {
розмір: п32;
дані: *Значення;
}
структура Вказівки {
розмір: п32;
дані: *п8;
}
структура Код {
константи: Константи;
вказівки: Вказівки;
шлях: *ПредметДаних;
місцезнаходження_вказівок: МісцезнаходженняВказівок;
}
внутрішня дія покласти_константу(М: *Машина, код: невідома_адреса, значення: Значення) -> п32 {
змінна код_як_код = код як *Код;
код_як_код.константи.дані = перевиділити<Значення>(М, код_як_код.константи.дані, природне(код_як_код.константи.розмір + 1));
код_як_код.константи.дані[код_як_код.константи.розмір] = значення;
код_як_код.константи.розмір += 1;
вернути код_як_код.константи.розмір - 1;
}
внутрішня дія створити_код(М: *Машина, шлях: невідома_адреса) -> невідома_адреса {
змінна код = виділити<Код>(М, 1);
код.константи = Константи { 0, пусто };
код.вказівки = Вказівки { 0, пусто };
код.шлях = шлях як *ПредметДаних;
код.місцезнаходження_вказівок = МісцезнаходженняВказівок { 0, пусто };
вернути код;
}
внутрішня дія покласти_константу_числа(М: *Машина, код: невідома_адреса, значення: р64) -> п32 {
змінна код_як_код = код як *Код;
змінна п: п32 = 0;
поки п < код_як_код.константи.розмір {
змінна константа = код_як_код.константи.дані[п];
якщо константа.вид == ЗЧисло {
якщо константа.дані як р64 == значення {
вернути п;
}
}
п += 1;
}
вернути покласти_константу(М, код, ЧИСЛО(значення));
}
внутрішня дія покласти_константу_тексту(М: *Машина, код: невідома_адреса, значення: кд) -> п32 {
змінна код_як_код = код як *Код;
змінна п: п32 = 0;
поки п < код_як_код.константи.розмір {
змінна константа = код_як_код.константи.дані[п];
якщо константа.вид == ЗПредмет {
змінна предмет_тексту = константа.дані як *Предмет як *ПредметТексту;
якщо предмет_тексту.клас == М.клас_Текст {
якщо перевірити_чи_кд_рівні(предмет_тексту.значення, значення) {
вернути п;
}
}
}
п += 1;
}
змінна предмет_тексту = створити_текст(М, значення);
вернути покласти_константу(М, код, ПРЕДМЕТ(предмет_тексту));
}
внутрішня дія покласти_константу_коду(М: *Машина, код: невідома_адреса, значення: невідома_адреса) -> п32 {
змінна код_як_код = значення як *Код;
змінна значення_як_код = значення як *Код;
змінна константи = створити_послідовність_без_копіювання(М, природне(значення_як_код.константи.розмір), значення_як_код.константи.дані);
змінна вказівки = створити_дані_без_копіювання(М, природне(значення_як_код.вказівки.розмір), значення_як_код.вказівки.дані);
змінна предмет_коду = мавка::створити_код(М, константи, вказівки, значення_як_код.шлях, значення_як_код.місцезнаходження_вказівок);
вернути покласти_константу(М, код, ПРЕДМЕТ(предмет_коду));
}
внутрішня дія покласти_вказівку(М: *Машина, код: невідома_адреса, рядок: п32, вид: п8) -> п32 {
змінна код_як_код = код як *Код;
код_як_код.вказівки.дані = перевиділити<п8>(М, код_як_код.вказівки.дані, природне(код_як_код.вказівки.розмір + 1));
змінна позиція_вказівки = код_як_код.вказівки.розмір;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = вид;
код_як_код.вказівки.розмір += 1;
покласти_місцезнаходження_вказівки(М, код_як_код.місцезнаходження_вказівок::адреса, рядок, позиція_вказівки);
вернути позиція_вказівки;
}
внутрішня дія покласти_вказівку_з_аргументом(М: *Машина, код: невідома_адреса, рядок: п32, вид: п8, аргумент: п32) -> п32 {
змінна код_як_код = код як *Код;
код_як_код.вказівки.дані = перевиділити<п8>(М, код_як_код.вказівки.дані, природне((код_як_код.вказівки.розмір + 1) + 4));
змінна позиція_вказівки = код_як_код.вказівки.розмір;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = вид;
код_як_код.вказівки.розмір += 1;
змінна аргумент_байти = аргумент::адреса як *п8;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_байти[0];
код_як_код.вказівки.розмір += 1;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_байти[1];
код_як_код.вказівки.розмір += 1;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_байти[2];
код_як_код.вказівки.розмір += 1;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_байти[3];
код_як_код.вказівки.розмір += 1;
покласти_місцезнаходження_вказівки(М, код_як_код.місцезнаходження_вказівок::адреса, рядок, позиція_вказівки);
вернути позиція_вказівки;
}
внутрішня дія покласти_вказівку_з_двома_аргументами(М: *Машина, код: невідома_адреса, рядок: п32, вид: п8, аргумент1: п32, аргумент2: п32) -> п32 {
змінна код_як_код = код як *Код;
код_як_код.вказівки.дані = перевиділити<п8>(М, код_як_код.вказівки.дані, природне((код_як_код.вказівки.розмір + 1) + 8));
змінна позиція_вказівки = код_як_код.вказівки.розмір;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = вид;
код_як_код.вказівки.розмір += 1;
змінна аргумент_1_байти = аргумент1::адреса як *п8;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_1_байти[0];
код_як_код.вказівки.розмір += 1;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_1_байти[1];
код_як_код.вказівки.розмір += 1;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_1_байти[2];
код_як_код.вказівки.розмір += 1;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_1_байти[3];
код_як_код.вказівки.розмір += 1;
змінна аргумент_2_байти = аргумент2::адреса як *п8;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_2_байти[0];
код_як_код.вказівки.розмір += 1;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_2_байти[1];
код_як_код.вказівки.розмір += 1;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_2_байти[2];
код_як_код.вказівки.розмір += 1;
код_як_код.вказівки.дані[код_як_код.вказівки.розмір] = аргумент_2_байти[3];
код_як_код.вказівки.розмір += 1;
покласти_місцезнаходження_вказівки(М, код_як_код.місцезнаходження_вказівок::адреса, рядок, позиція_вказівки);
вернути позиція_вказівки;
}
внутрішня дія змінити_аргумент_вказівки(М: *Машина, код: невідома_адреса, позиція_виду_вказівки: п32, позиція_аргумента_вказівки: п32, новий_аргумент: п32) {
змінна код_як_код = код як *Код;
змінна позиція_аргумента_як_байти = позиція_виду_вказівки + 1 + (позиція_аргумента_вказівки * 4);
змінна новий_аргумент_як_байти = новий_аргумент::адреса як *п8;
код_як_код.вказівки.дані[позиція_аргумента_як_байти + 0] = новий_аргумент_як_байти[0];
код_як_код.вказівки.дані[позиція_аргумента_як_байти + 1] = новий_аргумент_як_байти[1];
код_як_код.вказівки.дані[позиція_аргумента_як_байти + 2] = новий_аргумент_як_байти[2];
код_як_код.вказівки.дані[позиція_аргумента_як_байти + 3] = новий_аргумент_як_байти[3];
}
внутрішня дія отримати_розмір_вказівок(М: *Машина, код: невідома_адреса) -> п32 {
змінна код_як_код = код як *Код;
вернути код_як_код.вказівки.розмір;
}
внутрішня дія отримати_шлях_коду(М: *Машина, код: невідома_адреса) -> невідома_адреса {
змінна код_як_код = код як *Код;
вернути код_як_код.шлях;
}
}
дія перекласти_в_код(
М: *Машина,
шлях: *ПредметДаних,
сирий_текст: кд,
знаки: розбирач::Знаки,
сполуки: розбирач::Сполуки,
вихід_коду: **ПредметКоду,
вихід_помилки: *перекладач::ПомилкаПерекладу
) -> логічне {
змінна код: *перекладач_в_код::Код = пусто;
змінна успіх_перекладу = перекладач::перекласти(
М,
шлях,
сирий_текст,
знаки,
сполуки,
перекладач::Дії {
створити_код = перекладач_в_код::створити_код,
покласти_константу_числа = перекладач_в_код::покласти_константу_числа,
покласти_константу_тексту = перекладач_в_код::покласти_константу_тексту,
покласти_константу_коду = перекладач_в_код::покласти_константу_коду,
покласти_вказівку = перекладач_в_код::покласти_вказівку,
покласти_вказівку_з_аргументом = перекладач_в_код::покласти_вказівку_з_аргументом,
покласти_вказівку_з_двома_аргументами = перекладач_в_код::покласти_вказівку_з_двома_аргументами,
змінити_аргумент_вказівки = перекладач_в_код::змінити_аргумент_вказівки,
отримати_розмір_вказівок = перекладач_в_код::отримати_розмір_вказівок,
отримати_шлях_коду = перекладач_в_код::отримати_шлях_коду,
},
код::адреса як *адреса,
вихід_помилки
);
якщо не успіх_перекладу {
вернути успіх_перекладу;
}
змінна константи = створити_послідовність_без_копіювання(М, природне(код.константи.розмір), код.константи.дані);
змінна вказівки = створити_дані_без_копіювання(М, природне(код.вказівки.розмір), код.вказівки.дані);
вихід_коду::вміст = створити_код(М, константи, вказівки, шлях, код.місцезнаходження_вказівок);
вернути так;
}
дія перекласти_у_файл_коду(
М: *Машина,
сирий_текст: кд,
знаки: розбирач::Знаки,
сполуки: розбирач::Сполуки,
вихід_розміру: *природне,
вихід_даних: **п8,
вихід_помилки: *перекладач::ПомилкаПерекладу
) -> логічне {
вернути ні;
}
}