SVI Исправления, редактирование

README.md

@@ -32,16 +32,16 @@
   - [9. Предписания](#9-предписания)
     - [9.1 Предписание ПРИСВОЕНИЕ](#91-предписание-присвоение)
     - [9.3 Последовательность предписаний](#93-последовательность-предписаний)
-    - [9.4 Предписание\_ЕСЛИ](#94-предписание_если)
     - [9.5 Предписание\_ВЫБОР](#95-предписание_выбор)
-    - [9.6 Предписание пока](#96-предписание-пока)
-    - [9.7 Предписание ДЛЯ](#97-предписание-для)
+    - [9.7 Предписание цикл](#97-предписание-цикл)
   - [10.  Объявление функций](#10--объявление-функций)
     - [10.1 Формальные параметры](#101-формальные-параметры)
     - [10.2. Встроенные функции](#102-встроенные-функции)
   - [11.  Модули](#11--модули)
     - [11.1 Модуль СИСТЕМА](#111-модуль-система)
-  - [Ссылки](#ссылки)
+  - [Приложение 1: Синтаксис Оберона](#приложение-1-синтаксис-оберона)
+  - [Приложение 2: Участники](#приложение-2-участники)
+  - [Пиложение 3: Ссылки](#пиложение-3-ссылки)
 
 ## 0. Введение
 
@@ -262,7 +262,7 @@ flowchart TD
 | ветка   | CASE ветка выбора                                    |
 | вернуть | RETURN Возврат из функции                            |
 | нич     | NIL Пустое состояние объекта                         |
-| петля   | LOOP Безусловный цикл                                |
+| цикл    | LOOP Безусловный цикл                                |
 | дальше  | NEXT Продолжить цикл с пропуском следующих выражений |
 | стоп    | BREAK Прервать цикл с пропуском следующих выражений  |
 | или     | OR Логическое или                                    |
@@ -305,7 +305,6 @@ SET
 UNPK
 ```
 
-
 ## 5. Объявление констант
 
 Объявление константы связывает её `имя` с её значением.
@@ -406,13 +405,6 @@ UNPK
 }
 ```
 
-После присвоения литеральная строка представлена массивом байтов.
-
-```bash
-ОбъявлениеТипа = ИмяТип + "=" + СТРУКТ (ИмяТип?) { Поле..? };
-Тип = ИмяКвал | ТипСущность | ТипМассив | ТипСтруктура | ТипФункция;
-```
-
 `Литеральная строка` при создании представляет собой набор байт в виде букв в одинарных кавычках. После привоения фактически -- это массив байт.
 
 Пример:
@@ -423,6 +415,13 @@ UNPK
 }
 ```
 
+После присвоения литеральная строка представлена массивом байтов.
+
+```bash
+ОбъявлениеТипа = ИмяТип + "=" + СТРУКТ (ИмяТип?) { Поле..? };
+Тип = ИмяКвал | ТипСущность | ТипМассив | ТипСтруктура | ТипФункция;
+```
+
 ### 6.3 Структура
 
 Символ `структура`, состоит из фиксированного количества элементов возможно разных типов. Тип структуры при объявлении требует описание типа для каждого элемента этого типа, которое называется `полем`. Тип и имя `поля` является неотъемлемой частью структуры. Область действия этих имён полей - само определение структуры, но они также видны как неотъемлемые части экземпляра структуры в форме "через точку", которая ссылается на элементы самого экземпляра структуры. Структуры не помеченные как 'пуб' -- не экспортируются.
@@ -433,8 +432,7 @@ UNPK
     СписокПолейТипа
 };
 БазовыйТип = квалификатор;
-СписокПолейТипа= СписокПолей?;
-СписокПолей = Поле..?
+СписокПолейТипа= Поле..?;
 Поле = Имя, Имя..? + ":" + Тип;
 ```
 
@@ -444,10 +442,10 @@ UNPK
 
 ```c
 тип {
-    структ Дата {
+    Дата = структ {
         день, месяц, год: целое,
     }
-    структ User (Дата){
+    User = структ (Дата){
         имя, фамилия: массив[32]байт,
         возраст: целое,
         зарплата: вещ,
@@ -465,15 +463,17 @@ UNPK
 
 ## 7. Объявление объектов
 
-Объявления объектов служат для введения объектов и связывания их с именами, которые не должны повторяться в пределах данной области видимости. Они также служат для связывания встроенных линейных типов данных с имена объектов.
+Объявления объектов служат для введения объектов и связывания их с именами, которые не должны повторяться в пределах данной области видимости. Они также служат для связывания встроенных линейных и векторных типов данных с имена объектов.
 
-> ОбъявлениеОбъектов = СписокИмён ":" тип;
+```bash
+ОбъявлениеОбъектов = Имя, Имя..? ":" тип;
+```
 
 Объекты, имена которых отображаются через запятую имеют один и тот же тип. Примеры объявления объектов (см. Примеры ранее):
 
 ```c
 тип {
-    структ Текст {
+    Текст = структ {
         лит: байт,
         счётчик: целое,
     }
@@ -492,7 +492,7 @@ UNPK
 
 ## 8. Выражения
 
-`Выражения` - это конструкции, содержащие правила вычисления, в которых константы и текущие значения объектов объединяются для получения других значений посредством применения операторов и процедур возвращающих результат.
+`Выражения` - это конструкции, содержащие правила вычисления, в которых константы и текущие значения объектов объединяются для получения других значений посредством применения операторов и функций возвращающих результат.
 
 `Выражения` состоят из операндов и операторов. Также могут включать круглые скобки для выражения определённых правил вычисления операторов и операндов. Выражения разделяются литерой `;`.
 
@@ -502,13 +502,15 @@ UNPK
 
 - константа;
 - объект;
-- процедура;
+- функция;
 - тип;
 
 Если имя операнда определено как имя модуля, то за ним могут следовать имена подчинённых символов. Если операнд является структурой, то через точку указываются поля такой структуры.
 
-> селектор = "." Имя | "["СписокВыражения"]" | «^» | "(" Квалификатор ")";
-> СписокВыражения = выражение..?;
+```bash
+СелекторСимвола = Модуль? + "."? +  Имя | "["СписокВыражения"]";
+СписокВыражения = выражение..?;
+```
 
 Если обозначенное имя символа является объектом, то имя объекта ссылается на текущее значение самого объекта.
 
@@ -529,7 +531,6 @@ t(УзелСредний).подузел(Дерево)
 
 Синтаксис выражений различает четыре вида операторов с разными приоритетами (порядком выполнения).
 
-- `~` (инверсия имеет наивысший приоритет)
 - `*`, `/` (умножение и деление)
 - `+`,`-` (сложения и вычитание)
 
@@ -542,15 +543,15 @@ t(УзелСредний).подузел(Дерево)
 > (x-y)-z
 
 ```bash
-выражение = (ОперацияПростая ОперацияОтношение ОперацияПростая)..;
-ОперацияОтношение = "=" | "~" | "<" | "<=" | ">" | ">=" | есть;
-ОперацияПростая = ()"+"|"−"? разделитель? ОператорАддикции разделитель?;
+Операция = ОперацияПростая | ОперацияОтношение;
+ОперацияОтношение = "=" | "<" | "<=" | ">" | ">=" | есть;
+ОперацияПростая = "+" | "−"  Разделитель? ОператорАддикции Разделитель?;
 ОперациярАддикции= "+" | "−" | или;
-разделитель = множитель ОператорМультипликации? множитель;
-ОператорМультипликации = "*" | "/" | див | мод | и;
-множитель = число| строка| ПУСТО | да | нет | ФактическийПараметр.. | "(" выражение ")" | "~" множитель;
+Разделитель = пробел.. | табуляция.. | ПереводСтроки..;
+ОператорМультипликации = "*" | "/" | и;
+Множитель = число| строка| ПУСТО | да | нет | ФактическийПараметр.. | "(" выражение ")" | "~" множитель;
 ОперацияВыборки = выражение выражение..?;
-ФактическийПараметр = ( СписокВыражения..?);
+ФактическийПараметр = (СписокВыражения..?);
 ```
 
 Множество [m..n] обозначает [m, m + 1, ..., n-1, n], а если m>n, то пустое множество. Доступные операции перечислены в следующих таблицах. В некоторых случаях несколько разных операций обозначаются одним и тем же символом операции. В этих случаях фактическая операция определяется типом операндов.
@@ -571,91 +572,82 @@ t(УзелСредний).подузел(Дерево)
 
 #### 8.2.2 Арифметические операторы
 
-| Символ | Результат                |
-| ------ | ------------------------ |
-| +      | сложение                 |
-| -      | вычитание                |
-| *      | умножение                |
-| /      | деление                  |
-| див    | целое частное от деления |
-| мод    | целое модуль  от деления |
+| Символ | Результат |
+| ------ | --------- |
+| +      | сложение  |
+| -      | вычитание |
+| *      | умножение |
+| /      | деление   |
 
 Операторы `+`, `-`, `*` и `/` применяются к операндам числовых типов. Оба операнда *должны быть одного типа*, что также определяет тип результата. При использовании в качестве унарных операторов:
 
 - `-` обозначает инверсию знака;
 - `+` обозначает оператор идентичности.
 
-Операции `DIV` и `MOD` применяются *только* к целочисленным операндам. Пусть `q = x див y`, а `r = x мод y`. Тогда множитель `q` и остаток `r` определяются уравнением:
-
-> x = q * y + r
-> 0 <= r < y
-
 #### 8.2.3 Отношения
 
 | Символ | Результат        |
 | ------ | ---------------- |
-| =      | равно            |
+| ==     | равно            |
 | !=     | неравно          |
 | <      | меньше           |
 | <=     | меньше или равно |
 | >      | больше           |
-| =      | больше или равно |
+| >=     | больше или равно |
 | есть   | проверка типа    |
 
-Результат операций отношения является базовым типом `бул`. `ОперацияОтношение` (`<`, `<=`,`>`,`=`) применяется к числовым типам и `байт`. Отношения `=` и `!=` применимы также к типам `бул`, ссылкам и процедурным типам.
+Результат операций отношения является базовым типом `бул`. `ОперацияОтношение` (`==`,`!=`, `<`, `<=`,`>`,`>=`) применяется к числовым типам и `байт`. Отношения `==` и `!=` применимы также к типам `бул`, и функциям.
 
 `v есть T` означает `v ЯВЛЯЕТСЯ типом T` и вызывает проверку типа. Это применимо, если выполнены все условия:
 
 - `T` расширение объявленной структуры `T0` для `v`;
-- `v` параметр, как переменная заданного типа структуры.
+- `v` параметр, как объект заданного типа структуры.
 
-Предполагая, например, что сслыка на тип структуры `T` является расширением базовой ссылки на  тип структуры `T0`, тогда проверка `v есть T` определяет, является ли фактически указанная переменная (в том числе, а не только `T0`) cтруктурой типа `T`. Значение `ПУСТО есть Т` возвращает отрицательный результат.
+Предполагая, например, что тип структуры `T` является расширением базовой структуры `T0`, тогда проверка `v есть T` определяет, является ли фактически указанный объект (в том числе, а не только `T0`) cтруктурой типа `T`. Значение `ПУСТО есть Т` возвращает отрицательный результат.
 Примеры выражений (см. Примеры в главе 7):
 
 ```c
 1987                (`целое`)
-I див 3             (`целое`)
-~ P или q           (`бул`)
+P == q              (`бул`)
 (I + j) * (i-j)     (`целое`)
 A [i + j] * a [i-j] (`вещ`)
-(0 <= i) & (i <100) (`бул`)
-T.ключ = 0          (`бул`)
+(0 <= i) и (i <100) (`бул`)
+T.ключ == 0         (`бул`)
 K == i              (`бул`)
 T есть УзелСредний  (`бул`)
 ```
 
 ## 9. Предписания
 
-Предписания обозначают *языковые действия*. Есть простые и составные предписания. Простые предписания не состоят из каких-либо частей, которые сами являлись бы предписаниями. Простые предписания -- просто присваивания, либо вызов процедур.
+Предписания обозначают *языковые действия*. Простые предписания есть операторы. Простые предписания не состоят из каких-либо частей, которые сами являлись бы предписаниями.
 
-Составные предписания состоят из частей, которые сами являются предписаниями. Они используются, чтобы выразить последовательное и условное, выборочное и повторное действие.
+Составные предписания состоят из частей, которые сами являются предписаниями. Они используются, чтобы выразить последовательное и условное, выборочное и повторное действие; служат для изменения выполнения потока программы.
 
 Предписания также могут быть пустыми, и в этом случае они не обозначают никаких действий. Пустое предписание включено в язык для того, чтобы ослабить правила пунктуации в последовательностях предписаний.
 
-> Предписание = [Присвоение | ВызовПроцедур | Предписание_ЕСЛИ | Предписание_ВЫБОР | Предписание_ПОКА | Предписание_ДЛЯ | Предписание_ПЕТЛЯ].
+> Предписание = Оператор | Присвоение | ВызовПроцедур | Предписание_ВЫБОР | Предписание_ЦИКЛ.
 
 ### 9.1 Предписание ПРИСВОЕНИЕ
 
-Элементарное предписание `ПРИСВОЕНИЕ` служит для замены текущего значения переменной на новое значение, заданное выражением. Предписание `ПРИСВОЕНИЕ` записывается как «=» и произносится как «присвоить».
+Элементарное предписание `ПРИСВОЕНИЕ` служит для замены текущего значения объекта на новое значение, заданное выражением. Предписание `ПРИСВОЕНИЕ` записывается как «=» и произносится как «присвоить».
 
-> присвоение = переменная "=" выражение.
+> присвоение = объект + "=" + выражение;
 
-Если значение параметра обладает структурой (массив или структура), параметру не разрешено присваивать его или его элементам. Импортируемые переменные также не могут быть присвоены. Если переменная не помечена ключевым словом `мут` при её описании -- ей нельзя присваивать даже в модуле объявления (кроме случаев создания такой переменной).
+Если значение параметра обладает структурой (массив или структура), присвоение замещает исходное значение объекта. Импортируемые объекты не могут быть присвоены. Если объект не помечена ключевым словом `мут` при её описании -- ему нельзя присваивать даже в модуле объявления (кроме случаев создания такого объекта).
 
-Тип выражения должен быть таким же, как у переменной. Имеют место следующие исключения:
+Тип выражения должен быть таким же, как у объекта. Имеют место следующие исключения:
 
-- константу `ПУСТО` можно присвоить переменным любого типа;
-- литеральные строки могут быть назначены любому массиву байтов, если количество литер в литеральной строке меньше, чем количество байтов в массиве. (Добавляется литера с кодом ноль). Однолитерные строки также могут быть присвоены переменным типа `байт`;
-- в случае структур тип источника должен быть типом структуры адресата (либо расширением этой структуры),
+- константу `ПУСТО` можно присвоить объектам любого типа;
+- литеральные строки могут быть назначены любому массиву байтов длины больше, чем длина литеральной строки +1. В массив будет добавлена в конец литера с кодом ноль. Однолитерные строки также могут быть присвоены объектам типа `байт`;
+- в случае структур тип источника должен быть типом структуры получателя,
 - массив может быть назначен другому массиву равного типа.
 
 Примеры присвоений (см. Примеры в главе 7):
 
 ```c
 i = 0
-p = i = j
-x = FLT(i + 1)
-k = (i + j) див 2
+p = i
+k = (i + j) \ 2
 f = log2
 s = [2, 3, 5, 7, 11, 13]
 a[i] = (x+y) * (x-y)
@@ -667,36 +659,14 @@ w[i+1].ch = "A"
 
 Последовательности предписаний обозначают последовательность действий, заданную частями операторов, разделенными точкой с запятой.
 
-> Последовательность_Предписаний = Предписание? ; (Предписание;)..?;
-
-### 9.4 Предписание_ЕСЛИ
-
-```bash
-Предписание_ЕСЛИ = если Выражение {
-    Последовательность_Предписаний;
-}аесли  Выражение {
-    Последовательность_Предписаний;
-}
-```
-
-Составное предписание `если` определяет условное выполнение охраняемых подчинённых предписаний. Логическое выражение, предшествующее предписанию называется охрана. Охрана вычисляет выражение в порядке встречи, пока выражение имеет значение `да`, после чего выполняется связанная с охраной последовательность предписаний. Если охраны не выполнена, то выполняется последовательность предписаний после символа `аесли`, если такая ветка существует. Пример:
-
-```c
-если (литера >= "A") и (литера <= "Z") {
-    Сущность_Читать();
-}аесли (литера >= "0") и (литера <= "9") {
-    Число_Читать();
-}аесли литера = 22X {
-    Строку_Читать();
-}
-```
+> Последовательность_Предписаний = Предписание? ; Предписание..?;
 
 ### 9.5 Предписание_ВЫБОР
 
-Составное предписание `ВЫБОР` определяет выбор и выполнение последовательности предписаний в соответствии со значением выражения. Сначала вычисляется выражение `ВЫБОР`, затем выполняется последовательность предписаний, чей список меток содержит полученное значение. Если выражение `ВЫБОР` имеет тип `целое` или `байт`, все метки должны быть целыми или байтами, соответственно.
+Составное предписание `выбор` определяет выбор и выполнение последовательности предписаний в соответствии со значением выражения. Сначала вычисляется выражение `выбор`, затем выполняется последовательность предписаний, чей список меток содержит полученное значение. Если выражение `выбор` имеет тип `целое` или `байт`, все метки должны быть целыми или байтами, соответственно.
 
 ```bash
-Предписание_ВЫБОР= ВЫБОР выражение СписокМеток_ВЫБОР;
+Предписание_ВЫБОР= выбор выражение СписокМеток_ВЫБОР;
 Выбор = Сущность ":" СписокВыражений;
 СписокМеток_ВЫБОР = МеткиДляВыбора["," МеткиДляВыбора].
 МеткиДляВыбора = Метка .. Метка..?;
@@ -705,191 +675,152 @@ w[i+1].ch = "A"
 
 Пример:
 ```c
-ВЫБОР k {
-    | 0: x = x + y,
-    | 1: x = x − y,
-    | 2: x = x * y,
-    | 3: x = x / y,
+выбор k {
+    провер 0: x = x + y,
+    провер 1: x = x − y,
+    провер 2: x = x * y,
+    провер 3: x = x / y,
 }
 ```
 
-Тип `T` выражения `ВЫБОР` (переменная после ключевого символа `ВЫБОР`) также может быть типом структуры. Тогда метки для `ВЫБОР` должны быть расширениями `Т`, а в предписаниях `Si`, помеченных `Ti`, переменная `ВЫБОР` рассматривается как тип `Ti`.
+Тип `T` выражения `выбор` (переменная после ключевого символа `выбор`) также может быть типом структуры. Тогда метки для `выбор` должны быть расширениями `Т`, а в предписаниях `провер` переменная `выбор` рассматривается как соответствующий тип `провер`.
 
 Пример:
 
 ```c
-тип СвязьЦел структ{
-    a : целое
-}
-
-р0 := СвязьЦел{
-    а:5,
-}
-
-тип СвязьВещ структ{
-    а:вещ
-}
-
-р1 := СвязьВещ{
-    а:6.1,
+тип {
+    СвязьЦел = структ {
+        a : целое,
+    }
+    СвязьВещ = структ{
+        а:вещ,
+    }
 }
 
-P := тЗапись{};
-P0 = R0;
-P1 = R1;
-P2 = R2;
-
-ВЫБОР p {
-    | P0: p.а = 10
-    | P1: p.а = 2.5
-    | P2: p.а = 0, 2
+сущ {
+    р0 = СвязьЦел {
+        а:5,
+    }
+    р1 = СвязьВещ {
+        а:6.1,
+    }
+    P = тЗапись{}
 }
-```
 
-### 9.6 Предписание пока
-
-Составное предписание `пока` определяет повторение. Если любое из булевых выражений (охрана) дает `да`, выполняется соответствующая последовательность предписаний. Вычисление выражения и выполнение предписаний повторяются до тех пор, пока в итоге булевы выражения охрыны не дадут `нет`.
-
-```bash
-Предписание_ПОКА = пока Выражение {}
-ПоследовательностьПредписаний
-аесли Выражение {
-    ПоследовательностьПредписаний
+{
+    P0 = R0;
+    P1 = R1;
+    P2 = R2;
+
+    выбор p {
+        провер P0: p.а = 10,
+        провер P1: p.а = 2.5,
+        провер P2: p.а = 0,
+    }
 }
 ```
 
-Пример:
-
-```c
-пока j > 0 {
-    j = j див 2;
-    i = i+1;
-}
-пока (t не NIL) и (t.key не i){
-    t = t.left;
-}
-пока m > n {
-    m = m – n;
-} аесли n > m {
-    n = n – m;
-}
-```
+### 9.7 Предписание цикл
 
-### 9.7 Предписание ДЛЯ
+Составное предписание `цикл` указывает повторное выполнение последовательности выражений бесконечное количество раз. Для досрочного начала очередной операции используется ключевой символ `дальше`. Для прерывания итераций используется ключевой символ `стоп`.
 
-Составное предписание `ДЛЯ` указывает повторное выполнение последовательности предписаний заданное количество раз, одновременно последовательно увеличивая значение переменной, которая называется управляющая переменная для предписания FOR.
 ```bash
-Предписание_ДЛЯ =
-ДЛЯ Имя ":=" Выражение ДО Выражение[ПО КонстантаВаражения]{
-    ПоследовательностьПредписаний
-}
-```
-
-Предписание `ДЛЯ`
-> ДЛЯ v := beg ДО end ПО inc {
-> S
-> }
-
-есть, если inc>0, что эквивалентно
-
-```c
-v := beg;
-пока v <= end {
-    S();
-    v = v + inc;
-}
-```
-
-и если inc<0, то это эквивалентно
-
-```c
-v := beg;
-пока v >= end {
-    S();
-    v = v + inc;
+Предписание_ЦИКЛ =
+цикл {
+    ПоследовательностьПредписаний..?;
 }
 ```
 
-Типы `v`, `beg` и `end` должны быть `целое`, а `inc` должен быть целым (константное выражение). Если шаг не указан, предполагается, что он равен 1.
-
 ## 10.  Объявление функций
 
-Объявление функцмй состоит из заголовка функции и её тела. Заголовок определяет имя функции, формальные параметры и тип результата (если таковой есть). Тело содержит объявления и предписания.
+Объявление функций состоит из заголовка функции и её тела. Заголовок определяет имя функции, формальные параметры и тип результата (если таковой есть). Тело содержит объявления и предписания.
 
-Существует два типа функций, а именно функции и фнкции-процедуры.
+Существует два типа функций, а именно функции и функции-процедуры.
 
 Первые активируются именем функции как частью выражения и возвращают результат, являющийся операндом в вызывающем выражении.
 
-Функции-процедуры активируются вызовом функции. Функция-процедура отличается в объявлении путём указания типа её результата после списка параметров. Её тело должно заканчиваться ключевым словом `вернуть`, которое определяет результат функции-процедуры.
+Функции активируются вызовом функции. Функция отличается от функции-процедуры в объявлении путём указания типа её результата после списка параметров. Её тело должно заканчиваться ключевым словом `вернуть`, которое определяет результат функции.
 
-Все константы, переменные и типы, объявленные в теле функции, являются локальными для этой функции. Значения локальных переменных не определены при входе в функцию.
+Все константы, объекты и типы, объявленные в теле функции, являются локальными для этой функции. Значения локальных объектов не определено при входе в функцию.
 
 В дополнение к своим формальным параметрам и локально объявленным объектам -- объекты, объявленные глобально, также видны в функции.
 Использование имени функции в вызове в границах её объявления подразумевает рекурсивный вызов функции.
 
 ```bash
-ОбъявлениеФункции = ИмяФункции{ТелоФункции}.
-ИмяФункции = фн ИмяФункции(ФормальныеПараметры..)Результат.
-ТелоФункции = ПоследОбъявлений{ПоследПредписаний, вернуть Выражение}.
-ПоследОбъявлений = [конст {ОбъявлениеКонстант ";"}]
-[тип {ОбъявлениеТипов ";"}] [симв {ОбъявлениеПеременных ";"}]
-{ОбъявлениеФункции ";"}.
+ОбъявлениеФункции = ИмяФункции ТелоФункции;
+ИмяФункции = фн ИмяФункции(ФормальныеПараметры..)Результат?;
+ТелоФункции = ПоследОбъявлений..? ПоследПредписаний..? вернуть Выражение;
+ПоследОбъявлений = ОбъявлениеКонстант..? ; ОбъявлениеТипов..? ; ОбъявлениеОбъектов?;
 ```
 
 ### 10.1 Формальные параметры
 
-Формальные параметры (или просто параметры) -- это имена, которые обозначают фактические параметры (аргументы), указанные в вызове функции. Соответствие между аргументами и параметрами устанавливается при вызове функции. Переменная соответствует фактическому параметру, который является переменной, и она обозначает эту переменную. Значение соответствует фактическому параметру, который является выражением, и он обозначает его значение, которое невозможно изменить при передаче. Однако, если значение имеет базовый тип, он представляет собой локальную переменную, которой первоначально присваивается значение фактического выражения.
+Формальные параметры (или просто параметры) -- это имена, которые обозначают фактические параметры (аргументы), указанные в вызове функции. Соответствие между аргументами и параметрами устанавливается при вызове функции. Объект соответствует фактическому параметру, который является объектом внутри функции. Значение соответствует фактическому параметру, который является выражением, и он обозначает его значение, которое невозможно изменить при передаче. Однако, если значение имеет базовый тип, он представляет собой локальный объект, которому первоначально присваивается значение фактического выражения.
 
-Тип параметра указывается в списке формальных параметров: переменные обозначаются ключевым словом `симв`, а  значения не имеют такого префикса.
+Тип параметра указывается в списке формальных параметров.
 
 Функция-процедура без параметров должна иметь пустой список параметров. Она должна быть вызвана через имя функции, список фактических параметров которой также пуст.
 
 Формальные параметры являются локальными для функции, т. е. их область действия - это текст программы, который представляет собой объявление функции.
 
 ```bash
-Формальныйпараметр = "(" [Секция_FP {";" Секция_FP}] ")" [":" квалификатор].
-Секция_FP = [симв] имя{"," имя} ":" ФормальныйПараметр.
-ФормальныйПараметр = массив[nn]Тип..
+Формальныйпараметр = "(" + Параметр..? + ")";
+Параметр = (Имя, Имя..? + ":" + Тип + ";"?)..?
 ```
 
-Тип каждого формального параметра указан в списке параметров. Для переменных он должен быть идентичен типу соответствующего фактического параметра, за исключением случаев структур, где он должен быть базовым типом соответствующего типа фактического параметра.
+Тип каждого формального параметра указан в списке параметров. Для переменных он должен быть идентичен типу соответствующего фактического параметра, за исключением случаев структур, где он должен быть минимум базовым типом соответствующего типа фактического параметра.
 
 Если формальный параметр указывает тип функции, то соответствующий фактический параметр должен быть либо объявленный глобально, либо переменной этого типа функции. Это не может быть встроенная функция. Тип результата функции может быть любым типом, но только *один*.
 
 Примеры объявлений функций:
 
 ```c
-фн Целое_Читать(симв x: `целое`){
-    симв i : целое;
-    симв ch: байт;
+фн Целое_Читать(симв x: целое) {
+    симв {
+        i : целое,
+        ch: байт,
+    }
     i = 0;
     Читать(ch);
-    пока ("0" <= ch) и (ch <= "9") {
-        i = 10*i + (ORD(ch)-ORD("0"));
+    пока (`0` <= ch) и (ch <= `9`) {
+        i = 10*i + (байт(ch)-байт(`0`));
         Читать(ch);
     }
     x = i
 }
 
-фн Целое_Писать(x: целое){ // 0 <= x < 10^5
-симв i: целое;
-симв buf: массив[5]целое;
-i = 0;
-пока i==0{
-    buf[i] = x мод 10;
-    x = x див 10;
-    i++
-    i++;
-    Записать(байт(buf[i] + ORD("0")));
+фн Целое_Писать(x: целое) { // 0 <= x < 10^5
+    симв {
+        i: целое,
+        buf: массив[5]целое,
+    }
+    i = 0;
+    петля {
+    выбор i==0{
+        провер 0: стоп,
+    }
+    buf[i] = x \ 10;
+    x = x * 10;
+    i = i + 1;
+    Записать(байт(buf[i] + байт(`0`)));
+    }
 }
 
 фн лог2(x: целое):целое{
-    симв y целое = 0; // assume x>0
-    WHILE x > 1 {
-        x = x див 2;
-        y++;
+    симв {
+        y: целое, // assume x>0
+        еслиХ: бул,
+    }
+    у = 0;
+    цикл {
+        еслиХ = х > 1;
+        выбор еслиХ {
+            провер нет: стоп,
+        }
+        x = x \ 2;
+        y = у + 1;
     }
-    вернуть y
+    вернуть y;
 }
 ```
 
@@ -899,47 +830,39 @@ 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) |
+| Имя      | Тип аргумента | Тип результата | Описание        | Англ    |
+| -------- | ------------- | -------------- | --------------- | ------- |
+| м.Длин() | v: массив     | целое          | длина массива v | v.Len() |
 
 Функции преобразования типов:
 
-| Имя | Тип аргумента | Тип результата | Функция             | Англ     |
-| --- | ------------- | -------------- | ------------------- | -------- |
-|     | вещ           | целое          | округление вниз     | FLOOR(x) |
-|     | целое         | вещ            | преобразование типа | FLT(x)   |
-|     | байт, бул     | целое          | порядковый номер x  | ORD(x)   |
+| Имя   | Тип аргумента | Тип результата | Функция             | Англ     |
+| ----- | ------------- | -------------- | ------------------- | -------- |
+| Вещ   | вещ           | целое          | округление вниз     | FLOOR(x) |
+| Целое | целое         | вещ            | преобразование типа | FLT(x)   |
+| Байт  | байт          | целое          | порядковый номер x  | ORD(x)   |
 
 Безопасные процедуры:
 
-| Имя    | Тип аргумента | Функция                        | Англ       |
-| ------ | ------------- | ------------------------------ | ---------- |
-| нов(v) | перменная     | размещение переменной в памяти | NEW(v)     |
-|        | BOOLEAN       | прервать, если ~b              | ASSERT(b)  |
-|        | вещ, целое    | упаковать x и n в x            | PACK(x, n) |
-|        | вещ, целое    | распаковать x в x и n          | UNPK(x, n) |
+| Имя   | Тип аргумента | Функция                        | Англ      |
+| ----- | ------------- | ------------------------------ | --------- |
+| ?v    | переменная    | размещение переменной в памяти | ?v        |
+| контр | BOOLEAN       | прервать, если нет             | ASSERT(b) |
 
-Функция FLOOR (x) дает наибольшее целое число, не большее x.
+Функция `Округ(x)` дает наибольшее целое число, не большее x.
 
-> FLOOR(1.5) = 1
-> FLOOR(-1.5) = -2
-
-Параметр `n` в `PACK` представляет экспоненту `x.PACK (x, y)` эквивалентен `x = x * 2y`, `UNPK` - это обратная операция. Получаемый `x` нормализуется, так что `1.0 <= x <2.0`.
+```bash
+Округ(1.5) = 1
+Округ(-1.5) = -2
+```
 
 ## 11.  Модули
 
-Модуль представляет собой набор объявлений констант, типов, переменных и функций и последовательностей предписаний с целью присвоения начальных значений переменным. Модуль обычно представляет собой текст, который можно скомпилировать как единое целое.
+Модуль представляет собой набор объявлений констант, типов, переменных и функций, списков предписаний с целью присвоения начальных значений переменным. Модуль обычно представляет собой текст, который можно скомпилировать как единое целое.
 
 ```bash
 Модуль = модуль Имя;
-    [СписокИмпорта]
-    СписокОбъявлений..? | СписокПредписаний..?;
+    СписокИмпорта..?  СписокОбъявлений..? СписокФункций..?
 {
     СписокВыражений..?;
 }
@@ -948,14 +871,14 @@ i = 0;
     ИмпортМодуля..?
 }
 
-ИмпортМодуля = Имя "=" МодульПуть;
+ИмпортМодуля = Имя + "=" + МодульПуть;
 ```
 
 В списке импорта указаны модули, для которых текущий модуль является клиентом. Если имя `x` экспортируется из модуля `M`, и если `M` указан в списке импорта модуля, тогда к `x` обращаются как `M.x`. Если в списке импорта используется форма `M1 = M`, экспортируемый объект `x`, объявленный в `M1`, ссылается в импортируемом модуле как `M1.x`.
 
-Имена, которые должны быть видны в клиентских модулях, то есть должны быть экспортированы, должны быть отмечены звездочкой (отметкой экспорта) в их объявлении. Переменные всегда экспортируются в режиме только для чтения.
+Имена, которые должны быть видны в клиентских модулях -- должны быть экспортированы (отмечены `пуб` (отметкой экспорта) в их объявлении). Переменные всегда экспортируются в режиме только для чтения.
 
-Последовательность предписаний, следующая за ключевым символом "{", выполняется, когда модуль *загружается* в систему. Последующие индивидуальные (без параметров) функции могут быть активированы из системы, и эти процедуры служат в качестве команд.
+Последовательность предписаний, следующая за ключевым символом "{", выполняется, когда модуль *загружается* в систему. Последующие индивидуальные (без параметров) функции могут быть активированы из системы, и эти функции служат в качестве команд.
 
 Пример:
 
@@ -963,8 +886,8 @@ i = 0;
 модуль Вывод; // экспортирует процедуры: Write, WriteInt, WriteLn
 
 импорт {
-    Текст,
-    Oberon,
+    Текст = `./text`,
+    Oberon = `./oberon/compiler`,
 }
 
 симв {
@@ -977,33 +900,40 @@ i = 0;
 
 фн WriteInt*(x, n: `целое`){
     симв {
-        i: целое = 0,
-        a: массив[16]BYTE,
+        i: целое,
+        a: массив[16]байт,
+        еслиХ: бул,
     }
-    если x < 0 {
-        Текст.Текст(W, "-");
-        x := -x;
+    i = 0;
+    еслиХ = i == 0;
+    выбор еслиХ {
+        провер да: {
+            Текст.Текст(W, "-");
+            x = -x;
+        },
     }
-    ПЕТЛЯ {
-        a[i] = CHR(x MOD 10 + ORD("0"));
-        x = x DIV 10;
-        i++
-        если х == 0{
-            стоп;
+    цикл {
+        еслиХ = х == 0;
+        выбор еслиХ {
+            провер да: стоп,
         }
+        a[i] = Вещ(x MOD 10 + Байт(`0`));
+        x = x \ 10;
+        i = i + 1;
     }
     Текст.Write(W, " ");
-    n--;
-    ПЕТЛЯ {
-        если n >i{
-            стоп;
+    n = n - 1;
+    еслиХ = n > 1;
+    цикл {
+        выбор еслиХ {
+            провер да: стоп,
         }
-        i--;
+        i = i - 1;
     }
     Текст.Write(W, a[i]);
 }
 
-фн WriteLn*{}
+фн WriteLn*{
     Текст.WriteLn(W);
     Текст.Append(Oberon.Log, W.buf);
 }
@@ -1017,97 +947,50 @@ i = 0;
 
 Необязательный модуль `СИСТЕМА` содержит определения, необходимые для программирования опасных операций, ссылающихся непосредственно на ресурсы, специфичные для данной аппаратуры.
 
-Импорт модуля `СИСТЕМА` может быть пустым для обозначения опасных операций.
+Импорт модуля `СИСТЕМА` может быть пустым для обозначения опасных операций или прежупреждения о неисправном коде или устервшем коде.
 
 К опасным операциям относятся, например, средства доступа к устройствам, которые контролируются аппаратурой, и, возможно, низкоуровневым средствам для нарушения правил совместимости типов данных (иначе пришлось бы такие средства языка вводить явно).
 
 В модуле `СИСТЕМА` есть две причины для упрощения процедур:
 
 - их значение зависит от реализации, то есть значение не выводится из определения языка;
-- они могут повредить систему (например, PUT). Настоятельно рекомендуется ограничить их использование конкретными низкоуровневыми модулями, поскольку такие модули по своей сути являются не переносимыми, и не «безопасными по типу». Однако они легко распознаются из-за идентификатора `СИСТЕМА`, появляющегося в списках импорта модуля.
+- они могут повредить систему (например, `Запись`). Настоятельно рекомендуется ограничить их использование конкретными низкоуровневыми модулями, поскольку такие модули по своей сути являются не переносимыми, и не «безопасными по типу». Однако они легко распознаются из-за идентификатора `СИСТЕМА`, появляющегося в списках импорта модуля.
 
 Следующие определения обычно применимы без дополнительных изменений. Однако отдельные реализации языка могут включать в свои модули дополнительные определения `СИСТЕМА`, которые относятся к конкретной, находящейся в использовании аппаратуре. В дальнейшем `v` обозначает переменную, `x`, `a` и `n` для выражений.
 
-Процедуры-функции:
-Имя
-Тип аргумента
-Тип результата
-Функция
-ADR(v)
-любой
-`целое`
-адрес переменной v
-SIZE(T)
-любой тип
-`целое`
-размер в байтах
-BIT(a, n)
-a, n: `целое`
-BOOLEAN
-n бит в mem[a]
-
-
+Функции-процедуры:
+| Имя       | Тип аргумента | Тип результата | Функция            |
+| --------- | ------------- | -------------- | ------------------ |
+| ADR(v)    | любой         | `целое`        | адрес переменной v |
+| SIZE(T)   | любой тип     | `целое`        | размер в байтах    |
+| BIT(a, n) | a, n: `целое` | BOOLEAN        | n бит в mem[a]     |
 
 Собственные процедуры:
-Имя
-Тип аргумента
-Тип результата
-Функция
-GET(a, v)
-a: `целое`;
-v: любой базовый тип
-v := mem[a]
-PUT(a, x)
-a: `целое`;
-x: любой базовый тип
-mem[a] := x
-COPY(src, dst, n)
-все
-
-`целое`
-
-копировать n последовательных 	слов из src в dst
-
+| Имя               | Тип аргумента | Тип результата       | Функция                                          |
+| ----------------- | ------------- | -------------------- | ------------------------------------------------ |
+| GET(a, v)         | a: `целое`    | v: любой базовый тип | v := mem[a]                                      |
+| PUT(a, x)         | a: `целое`    | x: любой базовый тип | mem[a] := x                                      |
+| COPY(src, dst, n) | все           | `целое`              | копировать n последовательных 	слов из src в dst |
 
 Ниже приводятся дополнительные процедуры, принятые компилятором для RISC-процессора:
 
 Процедуры-функции:
-Имя
-Тип аргумента
-Тип результата
-Функция
-VAL(T, n)
-скалярный
-T
-преобразование
-ADC(m, n)
-`целое`
-`целое`
-сложение с флагом переноса C
-SBC(m, n)
-`целое`
-`целое`
-вычитание с флагом переноса C
-UML(m, n)
-`целое`
-`целое`
-беззнаковое умножение
-COND(n)
-`целое`
-BOOLEAN
-IF Cond(n) THEN ...
-
+| Имя       | Тип аргумента | Тип результата | Функция                       |
+| --------- | ------------- | -------------- | ----------------------------- |
+| VAL(T, n) | скалярный     | T              | преобразование                |
+| ADC(m, n) | `целое`       | `целое`        | сложение с флагом переноса C  |
+| SBC(m, n) | `целое`       | `целое`        | вычитание с флагом переноса C |
+| UML(m, n) | `целое`       | `целое`        | беззнаковое умножение         |
+| COND(n)   | `целое`       | BOOLEAN        | IF Cond(n) THEN ...           |
 
 Собственные процедуры:
-Имя
-Тип аргумента
-Функция
-LED(n)
-`целое`
-отображает n на LED-экране
+| Имя    | Тип аргумента | Функция                    |
+| ------ | ------------- | -------------------------- |
+| LED(n) | `целое`       | отображает n на LED-экране |
 
+## Приложение 1: Синтаксис Оберона
 
-Приложение: Синтаксис Оберона
+```bash
 литера 	= "A" | "B" | … | "Z" | "a" | "b" | … | "z".
 цифра 	= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9".
 шестнЦифра = digit | "A" | "B" | "C" | "D" | "E" | "F".
@@ -1186,7 +1069,9 @@ DO ПоследПредписаний END.
 
 СписокИмпорта = IMPORT импорт {"," импорт } ";".
 импорт 	= имя [":=" имя].
+```
 
+## Приложение 2: Участники
 
 Использован перевод:
 
@@ -1207,7 +1092,7 @@ DO ПоследПредписаний END.
 Дополнительные материалы:
 Чек-лист создателям компилятора
 
-## Ссылки
+## Пиложение 3: Ссылки
 
 [Модели онлайн](https://models.molpit.org/)
 [Сообщение о языке Oberon-7](https://www.inf.ethz.ch/personal/wirth/Oberon/Oberon07.Report.pdf)