SVI Исправления

README.md

@@ -21,9 +21,8 @@
 		- [6.1 Встроенные линейные типы](#61-встроенные-линейные-типы)
 		- [6.2 Встроенные векторные типы](#62-встроенные-векторные-типы)
 		- [6.3 Структура](#63-структура)
-		- [6.4 Структуры и ссылки](#64-структуры-и-ссылки)
-		- [6.5 Тип функции](#65-тип-функции)
-	- [7. Объявление переменных](#7-объявление-переменных)
+	- [6.4 Тип функции](#64-тип-функции)
+	- [7. Объявление объектов](#7-объявление-объектов)
 	- [8. Выражения](#8-выражения)
 		- [8.1 Операнды](#81-операнды)
 		- [8.2 Операторы](#82-операторы)
@@ -35,7 +34,7 @@
 		- [9.3 Последовательность предписаний](#93-последовательность-предписаний)
 		- [9.4 Предписание\_ЕСЛИ](#94-предписание_если)
 		- [9.5 Предписание\_ВЫБОР](#95-предписание_выбор)
-		- [9.6 Предписание ПОКА](#96-предписание-пока)
+		- [9.6 Предписание пока](#96-предписание-пока)
 		- [9.7 Предписание ДЛЯ](#97-предписание-для)
 	- [10.  Объявление функций](#10--объявление-функций)
 		- [10.1 Формальные параметры](#101-формальные-параметры)
@@ -46,7 +45,7 @@
 
 ## 0. Введение
 
-Идея создания языка **Оберон-У** (далее просто **Оберон**) родилась после переосмысления идей несоответствия современного ИТ и средств разработки. [Никлаус Вирт](https://ru.wikipedia.org/wiki/Вирт,_Никлаус) продвинулся в этом отношении дальше всех. И львиная доля идей в концепции **Оберон** является либо трансляцией этих идей, либо творческой компиляции их.
+Идея создания языка **Оберон-У** (далее просто **Оберон**) родилась после переосмысления идей несоответствия современного ИТ и средств разработки. [Никлаус Вирт](https://ru.wikipedia.org/wiki/Вирт,_Никлаус) продвинулся в этом отношении дальше всех. и львиная доля идей в концепции **Оберон** является либо трансляцией этих идей, либо творческой компиляции их.
 
 **Оберон-У** — язык программирования общего назначения, который является развитием **Модулы-2** и модификацией **Оберон-7**.
 
@@ -211,74 +210,74 @@ flowchart TD
 
 Ниже перечислен полный список `ключевых символов`
 
-| Символ   | Комментарий                                          |
-| -------- | ---------------------------------------------------- |
-| +        | Сложение                                             |
-| ++       | Инкремент операнда                                   |
-| +=       | Сложение операндов с присвоением операнду слева      |
-| =        | Присвоение                                           |
-| -        | Минус                                                |
-| --       | Декремент                                            |
-| -=       | Вычитание операндов, с присвоением операнду слева    |
-| ^        | Исключающее ИЛИ                                      |
-| ^=       | Исключающее ИЛИ с присвоением операнды слева         |
-| *        | Умножение                                            |
-| **       | Возведение в степень                                 |
-| **=      | Возведение в степень с присвоением операнда слева    |
-| /        | Деление                                              |
-| /=       | Деление с присвоением операнду слева                 |
-| <        | Меньше                                               |
-| >        | Больше                                               |
-| =        | Присвоить                                            |
-| //       | Линейный комментарий                                 |
-| /*       | Начало многострочного комментария                    |
-| */       | Конец многострочного комментария                     |
-| (*       | Начало многострочного комментария                    |
-| *)       | Конец многострочного комментария                     |
-| .        | Точка                                                |
-| <=       | Меньше или равно                                     |
-| ,        | Запятая                                              |
-| >=       | Больше или равно                                     |
-| ;        | Разделитель выражений                                |
-| ..       | Перечисление                                         |
-| :        | Определить тип переменной                            |
-| (        | Открывающая круглая скобка (выражение)               |
-| )        | Закрывающая круглая скобка (выражение)               |
-| [        | Открывающая квадратная скобка (массив)               |
-| ]        | Закрывающая квадратная скобка (массив)               |
-| {        | Фигурная открывающая скобка (область видимости)      |
-| }        | Закрывающая фигурная скобка (область видимости)      |
-| модуль   | MODULE Объявление начала модуля                      |
-| импорт   | IMPORT Импорт модуля                                 |
-| конст    | CONST Объявление константы                           |
-| тип      | TYPE Объявление типа                                 |
-| структ   | STRUCT Объявление структуры                          |
-| сущ      | VAR Объявление переменной                            |
-| фн       | FN Объявление функции                                |
-| &        | Создание объекта                                     |
-| есть     | IS Проверка типа                                     |
-| бул      | BOOL Белвый тип                                      |
-| ДА       | TRUE Булево значение                                 |
-| НЕТ      | FALSE Отрицание логического значения                 |
-| БАЙТ     | BYTE Тип байт                                        |
-| ЦЕЛОЕ    | INT Дробное число                                    |
-| ВЕЩ      | REAL Дробное число                                   |
-| МАССИВ   | ARRAY Массив элементов                               |
-| ПРОВЕР   | SWITCH Проверка на выбор                             |
-| МУТ      | MUT Признак изменяемости                             |
-| ВЕРНУТЬ  | RETURN Возврат из функции                            |
-| НОВ      | NEW Создать новую переменную                         |
-| ЕСЛИ     | IF Начало условия                                    |
-| АЕСЛИ    | IF Альтернативноее, если предыдущее не сработало     |
-| МОД      | MOD Модуль от целочисленного деления                 |
-| ДИВ      | DIV Остаток от целочисленного деления                |
-| НИЧ      | NIL Пустое состояние объекта                         |
-| ПОКА     | WHILE Условие проверки продолжения цикла на входе    |
-| ДАЛЬШЕ   | NEXT Продолжить цикл с пропуском следующих выражений |
-| ПРЕРВАТЬ | BREAK Прервать цикл с пропуском следующих выражений  |
-| ИЛИ      | OR Логическое ИЛИ                                    |
-| И        | AND Логическое И                                     |
-| НЕ       | NOT Логическая инверсия                              |
+| Символ  | Комментарий                                          |
+| ------- | ---------------------------------------------------- |
+| +       | Сложение                                             |
+| ++      | Инкремент операнда                                   |
+| +=      | Сложение операндов с присвоением операнду слева      |
+| =       | Присвоение                                           |
+| -       | Минус                                                |
+| --      | Декремент                                            |
+| -=      | Вычитание операндов, с присвоением операнду слева    |
+| ^       | Исключающее или                                      |
+| ^=      | Исключающее или с присвоением операнды слева         |
+| *       | Умножение                                            |
+| **      | Возведение в степень                                 |
+| **=     | Возведение в степень с присвоением операнда слева    |
+| /       | Деление                                              |
+| /=      | Деление с присвоением операнду слева                 |
+| <       | Меньше                                               |
+| >       | Больше                                               |
+| =       | Присвоить                                            |
+| //      | Линейный комментарий                                 |
+| /*      | Начало многострочного комментария                    |
+| */      | Конец многострочного комментария                     |
+| (*      | Начало многострочного комментария                    |
+| *)      | Конец многострочного комментария                     |
+| .       | Точка                                                |
+| <=      | Меньше или равно                                     |
+| ,       | Запятая                                              |
+| >=      | Больше или равно                                     |
+| ;       | Разделитель выражений                                |
+| ..      | Перечисление                                         |
+| :       | Определить тип переменной                            |
+| (       | Открывающая круглая скобка (выражение)               |
+| )       | Закрывающая круглая скобка (выражение)               |
+| [       | Открывающая квадратная скобка (массив)               |
+| ]       | Закрывающая квадратная скобка (массив)               |
+| {       | Фигурная открывающая скобка (область видимости)      |
+| }       | Закрывающая фигурная скобка (область видимости)      |
+| модуль  | MODULE Объявление начала модуля                      |
+| импорт  | IMPORT Импорт модуля                                 |
+| конст   | CONST Объявление константы                           |
+| тип     | TYPE Объявление типа                                 |
+| структ  | STRUCT Объявление структуры                          |
+| сущ     | VAR Объявление переменной                            |
+| фн      | FN Объявление функции                                |
+| &       | & Создание объекта                                   |
+| есть    | IS Проверка типа                                     |
+| бул     | BOOL Белвый тип                                      |
+| да      | TRUE Булево значение                                 |
+| нет     | FALSE Отрицание логического значения                 |
+| байт    | BYTE Тип байт                                        |
+| целое   | INT Дробное число                                    |
+| вещ     | REAL Дробное число                                   |
+| массив  | ARRAY Массив элементов                               |
+| провер  | SWITCH Проверка на выбор                             |
+| мут     | MUT Признак изменяемости                             |
+| пуб     | PUB Признак экспорта                                 |
+| вернуть | RETURN Возврат из функции                            |
+| если    | IF Начало условия                                    |
+| аесли   | IF Альтернативноее, если предыдущее не сработало     |
+| мод     | MOD Модуль от целочисленного деления                 |
+| див     | DIV Остаток от целочисленного деления                |
+| нич     | NIL Пустое состояние объекта                         |
+| пока    | WHILE Условие проверки продолжения цикла на входе    |
+| дальше  | NEXT Продолжить цикл с пропуском следующих выражений |
+| стоп    | BREAK Прервать цикл с пропуском следующих выражений  |
+| или     | OR Логическое или                                    |
+| и       | AND Логическое и                                     |
+| не      | NOT Логическая инверсия                              |
 
 ## 4. Объявления имён и область видимости
 
@@ -288,51 +287,56 @@ flowchart TD
 
 `Имя`, объявленное в блоке модуля, может сопровождаться *меткой экспорта* перед именем `пуб` , чтобы пояснить, что оно экспортируется из определяющего модуля с доступом *только на чтение*. В этом случае имя может быть использовано и в других модулях, если эти модули импортируют объявляющий модуль.
 
-`Имя` символа предваряется другим именем (префиксом), показывающим его модуль (см. Гл 11). Префикс и имя разделены точкой и вместе называются `уточнённым именем` (или `квалифицированным именем`).
+`Имя` символа предваряется другим именем (префиксом), показывающим его модуль (см. ниже). Модуль и имя разделены точкой и вместе называются `уточнённым именем` (или `квалифицированным именем`).
 
 > ИмяКвал = имя + "." + имя;
-> ИмяЭкспорт = имя + "*";
+> ИмяЭкспорт = "пуб" + имя ;
 
 Следующие имена являются стандартными (группа `ключевые символы`); их значение определено ниже:
 
-> ASR
-> ASSERT
-> бул
-> БАЙТ
-> EXCL
-> FLT
-> ЦЕЛОЕ
-> LSL
-> НОВ
-> ODD
-> ORD
-> PACK
-> ВЕЩ
-> ROR
-> SET
-> UNPK
+```bash
+ASR
+ASSERT
+бул
+байт
+EXCL
+FLT
+целое
+LSL
+нов
+ODD
+ORD
+PACK
+вещ
+ROR
+SET
+UNPK
+```
+
 
 ## 5. Объявление констант
 
 Объявление константы связывает её `имя` с её значением.
 
-> КонстантноеВыражение = Выражение;
-> ОбъявлениеКонстанты  = ИмяОпр "=" КонстантноеВыражение;
+```bsah
+КонстантноеВыражение = Выражение;
+ОбъявлениеКонстанты  = ИмяОпр + "=" + КонстантноеВыражение;
+```
 
-Константное выражение может быть вычислено по его тексту без фактического выполнения программы. Его операнды — константы. Примеры объявлений констант:
+Константное выражение может быть вычислено по его тексту на этапе компиляции программы. Его операнды — константы. Примеры объявлений констант:
 
 ```c
 конст {
     число = 100,
     лимит = 2 * число - 1,
     словаВсе = [0 .. словаРазмер -1],
-    имя = "Oberon",
+    имя = 'Oberon',
 }
 ```
 
 ## 6. Объявление типов
 
-`Тип данных` задаёт множество специфичных значений, которые переменные этого типа могут принимать, а также множетво операторов и методов, которые к ним применимы. Объявление типа используется для связывания имени с типом. Типы определяют структуру переменных этого типа и, косвенно, операторы, которые применимы к компонентам самих типов.
+`Тип данных` задаёт множество специфичных значений, которые переменные этого типа могут принимать, а также множетво операторов и методов, которые к ним применимы. Объявление типа используется для связывания имени типа с определением типа. Типы определяют структуру переменных этого типа и, косвенно, операторы, которые применимы к компонентам самих типов.
 
 Типы данных деляется на две группы:
 
@@ -346,28 +350,30 @@ flowchart TD
 
 После присвоения литеральная строка представлена массивом байтов.
 
-> ОбъявлениеТипа = ИмяОпр "=" Тип.
-> Тип = ИмяКвал | ТипМассив | ТипЗапись | ТипСсылка | ПроцедурныйТип.
+```bash
+ОбъявлениеТипа = ИмяОпр + "=" + Тип;
+Тип = ИмяКвал | ТипСущность | ТипМассив | ТипСтруктура | ТипФункция;
+```
 
 Примеры:
 
 ```c
 тип {
-    Таблица = МАССИВ[255]ВЕЩ,
+    Таблица = массив[255]вещ,
     Дерево = Узел,
 
     структ Узел {
-        ключ: ЦЕЛОЕ,
+        ключ: целое,
         Левый, Правый: Дерево,
     }
 
     ДеревоСередина = УзелСередина,
 
     структ УзелСередина (Узел){
-        Имя: МАССИВ[32]БАЙТ,
+        Имя: массив[32]байт,
         Подузел: Дерево,
     }
-    Функция = FN (x: ЦЕЛОЕ): ЦЕЛОЕ,
+    Функция = ФН (x: целое): целое,
 }
 ```
 
@@ -377,13 +383,13 @@ flowchart TD
 
 Встроенные линейные типы:
 
-- `бул` -- принимает значения `TRUE` и `FALSE`
-- `БАЙТ` -- целые числа от 0 до 255, размер фиксированный в 8 бит
-- `ЦЕЛОЕ` -- целые числа, размер зависит от реализации
-- `ВЕЩ` -- дробные числа, размер зависит от реализации
+- `бул` -- принимает значения `да` и `нет`;
+- `байт` -- целые числа от 0 до 255, размер фиксированный в 8 бит;
+- `целое` -- целые числа, размер зависит от аппаратуры;
+- `вещ` -- дробные числа, размер зависит от аппаратуры;
 
-Тип `БАЙТ` совместим с типом `ЦЕЛОЕ`, но наоборот требуется прведение.
-Тип `ЦЕЛОЕ` совместим с типом `ВЕЩ`, но наоборот требуется прведение.
+Тип `байт` совместим с типом `целое`, но наоборот требуется приведение.
+Тип `целое` совместим с типом `вещ`, но наоборот требуется приведение.
 В любом случае приведение *всегда* выполняется явно.
 
 ### 6.2 Встроенные векторные типы
@@ -393,23 +399,23 @@ flowchart TD
 - массив;
 - литеральная строка.
 
-Массив - это структура, состоящая из фиксированного количества элементов, тип элементов одинаковый для всех элементов данного типа массива. Количество элементов массива называется его длиной. Элементы массива обозначаются индексами, которые являются целыми числами от 0 до (длины - 1).
+Массив - это структура, состоящая из фиксированного количества элементов, тип элементов одинаковый для всех элементов конкретного типа массива. Количество элементов массива называется его длиной. Элементы массива обозначаются индексами, которые являются целыми числами от 0 до (длины - 1). Массив может иметь несколько размерностей.
 
 ```bash
-ТипМассива = МАССИВ[длина, длина..?]тип_элемента;
+ТипМассива = массив[длина, длина..?]тип_элемента;
 длина = Выражение | КонстантноеВыражение;
 ```
 
 Форма объявления
 
-> МАССИВ[N0, N1, ..., Nk]T
+> массив[N0, N1, ..., Nk]T
 
 Примеры типов массивов:
 
 ```c
 сущ {
-    listUser=МАССИВ[NN]ЦЕЛОЕ,
-    moments=МАССИВ[10, 20]ВЕЩ,
+    listUser = массив[NN]целое,
+    moments = массив[10, 20]вещ,
 }
 ```
 
@@ -419,117 +425,108 @@ flowchart TD
 
 ```bash
 сущ {
-    strHello="Привет",
+    strHello = `Привет`,
 }
 ```
 
-Все встроенные векторные типы *всегда* передаются по ссылке.
-
 ### 6.3 Структура
 
-Сущность `структура`, состоящая из фиксированного количества элементов возможно разных типов. Объявление типа структуры задаёт для каждого элемента, которое называется полем, его тип и имя, которое првязывает это поле. Область действия этих имён полей - само определение структуры, но они также видны как неотъемлемые части экземпляра структуры в форме "через точку", которая ссылается на элементы самого экземпляра структуры.
+Сущность `структура`, состоящая из фиксированного количества элементов возможно разных типов. Типа структуры при объявлении требует описание типа для каждого элемента этого типа, которое называется полем. Тип и имя поля првязывает является неотъемлемой частью структуры. Область действия этих имён полей - само определение структуры, но они также видны как неотъемлемые части экземпляра структуры в форме "через точку", которая ссылается на элементы самого экземпляра структуры. Структуры не помеченные как 'пуб' -- не экспортируются.
+Структуры не помеченные как 'мут' -- нельзя изменить после создания. Тоже самое относится и к каждому полю структуры.
 
 ```bash
-ТипЗаписи = структ ( БазовыйТип?) {
+ТипЗаписи = структ (БазовыйТип?) {
     СписокПолейТипа
 };
 БазовыйТип = квалификатор;
 СписокПолейТипа= СписокПолей?;
 СписокПолей = Поле..?
-Поле = Имя, Имя..? ":" тип;
+Поле = Имя, Имя..? + ":" + Тип;
 ```
 
-Если тип структуры экспортируется, имена полей, которые должны быть видимыми вне модуля объявления, должны быть помечены. Они называются публичными полями; неотмеченные поля называются приватными полями. Типы записей являются расширяемыми, т. е. тип записи может быть определён как расширение другого типа записи. В приведенных выше примерах УзелСередина (непосредственно) расширяет Узел, который является (прямым) базовым типом УзелСередина. Точнее, УзелСередина расширяет Узел с полями имя и подузел.
+Если тип структуры экспортируется, имена полей, которые должны быть видимыми вне модуля объявления, должны быть помечены. Они называются публичными полями; неотмеченные поля называются приватными полями. Типы записей являются расширяемыми, т. е. тип записи может быть определён как расширение другого типа записи. В приведенных выше примерах `УзелСередина` (непосредственно) расширяет `Узел`, который является (прямым) базовым типом `УзелСередина`. Точнее, `УзелСередина` расширяет `Узел` с полями имя и подузел.
 
-**Определение**. Тип `T1` является `T0`, если он непосредственно расширяет `T0`. И наоборот, тип `T0` является базовым типом для типа `T1`, если он является прямым базовым типом базового типа `T1`. Примеры типов структур:
+**Определение**. Тип `T1` является `T0`, если он непосредственно расширяет `T0`. и наоборот, тип `T0` является базовым типом для типа `T1`, если он является прямым базовым типом базового типа `T1`. Примеры типов структур:
 
 ```c
 тип {
     структ Дата {
-        день, месяц, год: ЦЕЛОЕ,
+        день, месяц, год: целое,
     }
     структ User (Дата){
-        имя, фамилия: МАССИВ[32]БАЙТ,
-        возраст: ЦЕЛОЕ,
-        зарплата: ВЕЩ,
+        имя, фамилия: массив[32]байт,
+        возраст: целое,
+        зарплата: вещ,
     }
 }
 ```
 
-### 6.4 Структуры и ссылки
-
-Типы структур *всегда* связываются по ссылке.
-
-```bash
-Тип = Структура?;
-```
-
-### 6.5 Тип функции
+## 6.4 Тип функции
 
-Тип функции является объектом кода, поэтому функция является статической сущностью.
+Тип функции является объектом кода, поэтому функция является статической сущностью. Можно удалить объект ссылающийся на функцию, но нельзя удалить саму функцию.
 
 Все переменные присваиваются ссылкой на функцию.
 
-> ТипФункция = FN (ФормальныеПараметры?)Результат?;
+> ТипФункция = ФН (ФормальныеПараметры?)Результат?;
 
-## 7. Объявление переменных
+## 7. Объявление объектов
 
-Объявления переменных служат для введения переменных и связывания их с именами, которые не должны повторяться в пределах данной области видимости. Они также служат для связывания встроенных линейных типов данных с переменными.
+Объявления объектов служат для введения объектов и связывания их с именами, которые не должны повторяться в пределах данной области видимости. Они также служат для связывания встроенных линейных типов данных с имена объектов.
 
-> ОбъявлениеПеременной = СписокИмён ":" тип;
+> ОбъявлениеОбъектов = СписокИмён ":" тип;
 
-Переменные, имена которых отображаются через запятую имеют один и тот же тип. Примеры объявления переменных (см. Примеры в главе 6):
+Объекты, имена которых отображаются через запятую имеют один и тот же тип. Примеры объявления объектов (см. Примеры ранее):
 
 ```c
 тип {
     структ Текст {
-        лит: БАЙТ,
-        счётчик: ЦЕЛОЕ,
+        лит: байт,
+        счётчик: целое,
     }
 }
 
 сущ {
-    i, j, k: ЦЕЛОЕ,
-    x, y: ВЕЩ,
+    i, j, k: целое,
+    x, y: вещ,
     p, q: бул,
-    f: FN(),
-    a: МАССИВ[100]ВЕЩ,
-    w: МАССИВ[16]Текст,
+    f: ФН(),
+    a: массив[100]вещ,
+    w: массив[16]Текст,
     t: Дерево,
 }
 ```
 
 ## 8. Выражения
 
-`Выражения` - это конструкции, содержащие правила вычисления, в которых константы и текущие значения переменных объединяются для получения других значений посредством применения операторов и процедур возвращающих результат.
+`Выражения` - это конструкции, содержащие правила вычисления, в которых константы и текущие значения объектов объединяются для получения других значений посредством применения операторов и процедур возвращающих результат.
 
-`Выражения` состоят из операндов и операторов. Также могут включать круглые скобки для выражения определённых правил вычисления операторов и операндов. Выражения разделяются `;`
+`Выражения` состоят из операндов и операторов. Также могут включать круглые скобки для выражения определённых правил вычисления операторов и операндов. Выражения разделяются литерой `;`.
 
 ### 8.1 Операнды
 
-За исключением чисел и литерных констант, операнды обозначаются именами. Обозначение операнда состоит из имени, которое может оносится к сущностям:
+За исключением чисел и литерных констант, операнды обозначаются именами. Обозначение операнда состоит из имени, которое может оносится к символам:
 
 - константа;
-- переменная;
+- объект;
 - процедура;
 - тип;
 
-Если имя операнда определено как имя модуля, то за ним могут следовать имена подчинённых сущностей. Если операнд является структурой, то через точку указываются поля такой структуры.
+Если имя операнда определено как имя модуля, то за ним могут следовать имена подчинённых символов. Если операнд является структурой, то через точку указываются поля такой структуры.
 
 > селектор = "." Имя | "["СписокВыражения"]" | «^» | "(" Квалификатор ")";
 > СписокВыражения = выражение..?;
 
-Если обозначенное имя сущности является переменной, то имя переменной ссылается на текущее значение переменной.
+Если обозначенное имя символа является объектом, то имя объекта ссылается на текущее значение самого объекта.
 
 Если объект является функцией, то имя функции без списка параметров ссылается на эту функцию. Если за функцией следует список параметров (возможно, пустой), имя подразумевает вызов функции и обозначает значение, полученное в результате её выполнения. Фактические параметры (используемых типов) должны соответствовать формальным параметрам, указанным в объявлении функции (см. далее).
 
 Примеры обозначений (см. Примеры в главе 7):
 
 ```c
-i              (ЦЕЛОЕ)
-а[I]           (ВЕЩ)
-w[3].ch        (БАЙТ)
-t.ключ         (ЦЕЛОЕ)
+i              (целое)
+а[I]           (вещ)
+w[3].ch        (байт)
+t.ключ         (целое)
 t.левый.правый (Дерево)
 t(УзелСредний).подузел(Дерево)
 ```
@@ -554,10 +551,10 @@ t(УзелСредний).подузел(Дерево)
 выражение = (ОперацияПростая ОперацияОтношение ОперацияПростая)..;
 ОперацияОтношение = "=" | "~" | "<" | "<=" | ">" | ">=" | есть;
 ОперацияПростая = ()"+"|"−"? разделитель? ОператорАддикции разделитель?;
-ОперациярАддикции= "+" | "−" | ИЛИ;
+ОперациярАддикции= "+" | "−" | или;
 разделитель = множитель ОператорМультипликации? множитель;
-ОператорМультипликации = "*" | "/" | ДИВ | МОД | И;
-множитель = число| строка| ПУСТО | ДА | НЕТ | ФактическийПараметр.. | "(" выражение ")" | "~" множитель;
+ОператорМультипликации = "*" | "/" | див | мод | и;
+множитель = число| строка| ПУСТО | да | нет | ФактическийПараметр.. | "(" выражение ")" | "~" множитель;
 ОперацияВыборки = выражение выражение..?;
 ФактическийПараметр = ( СписокВыражения..?);
 ```
@@ -568,15 +565,15 @@ t(УзелСредний).подузел(Дерево)
 
 | Символ | Результат                |
 | ------ | ------------------------ |
-| ИЛИ    | OR логическая дизъюнкция |
-| И      | И логическое соединение  |
-| НЕ     | НЕ логическое отрицание  |
+| или    | OR логическая дизъюнкция |
+| и      | и логическое соединение  |
+| не     | не логическое отрицание  |
 
 Эти операции применяются к операндам бул и дают результат BOO.
 
-> р ИЛИ q  // означает «если р, то ДА, иначе q»
-> p И q // обозначает «если р, то q, иначе НЕТ
-> НЕ P   // означает "не p"
+> р или q  // означает «если р, то да, иначе q»
+> p и q // обозначает «если р, то q, иначе нет
+> не P   // означает "не p"
 
 #### 8.2.2 Арифметические операторы
 
@@ -586,15 +583,15 @@ t(УзелСредний).подузел(Дерево)
 | -      | вычитание                |
 | *      | умножение                |
 | /      | деление                  |
-| ДИВ    | целое частное от деления |
-| МОД    | целое модуль  от деления |
+| див    | целое частное от деления |
+| мод    | целое модуль  от деления |
 
 Операторы `+`, `-`, `*` и `/` применяются к операндам числовых типов. Оба операнда *должны быть одного типа*, что также определяет тип результата. При использовании в качестве унарных операторов:
 
 - `-` обозначает инверсию знака;
 - `+` обозначает оператор идентичности.
 
-Операции `DIV` и `MOD` применяются *только* к целочисленным операндам. Пусть `q = x ДИВ y`, а `r = x МОД y`. Тогда множитель `q` и остаток `r` определяются уравнением:
+Операции `DIV` и `MOD` применяются *только* к целочисленным операндам. Пусть `q = x див y`, а `r = x мод y`. Тогда множитель `q` и остаток `r` определяются уравнением:
 
 > x = q * y + r
 > 0 <= r < y
@@ -611,7 +608,7 @@ t(УзелСредний).подузел(Дерево)
 | =      | больше или равно |
 | есть   | проверка типа    |
 
-Результат операций отношения является базовым типом `бул`. `ОперацияОтношение` (`<`, `<=`,`>`,`=`) применяется к числовым типам и `БАЙТ`. Отношения `=` и `!=` применимы также к типам `бул`, ссылкам и процедурным типам.
+Результат операций отношения является базовым типом `бул`. `ОперацияОтношение` (`<`, `<=`,`>`,`=`) применяется к числовым типам и `байт`. Отношения `=` и `!=` применимы также к типам `бул`, ссылкам и процедурным типам.
 
 `v есть T` означает `v ЯВЛЯЕТСЯ типом T` и вызывает проверку типа. Это применимо, если выполнены все условия:
 
@@ -622,11 +619,11 @@ t(УзелСредний).подузел(Дерево)
 Примеры выражений (см. Примеры в главе 7):
 
 ```c
-1987                (`ЦЕЛОЕ`)
-I ДИВ 3             (`ЦЕЛОЕ`)
-~ P ИЛИ q           (`бул`)
-(I + j) * (i-j)     (`ЦЕЛОЕ`)
-A [i + j] * a [i-j] (`ВЕЩ`)
+1987                (`целое`)
+I див 3             (`целое`)
+~ P или q           (`бул`)
+(I + j) * (i-j)     (`целое`)
+A [i + j] * a [i-j] (`вещ`)
 (0 <= i) & (i <100) (`бул`)
 T.ключ = 0          (`бул`)
 K == i              (`бул`)
@@ -649,12 +646,12 @@ T есть УзелСредний  (`бул`)
 
 > присвоение = переменная "=" выражение.
 
-Если значение параметра обладает структурой (массив или структура), параметру не разрешено присваивать его или его элементам. Импортируемые переменные также не могут быть присвоены. Если переменная не помечена ключевым словом `МУТ` при её описании -- ей нельзя присваивать даже в модуле объявления (кроме случаев создания такой переменной).
+Если значение параметра обладает структурой (массив или структура), параметру не разрешено присваивать его или его элементам. Импортируемые переменные также не могут быть присвоены. Если переменная не помечена ключевым словом `мут` при её описании -- ей нельзя присваивать даже в модуле объявления (кроме случаев создания такой переменной).
 
 Тип выражения должен быть таким же, как у переменной. Имеют место следующие исключения:
 
 - константу `ПУСТО` можно присвоить переменным любого типа;
-- литеральные строки могут быть назначены любому массиву байтов, если количество литер в литеральной строке меньше, чем количество байтов в массиве. (Добавляется литера с кодом ноль). Однолитерные строки также могут быть присвоены переменным типа `БАЙТ`;
+- литеральные строки могут быть назначены любому массиву байтов, если количество литер в литеральной строке меньше, чем количество байтов в массиве. (Добавляется литера с кодом ноль). Однолитерные строки также могут быть присвоены переменным типа `байт`;
 - в случае структур тип источника должен быть типом структуры адресата (либо расширением этой структуры),
 - массив может быть назначен другому массиву равного типа.
 
@@ -664,7 +661,7 @@ T есть УзелСредний  (`бул`)
 i = 0
 p = i = j
 x = FLT(i + 1)
-k = (i + j) ДИВ 2
+k = (i + j) див 2
 f = log2
 s = [2, 3, 5, 7, 11, 13]
 a[i] = (x+y) * (x-y)
@@ -681,28 +678,28 @@ w[i+1].ch = "A"
 ### 9.4 Предписание_ЕСЛИ
 
 ```bash
-Предписание_ЕСЛИ = ЕСЛИ Выражение {
+Предписание_ЕСЛИ = если Выражение {
     Последовательность_Предписаний;
-}АЕСЛИ  Выражение {
+}аесли  Выражение {
     Последовательность_Предписаний;
 }
 ```
 
-Составное предписание `ЕСЛИ` определяет условное выполнение охраняемых подчинённых предписаний. Логическое выражение, предшествующее предписанию называется охрана. Охрана вычисляет выражение в порядке встречи, пока выражение имеет значение `ДА`, после чего выполняется связанная с охраной последовательность предписаний. Если охраны не выполнена, то выполняется последовательность предписаний после символа `АЕСЛИ`, если такая ветка существует. Пример:
+Составное предписание `если` определяет условное выполнение охраняемых подчинённых предписаний. Логическое выражение, предшествующее предписанию называется охрана. Охрана вычисляет выражение в порядке встречи, пока выражение имеет значение `да`, после чего выполняется связанная с охраной последовательность предписаний. Если охраны не выполнена, то выполняется последовательность предписаний после символа `аесли`, если такая ветка существует. Пример:
 
 ```c
-ЕСЛИ (литера >= "A") И (литера <= "Z") {
+если (литера >= "A") и (литера <= "Z") {
     Сущность_Читать();
-}АЕСЛИ (литера >= "0") И (литера <= "9") {
+}аесли (литера >= "0") и (литера <= "9") {
     Число_Читать();
-}АЕСЛИ литера = 22X {
+}аесли литера = 22X {
     Строку_Читать();
 }
 ```
 
 ### 9.5 Предписание_ВЫБОР
 
-Составное предписание `ВЫБОР` определяет выбор и выполнение последовательности предписаний в соответствии со значением выражения. Сначала вычисляется выражение `ВЫБОР`, затем выполняется последовательность предписаний, чей список меток содержит полученное значение. Если выражение `ВЫБОР` имеет тип `ЦЕЛОЕ` или `БАЙТ`, все метки должны быть целыми или байтами, соответственно.
+Составное предписание `ВЫБОР` определяет выбор и выполнение последовательности предписаний в соответствии со значением выражения. Сначала вычисляется выражение `ВЫБОР`, затем выполняется последовательность предписаний, чей список меток содержит полученное значение. Если выражение `ВЫБОР` имеет тип `целое` или `байт`, все метки должны быть целыми или байтами, соответственно.
 
 ```bash
 Предписание_ВЫБОР= ВЫБОР выражение СписокМеток_ВЫБОР;
@@ -728,7 +725,7 @@ w[i+1].ch = "A"
 
 ```c
 тип СвязьЦел структ{
-    a : ЦЕЛОЕ
+    a : целое
 }
 
 р0 := СвязьЦел{
@@ -736,7 +733,7 @@ w[i+1].ch = "A"
 }
 
 тип СвязьВещ структ{
-    а:ВЕЩ
+    а:вещ
 }
 
 р1 := СвязьВещ{
@@ -755,14 +752,14 @@ P2 = R2;
 }
 ```
 
-### 9.6 Предписание ПОКА
+### 9.6 Предписание пока
 
-Составное предписание `ПОКА` определяет повторение. Если любое из булевых выражений (охрана) дает `ДА`, выполняется соответствующая последовательность предписаний. Вычисление выражения и выполнение предписаний повторяются до тех пор, пока в итоге булевы выражения охрыны не дадут `НЕТ`.
+Составное предписание `пока` определяет повторение. Если любое из булевых выражений (охрана) дает `да`, выполняется соответствующая последовательность предписаний. Вычисление выражения и выполнение предписаний повторяются до тех пор, пока в итоге булевы выражения охрыны не дадут `нет`.
 
 ```bash
-Предписание_ПОКА = ПОКА Выражение {}
+Предписание_ПОКА = пока Выражение {}
 ПоследовательностьПредписаний
-АЕСЛИ Выражение {
+аесли Выражение {
     ПоследовательностьПредписаний
 }
 ```
@@ -770,16 +767,16 @@ P2 = R2;
 Пример:
 
 ```c
-ПОКА j > 0 {
-    j = j ДИВ 2;
+пока j > 0 {
+    j = j див 2;
     i = i+1;
 }
-ПОКА (t НЕ NIL) И (t.key НЕ i){
+пока (t не NIL) и (t.key не i){
     t = t.left;
 }
-ПОКА m > n {
+пока m > n {
     m = m – n;
-} АЕСЛИ n > m {
+} аесли n > m {
     n = n – m;
 }
 ```
@@ -803,7 +800,7 @@ P2 = R2;
 
 ```c
 v := beg;
-ПОКА v <= end {
+пока v <= end {
     S();
     v = v + inc;
 }
@@ -813,13 +810,13 @@ v := beg;
 
 ```c
 v := beg;
-ПОКА v >= end {
+пока v >= end {
     S();
     v = v + inc;
 }
 ```
 
-Типы `v`, `beg` и `end` должны быть `ЦЕЛОЕ`, а `inc` должен быть целым (константное выражение). Если шаг не указан, предполагается, что он равен 1.
+Типы `v`, `beg` и `end` должны быть `целое`, а `inc` должен быть целым (константное выражение). Если шаг не указан, предполагается, что он равен 1.
 
 ## 10.  Объявление функций
 
@@ -829,7 +826,7 @@ v := beg;
 
 Первые активируются именем функции как частью выражения и возвращают результат, являющийся операндом в вызывающем выражении.
 
-Функции-процедуры активируются вызовом функции. Функция-процедура отличается в объявлении путём указания типа её результата после списка параметров. Её тело должно заканчиваться ключевым словом `ВЕРНУТЬ`, которое определяет результат функции-процедуры.
+Функции-процедуры активируются вызовом функции. Функция-процедура отличается в объявлении путём указания типа её результата после списка параметров. Её тело должно заканчиваться ключевым словом `вернуть`, которое определяет результат функции-процедуры.
 
 Все константы, переменные и типы, объявленные в теле функции, являются локальными для этой функции. Значения локальных переменных не определены при входе в функцию.
 
@@ -839,7 +836,7 @@ v := beg;
 ```bash
 ОбъявлениеФункции = ИмяФункции{ТелоФункции}.
 ИмяФункции = фн ИмяФункции(ФормальныеПараметры..)Результат.
-ТелоФункции = ПоследОбъявлений{ПоследПредписаний, ВЕРНУТЬ Выражение}.
+ТелоФункции = ПоследОбъявлений{ПоследПредписаний, вернуть Выражение}.
 ПоследОбъявлений = [конст {ОбъявлениеКонстант ";"}]
 [тип {ОбъявлениеТипов ";"}] [сущ {ОбъявлениеПеременных ";"}]
 {ОбъявлениеФункции ";"}.
@@ -858,7 +855,7 @@ v := beg;
 ```bash
 Формальныйпараметр = "(" [Секция_FP {";" Секция_FP}] ")" [":" квалификатор].
 Секция_FP = [сущ] имя{"," имя} ":" ФормальныйПараметр.
-ФормальныйПараметр = МАССИВ[nn]Тип..
+ФормальныйПараметр = массив[nn]Тип..
 ```
 
 Тип каждого формального параметра указан в списке параметров. Для переменных он должен быть идентичен типу соответствующего фактического параметра, за исключением случаев структур, где он должен быть базовым типом соответствующего типа фактического параметра.
@@ -868,37 +865,37 @@ v := beg;
 Примеры объявлений функций:
 
 ```c
-фн Целое_Читать(сущ x: `ЦЕЛОЕ`){
-    сущ i : ЦЕЛОЕ;
-    сущ ch: БАЙТ;
+фн Целое_Читать(сущ x: `целое`){
+    сущ i : целое;
+    сущ ch: байт;
     i = 0;
     Читать(ch);
-    ПОКА ("0" <= ch) И (ch <= "9") {
+    пока ("0" <= ch) и (ch <= "9") {
         i = 10*i + (ORD(ch)-ORD("0"));
         Читать(ch);
     }
     x = i
 }
 
-фн Целое_Писать(x: ЦЕЛОЕ){ // 0 <= x < 10^5
-сущ i: ЦЕЛОЕ;
-сущ buf: МАССИВ[5]ЦЕЛОЕ;
+фн Целое_Писать(x: целое){ // 0 <= x < 10^5
+сущ i: целое;
+сущ buf: массив[5]целое;
 i = 0;
-ПОКА i==0{
-    buf[i] = x МОД 10;
-    x = x ДИВ 10;
+пока i==0{
+    buf[i] = x мод 10;
+    x = x див 10;
     i++
     i++;
-    Записать(БАЙТ(buf[i] + ORD("0")));
+    Записать(байт(buf[i] + ORD("0")));
 }
 
-фн лог2(x: ЦЕЛОЕ):ЦЕЛОЕ{
-    сущ y ЦЕЛОЕ = 0; // assume x>0
+фн лог2(x: целое):целое{
+    сущ y целое = 0; // assume x>0
     WHILE x > 1 {
-        x = x ДИВ 2;
+        x = x див 2;
         y++;
     }
-    ВЕРНУТЬ y
+    вернуть y
 }
 ```
 
@@ -911,28 +908,28 @@ i = 0;
 | Имя           | Тип аргумента   | Тип результата       | Описание                       | Англ      |
 | ------------- | --------------- | -------------------- | ------------------------------ | --------- |
 |               | x: числовой тип | соответствует типу x | абсолютное значение числа      | ABS(x)    |
-|               | x: ЦЕЛОЕ        | бул                  | x МОД 2 = 1, чёиность          | ODD(x)    |
-| м.Длин()      | v: МАССИВ       | ЦЕЛОЕ                | длина массива v                | v.Len()   |
-| х.СдвигЛев(н) | x, н: ЦЕЛОЕ     | ЦЕЛОЕ                | логический сдвиг влево, x * 2n | LSL(x, n) |
-|               | x, n: ЦЕЛОЕ     | ЦЕЛОЕ                | знаковый сдвиг вправо,x DIV 2n | ASR(x, n) |
-|               | x, n: ЦЕЛОЕ     | ЦЕЛОЕ                | x сдвигается вправо на n бит   | ROR(x, n) |
+|               | x: целое        | бул                  | x мод 2 = 1, чёиность          | ODD(x)    |
+| м.Длин()      | v: массив       | целое                | длина массива v                | v.Len()   |
+| х.СдвигЛев(н) | x, н: целое     | целое                | логический сдвиг влево, x * 2n | LSL(x, n) |
+|               | x, n: целое     | целое                | знаковый сдвиг вправо,x DIV 2n | ASR(x, n) |
+|               | x, n: целое     | целое                | x сдвигается вправо на n бит   | ROR(x, n) |
 
 Функции преобразования типов:
 
 | Имя | Тип аргумента | Тип результата | Функция             | Англ     |
 | --- | ------------- | -------------- | ------------------- | -------- |
-|     | ВЕЩ           | ЦЕЛОЕ          | округление вниз     | FLOOR(x) |
-|     | ЦЕЛОЕ         | ВЕЩ            | преобразование типа | FLT(x)   |
-|     | БАЙТ, бул     | ЦЕЛОЕ          | порядковый номер x  | ORD(x)   |
+|     | вещ           | целое          | округление вниз     | FLOOR(x) |
+|     | целое         | вещ            | преобразование типа | FLT(x)   |
+|     | байт, бул     | целое          | порядковый номер x  | ORD(x)   |
 
 Безопасные процедуры:
 
 | Имя    | Тип аргумента | Функция                        | Англ       |
 | ------ | ------------- | ------------------------------ | ---------- |
-| НОВ(v) | перменная     | размещение переменной в памяти | NEW(v)     |
+| нов(v) | перменная     | размещение переменной в памяти | NEW(v)     |
 |        | BOOLEAN       | прервать, если ~b              | ASSERT(b)  |
-|        | ВЕЩ, ЦЕЛОЕ    | упаковать x и n в x            | PACK(x, n) |
-|        | ВЕЩ, ЦЕЛОЕ    | распаковать x в x и n          | UNPK(x, n) |
+|        | вещ, целое    | упаковать x и n в x            | PACK(x, n) |
+|        | вещ, целое    | распаковать x в x и n          | UNPK(x, n) |
 
 Функция FLOOR (x) дает наибольшее целое число, не большее x.
 
@@ -980,16 +977,16 @@ i = 0;
     W: Текст.Writer,
 }
 
-фн Write*(ch: БАЙТ){
+фн Write*(ch: байт){
     Текст.Write(W, ch);
 }
 
-фн WriteInt*(x, n: `ЦЕЛОЕ`){
+фн WriteInt*(x, n: `целое`){
     сущ {
-        i: ЦЕЛОЕ = 0,
-        a: МАССИВ[16]BYTE,
+        i: целое = 0,
+        a: массив[16]BYTE,
     }
-    ЕСЛИ x < 0 {
+    если x < 0 {
         Текст.Текст(W, "-");
         x := -x;
     }
@@ -997,15 +994,15 @@ i = 0;
         a[i] = CHR(x MOD 10 + ORD("0"));
         x = x DIV 10;
         i++
-        ЕСЛИ х == 0{
-            ПРЕРВАТЬ;
+        если х == 0{
+            стоп;
         }
     }
     Текст.Write(W, " ");
     n--;
     ПЕТЛЯ {
-        ЕСЛИ n >i{
-            ПРЕРВАТЬ;
+        если n >i{
+            стоп;
         }
         i--;
     }
@@ -1044,14 +1041,14 @@ i = 0;
 Функция
 ADR(v)
 любой
-`ЦЕЛОЕ`
+`целое`
 адрес переменной v
 SIZE(T)
 любой тип
-`ЦЕЛОЕ`
+`целое`
 размер в байтах
 BIT(a, n)
-a, n: `ЦЕЛОЕ`
+a, n: `целое`
 BOOLEAN
 n бит в mem[a]
 
@@ -1063,17 +1060,17 @@ n бит в mem[a]
 Тип результата
 Функция
 GET(a, v)
-a: `ЦЕЛОЕ`;
+a: `целое`;
 v: любой базовый тип
 v := mem[a]
 PUT(a, x)
-a: `ЦЕЛОЕ`;
+a: `целое`;
 x: любой базовый тип
 mem[a] := x
 COPY(src, dst, n)
 все
 
-`ЦЕЛОЕ`
+`целое`
 
 копировать n последовательных 	слов из src в dst
 
@@ -1090,19 +1087,19 @@ VAL(T, n)
 T
 преобразование
 ADC(m, n)
-`ЦЕЛОЕ`
-`ЦЕЛОЕ`
+`целое`
+`целое`
 сложение с флагом переноса C
 SBC(m, n)
-`ЦЕЛОЕ`
-`ЦЕЛОЕ`
+`целое`
+`целое`
 вычитание с флагом переноса C
 UML(m, n)
-`ЦЕЛОЕ`
-`ЦЕЛОЕ`
+`целое`
+`целое`
 беззнаковое умножение
 COND(n)
-`ЦЕЛОЕ`
+`целое`
 BOOLEAN
 IF Cond(n) THEN ...
 
@@ -1112,7 +1109,7 @@ IF Cond(n) THEN ...
 Тип аргумента
 Функция
 LED(n)
-`ЦЕЛОЕ`
+`целое`
 отображает n на LED-экране
 
 
@@ -1132,7 +1129,7 @@ LED(n)
 КонстВыражение = выражение.
 ОпрТипа 	= ОпрИмени "=" тип.
 тип 		= квалификатор| ТипМассива | ТипЗаписи | ТипСсылка | ТипПроцедуры.
-ТипМассива = МАССИВ длина {"," длина} OF тип.
+ТипМассива = массив длина {"," длина} OF тип.
 длина 	= КонстВыражение .
 ТипЗаписи 	= RECORD ["(" БазовыйТип ")"] [ПоследСписокПолей] END.
 БазовыйТип = квалификатор.
@@ -1188,7 +1185,7 @@ DO ПоследПредписаний END.
 {ОпрПроцедуры ";"}.
 ФормальныеПараметры = "(" [Секция_FP {";" Секция_FP}] ")" [":" квалификатор].
 Секция_FP 	= [сущ] имя {"," имя } ":" ФормальныйТип.
-ФормальныйТип = {МАССИВ OF} квалификатор.
+ФормальныйТип = {массив OF} квалификатор.
 
 модуль	= MODULE имя ";" [СписокИмпорта] ПоследОпределений
 [BEGIN ПоследПредписаний ] END имя "."
@@ -1203,14 +1200,14 @@ DO ПоследПредписаний END.
 Бурцева В.
 
 Перевод выполнили:
-Денисов И.
+Денисов и.
 Шипков В.
 
 Технические консультанты:
 
 Ершов А. П.
 Волков С.
-Ермаков И.
+Ермаков и.
 Ефимов А.
 
 Дополнительные материалы: