arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/bsl/runtime.bsl

@@ -0,0 +1,858 @@
+// Рантайм L0 для встроенного языка 1С (исполнитель в воротах — OneScript).
+// Тот же контракт, что у runtime.rb: точная десятичная арифметика §58, деньги
+// с валютой, названный режим округления, календарный день, член перечисления.
+//
+// Число — не место для значений дела. У OneScript это .NET decimal (28–29
+// значащих цифр), у платформы — 38 цифр; оба ОКРУГЛЯЮТ МОЛЧА, как только цифр
+// больше (проба OneScript 2.2.0: 1/3 и дробь из 30 знаков режутся без ошибки),
+// громко падает только переполнение целой части. Поэтому значение — длинное
+// целое по основанию 10^7 и масштаб, а Число хранит лишь разряды: произведение
+// двух разрядов с переносом меньше 10^15 и точно у обоих исполнителей.
+//
+// Имена операций контракта — с префиксом op_: pow, round, min, max и date
+// заняты глобальным контекстом, методом класса такое имя быть не может.
+// Регистр в BSL не различается, `И` — ключевое слово: имена ниже подобраны так,
+// чтобы не совпадать ни с ключевыми словами, ни друг с другом без учёта регистра.
+
+Перем БАЗА;
+Перем ПРЕФИКС_ОТКАЗА;
+Перем ВремяПрава;
+Перем POW_MIN;
+Перем POW_MAX;
+Перем Десять;
+Перем Степени;
+Перем ТипСтрока;
+Перем ТипСтруктура;
+Перем ТипЧисло;
+
+// Названный отказ рантайма: то, что срез не считает, а не сбой. Исключение с
+// префиксом; раннер печатает его как JSON с кодом выхода 3, любое другое
+// исключение — крах.
+Процедура Отказ(Текст) Экспорт
+	ВызватьИсключение ПРЕФИКС_ОТКАЗА + Текст;
+КонецПроцедуры
+
+// Текст отказа из описания исключения либо Неопределено, если это не отказ.
+Функция ТекстОтказа(Описание) Экспорт
+	Длина = СтрДлина(ПРЕФИКС_ОТКАЗА);
+	Если Лев(Описание, Длина) = ПРЕФИКС_ОТКАЗА Тогда
+		Возврат Сред(Описание, Длина + 1);
+	КонецЕсли;
+	Возврат Неопределено;
+КонецФункции
+
+// --- целые произвольной длины ------------------------------------------------
+// Структура {Отр, Разр}: Разр — Массив разрядов от младшего; ноль — пустой
+// Разр и Отр = Ложь. Массивы разрядов не изменяются после построения значения.
+
+Функция Обрезать(Разр)
+	Н = Разр.Количество();
+	Пока Н > 0 Цикл
+		Если Разр[Н - 1] <> 0 Тогда
+			Прервать;
+		КонецЕсли;
+		Разр.Удалить(Н - 1);
+		Н = Н - 1;
+	КонецЦикла;
+	Возврат Разр;
+КонецФункции
+
+Функция Целое(Отр, Разр)
+	Обрезать(Разр);
+	Возврат Новый Структура("Отр, Разр", Отр И Разр.Количество() > 0, Разр);
+КонецФункции
+
+Функция Большее(А, Б)
+	Если А > Б Тогда
+		Возврат А;
+	КонецЕсли;
+	Возврат Б;
+КонецФункции
+
+Функция РазрядИли0(Разр, Инд)
+	Если Инд < Разр.Количество() Тогда
+		Возврат Разр[Инд];
+	КонецЕсли;
+	Возврат 0;
+КонецФункции
+
+Функция РазобратьЦелое(Знач Текст)
+	Отр = Лев(Текст, 1) = "-";
+	Цифры = ?(Отр, Сред(Текст, 2), Текст);
+	Длина = СтрДлина(Цифры);
+	Если Длина = 0 Тогда
+		ВызватьИсключение "целое: не десятичная запись: " + Текст;
+	КонецЕсли;
+	Разр = Новый Массив;
+	Кон = Длина;
+	Пока Кон >= 1 Цикл
+		Нач = Большее(1, Кон - 6);
+		Р = 0;
+		Для Поз = Нач По Кон Цикл
+			Код = КодСимвола(Цифры, Поз);
+			Если Код < 48 Или Код > 57 Тогда
+				ВызватьИсключение "целое: не десятичная запись: " + Текст;
+			КонецЕсли;
+			Р = Р * 10 + (Код - 48);
+		КонецЦикла;
+		Разр.Добавить(Р);
+		Кон = Нач - 1;
+	КонецЦикла;
+	Возврат Целое(Отр, Разр);
+КонецФункции
+
+// Малое целое Число (показатели, масштабы) в длинное.
+Функция ИзМалого(Знач Н)
+	Отр = Н < 0;
+	Если Отр Тогда
+		Н = -Н;
+	КонецЕсли;
+	Разр = Новый Массив;
+	Пока Н > 0 Цикл
+		Остаток = Н % БАЗА;
+		Разр.Добавить(Остаток);
+		Н = (Н - Остаток) / БАЗА;
+	КонецЦикла;
+	Возврат Целое(Отр, Разр);
+КонецФункции
+
+// Цифры разряда без Строка() и Формат(): платформа группирует разряды
+// неразрывным пробелом, а Формат(0) без ЧН даёт пустую строку.
+Функция ЦифрыРазряда(Знач Р, Ширина) Экспорт
+	Т = "";
+	Пока Р > 0 Или СтрДлина(Т) < Ширина Цикл
+		Остаток = Р % 10;
+		Т = Символ(48 + Остаток) + Т;
+		Р = (Р - Остаток) / 10;
+	КонецЦикла;
+	Возврат Т;
+КонецФункции
+
+// Разряды печатаются Формат(..., "ЧГ=0") без группировки; ведущие нули
+// внутреннего разряда — через прибавку БАЗА и отбрасывание старшей единицы.
+Функция ЗаписьЦелого(Х) Экспорт
+	Н = Х.Разр.Количество();
+	Если Н = 0 Тогда
+		Возврат "0";
+	КонецЕсли;
+	Т = Формат(Х.Разр[Н - 1], "ЧГ=0");
+	Для Инд = 2 По Н Цикл
+		Т = Т + Сред(Формат(БАЗА + Х.Разр[Н - Инд], "ЧГ=0"), 2);
+	КонецЦикла;
+	Возврат ?(Х.Отр, "-", "") + Т;
+КонецФункции
+
+Функция СравнитьМодули(А, Б)
+	Если А.Количество() <> Б.Количество() Тогда
+		Возврат ?(А.Количество() < Б.Количество(), -1, 1);
+	КонецЕсли;
+	Для Инд = 1 По А.Количество() Цикл
+		К = А.Количество() - Инд;
+		Если А[К] <> Б[К] Тогда
+			Возврат ?(А[К] < Б[К], -1, 1);
+		КонецЕсли;
+	КонецЦикла;
+	Возврат 0;
+КонецФункции
+
+Функция СложитьМодули(А, Б)
+	Рез = Новый Массив;
+	Перенос = 0;
+	Для Инд = 0 По Большее(А.Количество(), Б.Количество()) - 1 Цикл
+		Т = РазрядИли0(А, Инд) + РазрядИли0(Б, Инд) + Перенос;
+		Перенос = ?(Т >= БАЗА, 1, 0);
+		Рез.Добавить(Т - Перенос * БАЗА);
+	КонецЦикла;
+	Если Перенос > 0 Тогда
+		Рез.Добавить(Перенос);
+	КонецЕсли;
+	Возврат Рез;
+КонецФункции
+
+// |А| >= |Б|.
+Функция ВычестьМодули(А, Б)
+	Рез = Новый Массив;
+	Заём = 0;
+	Для Инд = 0 По А.Количество() - 1 Цикл
+		Т = А[Инд] - РазрядИли0(Б, Инд) - Заём;
+		Заём = ?(Т < 0, 1, 0);
+		Рез.Добавить(Т + Заём * БАЗА);
+	КонецЦикла;
+	Возврат Обрезать(Рез);
+КонецФункции
+
+Функция УмножитьМодули(А, Б)
+	Рез = Новый Массив;
+	Если А.Количество() = 0 Или Б.Количество() = 0 Тогда
+		Возврат Рез;
+	КонецЕсли;
+	Для Инд = 1 По А.Количество() + Б.Количество() Цикл
+		Рез.Добавить(0);
+	КонецЦикла;
+	Для Ка = 0 По А.Количество() - 1 Цикл
+		Перенос = 0;
+		Ра = А[Ка];
+		Для Кб = 0 По Б.Количество() - 1 Цикл
+			Т = Рез[Ка + Кб] + Ра * Б[Кб] + Перенос;
+			Рез[Ка + Кб] = Т % БАЗА;
+			Перенос = (Т - Рез[Ка + Кб]) / БАЗА;
+		КонецЦикла;
+		К = Ка + Б.Количество();
+		Пока Перенос > 0 Цикл
+			Т = Рез[К] + Перенос;
+			Рез[К] = Т % БАЗА;
+			Перенос = (Т - Рез[К]) / БАЗА;
+			К = К + 1;
+		КонецЦикла;
+	КонецЦикла;
+	Возврат Обрезать(Рез);
+КонецФункции
+
+// Множитель меньше БАЗА.
+Функция УмножитьНаМалое(А, Множ)
+	Рез = Новый Массив;
+	Перенос = 0;
+	Для Инд = 0 По А.Количество() - 1 Цикл
+		Т = А[Инд] * Множ + Перенос;
+		Рез.Добавить(Т % БАЗА);
+		Перенос = (Т - Рез[Инд]) / БАЗА;
+	КонецЦикла;
+	Пока Перенос > 0 Цикл
+		Остаток = Перенос % БАЗА;
+		Рез.Добавить(Остаток);
+		Перенос = (Перенос - Остаток) / БАЗА;
+	КонецЦикла;
+	Возврат Обрезать(Рез);
+КонецФункции
+
+// Деление модулей в столбик: цифра частного по основанию 10^7 подбирается
+// двоичным поиском; делитель ненулевой. Частное целых — только через остаток:
+// деление Числа с бесконечной дробью округлялось бы молча.
+Функция ДелитьМодули(А, Б)
+	Ч = Новый Массив;
+	Ост = Новый Массив;
+	Если СравнитьМодули(А, Б) < 0 Тогда
+		Для Каждого Р Из А Цикл
+			Ост.Добавить(Р);
+		КонецЦикла;
+		Возврат Новый Структура("Ч, О", Ч, Ост);
+	КонецЕсли;
+	Для Инд = 1 По А.Количество() Цикл
+		Ч.Добавить(0);
+	КонецЦикла;
+	Если Б.Количество() = 1 Тогда
+		// Однозначный делитель: остаток разряда меньше делителя, Т < 10^14.
+		Д = Б[0];
+		Остаток = 0;
+		Для Инд = 1 По А.Количество() Цикл
+			К = А.Количество() - Инд;
+			Т = Остаток * БАЗА + А[К];
+			Остаток = Т % Д;
+			Ч[К] = (Т - Остаток) / Д;
+		КонецЦикла;
+		Если Остаток > 0 Тогда
+			Ост.Добавить(Остаток);
+		КонецЕсли;
+		Возврат Новый Структура("Ч, О", Обрезать(Ч), Ост);
+	КонецЕсли;
+	Для Инд = 1 По А.Количество() Цикл
+		К = А.Количество() - Инд;
+		Ост.Вставить(0, А[К]);
+		Обрезать(Ост);
+		Низ = 0;
+		Верх = БАЗА - 1;
+		Пока Низ < Верх Цикл
+			Сер = Низ + Верх + 1;
+			Сер = (Сер - Сер % 2) / 2;
+			Если СравнитьМодули(УмножитьНаМалое(Б, Сер), Ост) <= 0 Тогда
+				Низ = Сер;
+			Иначе
+				Верх = Сер - 1;
+			КонецЕсли;
+		КонецЦикла;
+		Если Низ > 0 Тогда
+			Ост = ВычестьМодули(Ост, УмножитьНаМалое(Б, Низ));
+		КонецЕсли;
+		Ч[К] = Низ;
+	КонецЦикла;
+	Возврат Новый Структура("Ч, О", Обрезать(Ч), Ост);
+КонецФункции
+
+Функция ЦелСложить(Х, У)
+	Если Х.Отр = У.Отр Тогда
+		Возврат Целое(Х.Отр, СложитьМодули(Х.Разр, У.Разр));
+	КонецЕсли;
+	С = СравнитьМодули(Х.Разр, У.Разр);
+	Если С = 0 Тогда
+		Возврат Целое(Ложь, Новый Массив);
+	ИначеЕсли С > 0 Тогда
+		Возврат Целое(Х.Отр, ВычестьМодули(Х.Разр, У.Разр));
+	КонецЕсли;
+	Возврат Целое(У.Отр, ВычестьМодули(У.Разр, Х.Разр));
+КонецФункции
+
+Функция ЦелПротивоположное(Х)
+	Возврат Целое(Не Х.Отр, Х.Разр);
+КонецФункции
+
+Функция ЦелВычесть(Х, У)
+	Возврат ЦелСложить(Х, ЦелПротивоположное(У));
+КонецФункции
+
+Функция ЦелУмножить(Х, У)
+	Возврат Целое(Х.Отр <> У.Отр, УмножитьМодули(Х.Разр, У.Разр));
+КонецФункции
+
+Функция ЦелНоль(Х)
+	Возврат Х.Разр.Количество() = 0;
+КонецФункции
+
+Функция ЦелСравнить(Х, У)
+	Если Х.Отр <> У.Отр Тогда
+		Возврат ?(Х.Отр, -1, 1);
+	КонецЕсли;
+	С = СравнитьМодули(Х.Разр, У.Разр);
+	Возврат ?(Х.Отр, -С, С);
+КонецФункции
+
+Функция ЦелМодуль(Х)
+	Возврат Целое(Ложь, Х.Разр);
+КонецФункции
+
+// Частное и остаток с усечением к нулю: знак остатка — знак делимого.
+Функция ЦелДелить(Х, У)
+	ЧО = ДелитьМодули(Х.Разр, У.Разр);
+	Возврат Новый Структура("Ч, О", Целое(Х.Отр <> У.Отр, ЧО.Ч), Целое(Х.Отр, ЧО.О));
+КонецФункции
+
+// Степени десяти кэшируются: значения не изменяются после построения, поэтому
+// одно значение безопасно делится между вызовами.
+Функция Степень10(К)
+	Пока Степени.Количество() <= К Цикл
+		Степени.Добавить(Целое(Ложь, УмножитьНаМалое(Степени[Степени.Количество() - 1].Разр, 10)));
+	КонецЦикла;
+	Возврат Степени[К];
+КонецФункции
+
+Функция ЦелНОД(Х, У)
+	А = ЦелМодуль(Х);
+	Б = ЦелМодуль(У);
+	Пока Не ЦелНоль(Б) Цикл
+		Остаток = ЦелДелить(А, Б).О;
+		А = Б;
+		Б = Остаток;
+	КонецЦикла;
+	Возврат А;
+КонецФункции
+
+// Малое Число: вызывающий обязан сперва проверить диапазон.
+Функция ВМалое(Х)
+	Н = 0;
+	Для Инд = 1 По Х.Разр.Количество() Цикл
+		Н = Н * БАЗА + Х.Разр[Х.Разр.Количество() - Инд];
+	КонецЦикла;
+	Возврат ?(Х.Отр, -Н, Н);
+КонецФункции
+
+// --- значения ----------------------------------------------------------------
+// Decimal {Вид="dec", Ц, Масштаб}, Money {Вид="money", Ц, Масштаб, Вал};
+// календарный день §2.15 в канонической записи ISO — {Вид="date", Зн}: порядок
+// записи и есть порядок дня; член перечисления §38 или ссылка без объявления —
+// {Вид="sym", Ид}. Text и сущность — Строка.
+
+Функция ЗначДес(Ц, Масштаб)
+	Возврат Новый Структура("Вид, Ц, Масштаб", "dec", Ц, Масштаб);
+КонецФункции
+
+Функция ЗначДеньги(Ц, Масштаб, Вал)
+	Возврат Новый Структура("Вид, Ц, Масштаб, Вал", "money", Ц, Масштаб, Вал);
+КонецФункции
+
+Функция ВидЗнач(З) Экспорт
+	ТЗ = ТипЗнч(З);
+	Если ТЗ = ТипСтруктура Тогда
+		Возврат З.Вид;
+	ИначеЕсли ТЗ = ТипСтрока Тогда
+		Возврат "text";
+	КонецЕсли;
+	Возврат "other";
+КонецФункции
+
+Функция ЧисловойВид(З)
+	В = ВидЗнач(З);
+	Возврат В = "dec" Или В = "money";
+КонецФункции
+
+Функция ЭтоДеньги(З)
+	Возврат ВидЗнач(З) = "money";
+КонецФункции
+
+Функция op_dec(Лит) Экспорт
+	Поз = СтрНайти(Лит, ".");
+	Если Поз = 0 Тогда
+		ЦелЧасть = Лит;
+		Дробь = "";
+	Иначе
+		ЦелЧасть = Лев(Лит, Поз - 1);
+		Дробь = Сред(Лит, Поз + 1);
+	КонецЕсли;
+	Отр = Лев(ЦелЧасть, 1) = "-";
+	Цифры = ?(Отр, Сред(ЦелЧасть, 2), ЦелЧасть) + Дробь;
+	Возврат ЗначДес(РазобратьЦелое(?(Отр, "-", "") + Цифры), СтрДлина(Дробь));
+КонецФункции
+
+Функция op_money(Лит, Вал) Экспорт
+	Д = op_dec(Лит);
+	Возврат ЗначДеньги(Д.Ц, Д.Масштаб, Вал);
+КонецФункции
+
+Функция op_date(Лит) Экспорт
+	Возврат Новый Структура("Вид, Зн", "date", Лит);
+КонецФункции
+
+Функция op_sym(Ид) Экспорт
+	Возврат Новый Структура("Вид, Ид", "sym", Ид);
+КонецФункции
+
+// §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+Процедура Одинаковые(А, Б, Оп)
+	Если Не (ЧисловойВид(А) И ЧисловойВид(Б) И ЭтоДеньги(А) = ЭтоДеньги(Б)) Тогда
+		Отказ("§58: виды операндов не совпадают: " + Оп);
+	КонецЕсли;
+	Если ЭтоДеньги(А) Тогда
+		Если А.Вал <> Б.Вал Тогда
+			Отказ("§58: разные валюты: " + Оп);
+		КонецЕсли;
+	КонецЕсли;
+КонецПроцедуры
+
+Функция Пара(А, Б)
+	Если А.Масштаб = Б.Масштаб Тогда
+		Возврат Новый Структура("Х, У, Масштаб", А.Ц, Б.Ц, А.Масштаб);
+	КонецЕсли;
+	С = Большее(А.Масштаб, Б.Масштаб);
+	Возврат Новый Структура("Х, У, Масштаб",
+		ЦелУмножить(А.Ц, Степень10(С - А.Масштаб)), ЦелУмножить(Б.Ц, Степень10(С - Б.Масштаб)), С);
+КонецФункции
+
+Функция Сделать(Ц, Масштаб, Образец)
+	Если ЭтоДеньги(Образец) Тогда
+		Возврат ЗначДеньги(Ц, Масштаб, Образец.Вал);
+	КонецЕсли;
+	Возврат ЗначДес(Ц, Масштаб);
+КонецФункции
+
+// Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+Функция Целочисленное(З)
+	Если ВидЗнач(З) <> "dec" Тогда
+		Возврат Ложь;
+	КонецЕсли;
+	Возврат ЦелНоль(ЦелДелить(З.Ц, Степень10(З.Масштаб)).О);
+КонецФункции
+
+Функция ВЦелое(З)
+	Возврат ЦелДелить(З.Ц, Степень10(З.Масштаб)).Ч;
+КонецФункции
+
+Функция op_add(А, Б) Экспорт
+	Одинаковые(А, Б, "add");
+	П = Пара(А, Б);
+	Возврат Сделать(ЦелСложить(П.Х, П.У), П.Масштаб, А);
+КонецФункции
+
+Функция op_sub(А, Б) Экспорт
+	Одинаковые(А, Б, "sub");
+	П = Пара(А, Б);
+	Возврат Сделать(ЦелВычесть(П.Х, П.У), П.Масштаб, А);
+КонецФункции
+
+// Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+// сумма масштабов. Два размерных не перемножаются.
+Функция op_mul(А, Б) Экспорт
+	Если Не (ЧисловойВид(А) И ЧисловойВид(Б)) Тогда
+		Отказ("§58: виды операндов не совпадают: mul");
+	КонецЕсли;
+	Если ЭтоДеньги(А) И ЭтоДеньги(Б) Тогда
+		Отказ("§58: произведение двух размерных величин не определено");
+	КонецЕсли;
+	Возврат Сделать(ЦелУмножить(А.Ц, Б.Ц), А.Масштаб + Б.Масштаб, ?(ЭтоДеньги(А), А, Б));
+КонецФункции
+
+// Точное десятичное частное Числ/Знам при 10-гладком знаменателе (§18), иначе
+// Неопределено; иначе структура {Ц, Масштаб}.
+Функция Точное(Знач Числ, Знач Знам)
+	Н = ЦелНОД(Числ, Знам);
+	Если ЦелНоль(Н) Тогда
+		Н = ИзМалого(1);
+	КонецЕсли;
+	Числ = ЦелДелить(Числ, Н).Ч;
+	Знам = ЦелДелить(Знам, Н).Ч;
+	Если Знам.Отр Тогда
+		Числ = ЦелПротивоположное(Числ);
+		Знам = ЦелПротивоположное(Знам);
+	КонецЕсли;
+	Двоек = 0;
+	Пятёрок = 0;
+	Пока Истина Цикл
+		ЧО = ЦелДелить(Знам, ИзМалого(2));
+		Если Не ЦелНоль(ЧО.О) Тогда
+			Прервать;
+		КонецЕсли;
+		Знам = ЧО.Ч;
+		Двоек = Двоек + 1;
+	КонецЦикла;
+	Пока Истина Цикл
+		ЧО = ЦелДелить(Знам, ИзМалого(5));
+		Если Не ЦелНоль(ЧО.О) Тогда
+			Прервать;
+		КонецЕсли;
+		Знам = ЧО.Ч;
+		Пятёрок = Пятёрок + 1;
+	КонецЦикла;
+	Если ЦелСравнить(Знам, ИзМалого(1)) <> 0 Тогда
+		Возврат Неопределено;
+	КонецЕсли;
+	К = Большее(Двоек, Пятёрок);
+	Множ = ИзМалого(1);
+	Для Шаг = 1 По К - Двоек Цикл
+		Множ = ЦелУмножить(Множ, ИзМалого(2));
+	КонецЦикла;
+	Для Шаг = 1 По К - Пятёрок Цикл
+		Множ = ЦелУмножить(Множ, ИзМалого(5));
+	КонецЦикла;
+	Возврат Новый Структура("Ц, Масштаб", ЦелУмножить(Числ, Множ), К);
+КонецФункции
+
+// Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+// валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+Функция op_div(А, Б) Экспорт
+	Если Не (ЧисловойВид(А) И ЧисловойВид(Б)) Тогда
+		Отказ("§58: деление вне таблицы делимых");
+	КонецЕсли;
+	Если ЦелНоль(Б.Ц) Тогда
+		Отказ("деление на ноль — evaluation error (§58)");
+	КонецЕсли;
+	Образец = Неопределено;
+	Если ЭтоДеньги(А) И ЭтоДеньги(Б) Тогда
+		Если А.Вал <> Б.Вал Тогда
+			Отказ("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте");
+		КонецЕсли;
+	ИначеЕсли ЭтоДеньги(А) Тогда
+		Образец = А;
+	ИначеЕсли ЭтоДеньги(Б) Тогда
+		Отказ("§58: деление вне таблицы делимых");
+	КонецЕсли;
+	Ч = Точное(ЦелУмножить(А.Ц, Степень10(Б.Масштаб)), ЦелУмножить(Б.Ц, Степень10(А.Масштаб)));
+	Если Ч = Неопределено Тогда
+		Если Образец <> Неопределено Тогда
+			Отказ("INEXACT_DIVISION: округление только явной политикой (§50/§18)");
+		КонецЕсли;
+		Отказ("§58: частное не 10-гладкое — Rational вне среза");
+	КонецЕсли;
+	Если Образец = Неопределено Тогда
+		Возврат ЗначДес(Ч.Ц, Ч.Масштаб);
+	КонецЕсли;
+	Возврат ЗначДеньги(Ч.Ц, Ч.Масштаб, Образец.Вал);
+КонецФункции
+
+// Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов. Оператор `%`
+// Числа усекает к нулю (-7 % 3 = -1) и здесь не годится.
+Функция op_mod(А, Б) Экспорт
+	Если Не (Целочисленное(А) И Целочисленное(Б)) Тогда
+		Отказ("§58: mod определён только для Integer");
+	КонецЕсли;
+	У = ВЦелое(Б);
+	Если ЦелНоль(У) Тогда
+		Отказ("остаток от деления на ноль — evaluation error (§58)");
+	КонецЕсли;
+	Модуль = ЦелМодуль(У);
+	Остаток = ЦелДелить(ВЦелое(А), Модуль).О;
+	Если Остаток.Отр Тогда
+		Остаток = ЦелСложить(Остаток, Модуль);
+	КонецЕсли;
+	Возврат ЗначДес(Остаток, 0);
+КонецФункции
+
+Функция op_min(А, Б) Экспорт
+	Одинаковые(А, Б, "min");
+	П = Пара(А, Б);
+	Возврат ?(ЦелСравнить(П.Х, П.У) <= 0, А, Б);
+КонецФункции
+
+Функция op_max(А, Б) Экспорт
+	Одинаковые(А, Б, "max");
+	П = Пара(А, Б);
+	Возврат ?(ЦелСравнить(П.Х, П.У) >= 0, А, Б);
+КонецФункции
+
+Функция op_abs(З) Экспорт
+	Если Не ЧисловойВид(З) Тогда
+		Отказ("§58: abs — не числовой вид");
+	КонецЕсли;
+	Возврат Сделать(ЦелМодуль(З.Ц), З.Масштаб, З);
+КонецФункции
+
+// §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+// вычисление, диапазон — часть контракта. Умножение останавливается, как только
+// модуль превысил 2^63: при |основание| >= 1 он дальше не убывает, а при нулевом
+// основании не растёт, — исход тот же, что у полного вычисления.
+Функция op_pow(Осн, Пок) Экспорт
+	Если Не (Целочисленное(Осн) И Целочисленное(Пок)) Тогда
+		Отказ("§58: pow определён только для Integer");
+	КонецЕсли;
+	Е = ВЦелое(Пок);
+	Если Е.Отр Тогда
+		Отказ("§58: pow — показатель отрицателен");
+	КонецЕсли;
+	Если ЦелСравнить(Е, ИзМалого(4096)) > 0 Тогда
+		Отказ("RESOURCE_LIMIT: pow — показатель превышает 4096");
+	КонецЕсли;
+	Б = ВЦелое(Осн);
+	Р = ИзМалого(1);
+	Граница = ЦелМодуль(POW_MIN);
+	Для Шаг = 1 По ВМалое(Е) Цикл
+		Р = ЦелУмножить(Р, Б);
+		Если ЦелСравнить(ЦелМодуль(Р), Граница) > 0 Тогда
+			Прервать;
+		КонецЕсли;
+	КонецЦикла;
+	Если ЦелСравнить(Р, POW_MIN) < 0 Или ЦелСравнить(Р, POW_MAX) > 0 Тогда
+		Отказ("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона");
+	КонецЕсли;
+	Возврат ЗначДес(Р, 0);
+КонецФункции
+
+Функция op_round(З, Разрядов, Режим) Экспорт
+	Если Режим <> "HALF_UP" Тогда
+		Отказ("§50: режим округления не реализован: " + Режим);
+	КонецЕсли;
+	Если Не ЧисловойВид(З) Тогда
+		Отказ("§50: round — не числовой вид");
+	КонецЕсли;
+	Если ТипЗнч(Разрядов) = ТипЧисло Тогда
+		Н = Разрядов;
+	Иначе
+		Н = ВМалое(ВЦелое(Разрядов));
+	КонецЕсли;
+	Если З.Масштаб <= Н Тогда
+		Возврат Сделать(ЦелУмножить(З.Ц, Степень10(Н - З.Масштаб)), Н, З);
+	КонецЕсли;
+	Сброс = Степень10(З.Масштаб - Н);
+	ЧО = ЦелДелить(ЦелМодуль(З.Ц), Сброс);
+	Вверх = ЧО.Ч;
+	Если ЦелСравнить(ЦелСложить(ЧО.О, ЧО.О), Сброс) >= 0 Тогда
+		Вверх = ЦелСложить(Вверх, ИзМалого(1)); // HALF_UP — от нуля
+	КонецЕсли;
+	Если З.Ц.Отр Тогда
+		Вверх = ЦелПротивоположное(Вверх);
+	КонецЕсли;
+	Возврат Сделать(Вверх, Н, З);
+КонецФункции
+
+// Порядок строк по кодам символов. Встроенное `<` над Строкой не обещает
+// порядкового сравнения у обоих исполнителей; окна §31 сравниваются этим.
+Функция ПорядокТекста(А, Б) Экспорт
+	ДА = СтрДлина(А);
+	ДБ = СтрДлина(Б);
+	Для Поз = 1 По ?(ДА < ДБ, ДА, ДБ) Цикл
+		КА = КодСимвола(А, Поз);
+		КБ = КодСимвола(Б, Поз);
+		Если КА <> КБ Тогда
+			Возврат ?(КА < КБ, -1, 1);
+		КонецЕсли;
+	КонецЦикла;
+	Возврат ?(ДА < ДБ, -1, ?(ДА > ДБ, 1, 0));
+КонецФункции
+
+// Булево по результату сравнения либо Неопределено для незнакомой операции.
+Функция ПоПорядку(С, Оп)
+	Если Оп = "lt" Тогда
+		Возврат С < 0;
+	ИначеЕсли Оп = "le" Тогда
+		Возврат С <= 0;
+	ИначеЕсли Оп = "gt" Тогда
+		Возврат С > 0;
+	ИначеЕсли Оп = "ge" Тогда
+		Возврат С >= 0;
+	ИначеЕсли Оп = "eq" Тогда
+		Возврат С = 0;
+	ИначеЕсли Оп = "ne" Тогда
+		Возврат С <> 0;
+	КонецЕсли;
+	Возврат Неопределено;
+КонецФункции
+
+Функция РавныеСимволы(А, Б)
+	Если ВидЗнач(А) <> "sym" Или ВидЗнач(Б) <> "sym" Тогда
+		Возврат Ложь;
+	КонецЕсли;
+	Возврат А.Ид = Б.Ид;
+КонецФункции
+
+Функция РавныеДаты(А, Б)
+	Если ВидЗнач(А) <> "date" Или ВидЗнач(Б) <> "date" Тогда
+		Возврат Ложь;
+	КонецЕсли;
+	Возврат А.Зн = Б.Зн;
+КонецФункции
+
+// Строки сравниваются только строками: `=` у Строки и Структуры — Ложь, но
+// явная проверка вида не зависит от того, как исполнитель сравнивает типы.
+Функция РавныеТексты(А, Б)
+	Если ВидЗнач(А) <> "text" Или ВидЗнач(Б) <> "text" Тогда
+		Возврат Ложь;
+	КонецЕсли;
+	Возврат А = Б;
+КонецФункции
+
+Функция op_cmp(А, Оп, Б) Экспорт
+	// Быстрый путь соединений правил: две сущности или два текста.
+	Если ТипЗнч(А) = ТипСтрока И ТипЗнч(Б) = ТипСтрока Тогда
+		Если Оп = "eq" Тогда
+			Возврат А = Б;
+		ИначеЕсли Оп = "ne" Тогда
+			Возврат А <> Б;
+		КонецЕсли;
+		Отказ("порядок на Text вне среза рантайма: " + Оп);
+	КонецЕсли;
+	ВА = ВидЗнач(А);
+	ВБ = ВидЗнач(Б);
+	Если ВА = "sym" Или ВБ = "sym" Тогда
+		Тот = РавныеСимволы(А, Б);
+		Если Оп = "eq" Тогда
+			Возврат Тот;
+		ИначеЕсли Оп = "ne" Тогда
+			Возврат Не Тот;
+		КонецЕсли;
+		Отказ("§57: вид enum не упорядочен");
+	КонецЕсли;
+	Если ВА = "date" Или ВБ = "date" Тогда
+		Если ВА = "date" И ВБ = "date" Тогда
+			Р = ПоПорядку(ПорядокТекста(А.Зн, Б.Зн), Оп);
+			Если Р = Неопределено Тогда
+				Отказ("сравнение вне среза рантайма: " + Оп);
+			КонецЕсли;
+			Возврат Р;
+		КонецЕсли;
+		Если Оп = "eq" Тогда
+			Возврат Ложь;
+		ИначеЕсли Оп = "ne" Тогда
+			Возврат Истина;
+		КонецЕсли;
+		Отказ("§57: Date сравнивается только с Date");
+	КонецЕсли;
+	Если ВА = "text" Или ВБ = "text" Тогда
+		Тот = РавныеТексты(А, Б);
+		Если Оп = "eq" Тогда
+			Возврат Тот;
+		ИначеЕсли Оп = "ne" Тогда
+			Возврат Не Тот;
+		КонецЕсли;
+		Отказ("порядок на Text вне среза рантайма: " + Оп);
+	КонецЕсли;
+	Если ЭтоДеньги(А) <> ЭтоДеньги(Б) Тогда
+		Отказ("§49: сравнение денег с безразмерным");
+	КонецЕсли;
+	Если ЭтоДеньги(А) Тогда
+		Если А.Вал <> Б.Вал Тогда
+			Отказ("§49: разные валюты");
+		КонецЕсли;
+	КонецЕсли;
+	П = Пара(А, Б);
+	Р = ПоПорядку(ЦелСравнить(П.Х, П.У), Оп);
+	Если Р = Неопределено Тогда
+		Отказ("сравнение вне среза рантайма: " + Оп);
+	КонецЕсли;
+	Возврат Р;
+КонецФункции
+
+Функция op_eq(А, Б) Экспорт
+	Если ТипЗнч(А) = ТипСтрока И ТипЗнч(Б) = ТипСтрока Тогда
+		Возврат А = Б;
+	КонецЕсли;
+	ВА = ВидЗнач(А);
+	ВБ = ВидЗнач(Б);
+	Если ВА = "sym" Или ВБ = "sym" Тогда
+		Возврат РавныеСимволы(А, Б);
+	ИначеЕсли ВА = "date" Или ВБ = "date" Тогда
+		Возврат РавныеДаты(А, Б);
+	ИначеЕсли ВА = "text" Или ВБ = "text" Тогда
+		Возврат РавныеТексты(А, Б);
+	ИначеЕсли ЭтоДеньги(А) <> ЭтоДеньги(Б) Тогда
+		Возврат Ложь;
+	ИначеЕсли ЭтоДеньги(А) Тогда
+		Если А.Вал <> Б.Вал Тогда
+			Возврат Ложь;
+		КонецЕсли;
+	КонецЕсли;
+	П = Пара(А, Б);
+	Возврат ЦелСравнить(П.Х, П.У) = 0;
+КонецФункции
+
+// Запись без хвостовых нулей дробной части: отбрасываются цифры записи, а не
+// делится длинное целое, — ноль любого масштаба даёт «0e-0».
+Функция Норм(З)
+	Цифры = ЗаписьЦелого(З.Ц);
+	Масштаб = З.Масштаб;
+	Если ЦелНоль(З.Ц) Тогда
+		Масштаб = 0;
+	КонецЕсли;
+	Пока Масштаб > 0 Цикл
+		Если Прав(Цифры, 1) <> "0" Тогда
+			Прервать;
+		КонецЕсли;
+		Цифры = Лев(Цифры, СтрДлина(Цифры) - 1);
+		Масштаб = Масштаб - 1;
+	КонецЦикла;
+	Возврат Цифры + "e-" + Формат(Масштаб, "ЧГ=0; ЧН=0");
+КонецФункции
+
+// Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+// ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+Функция Экран(Т)
+	Возврат СтрЗаменить(СтрЗаменить(Т, "\", "\\"), "|", "\|");
+КонецФункции
+
+Функция op_key(Ряд) Экспорт
+	Ключ = "";
+	Для Инд = 0 По Ряд.Количество() - 1 Цикл
+		З = Ряд[Инд];
+		В = ВидЗнач(З);
+		Если В = "text" Тогда
+			Часть = "e:" + Экран(З);
+		ИначеЕсли В = "date" Тогда
+			Часть = "t:" + З.Зн;
+		ИначеЕсли В = "sym" Тогда
+			Часть = "c:" + Экран(З.Ид);
+		ИначеЕсли В = "money" Тогда
+			Часть = "m:" + З.Вал + ":" + Норм(З);
+		Иначе
+			Часть = "d:" + Норм(З);
+		КонецЕсли;
+		Ключ = ?(Инд = 0, Часть, Ключ + "|" + Часть);
+	КонецЦикла;
+	Возврат Ключ;
+КонецФункции
+
+Процедура op_setLegalTime(Т) Экспорт
+	ВремяПрава = Т;
+КонецПроцедуры
+
+Функция op_legalTime() Экспорт
+	Если ВремяПрава = "" Тогда
+		Отказ("legalTime не подан делом");
+	КонецЕсли;
+	Возврат ВремяПрава;
+КонецФункции
+
+БАЗА = 10000000;
+ТипСтрока = Тип("Строка");
+ТипСтруктура = Тип("Структура");
+ТипЧисло = Тип("Число");
+Степени = Новый Массив;
+Степени.Добавить(Целое(Ложь, ИзМалого(1).Разр));
+ПРЕФИКС_ОТКАЗА = "law-refused|";
+ВремяПрава = "";
+POW_MIN = РазобратьЦелое("-9223372036854775808");
+POW_MAX = РазобратьЦелое("9223372036854775807");
+Десять = ИзМалого(10);