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

README.md

@@ -225,13 +225,14 @@ flowchart TD
 | {       | Фигурная открывающая скобка (область видимости)   |
 | }       | Закрывающая фигурная скобка (область видимости)   |
 | ВНУТРИ  | IN Определение вхождения                          |
-| МАССИВ  | ARRAY Массив элементов                            |
 | ЕСТЬ    | IS Проверка типа                                  |
-| БАЙТ    | BYTE Тип байт                                     |
+| БУЛ     | BOOL Белвый тип                                   |
 | ДА      | TRUE Булево значение                              |
 | НЕТ     | FALSE Отрицание логического значения              |
+| БАЙТ    | BYTE Тип байт                                     |
 | ЦЕЛОЕ   | INT Дробное число                                 |
 | ВЕЩ     | REAL Дробное число                                |
+| МАССИВ  | ARRAY Массив элементов                            |
 | ПРОВЕР  | SWITCH Проверка на выбор                          |
 | ТИП     | TYPE Объявление типа                              |
 | МОДУЛЬ  | MODULE Объявление начала модуля                   |
@@ -243,6 +244,7 @@ flowchart TD
 | МУТ     | MUT Признак изменяемости                          |
 | ФН      | FN Объявление функции                             |
 | ВЕРНУТЬ | RETURN Возврат из функции                         |
+| НОВ     | NEW Создать новую переменную                      |
 | ЕСЛИ    | IF Начало условия                                 |
 | ТОГДА   | THEN Действие после условия                       |
 | ИНАЧЕ   | Альтернативная ветка ЕСЛИ                         |
@@ -271,18 +273,17 @@ flowchart TD
 
 > ASR
 > ASSERT
-> BOOL
+> БУЛ
 > БАЙТ
-> CHAR
 > EXCL
 > FLT
-> INTEGER
+> `ЦЕЛОЕ`
 > LSL
-> NEW
+> НОВ
 > ODD
 > ORD
 > PACK
-> REAL
+> ВЕЩ
 > ROR
 > SET
 > UNPK
@@ -325,18 +326,18 @@ flowchart TD
 Примеры:
 
 ```bash
-type Таблица = ARRAY[255]REAL;
-type Дерево = Узел;
-type Узел {
-    ключ: INT,
+ТИП Таблица = МАССИВ[255]ВЕЩ;
+ТИП Дерево = Узел;
+ТИП Узел {
+    ключ: ЦЕЛОЕ,
     Левый, Правый: Дерево,
 }
-type ДеревоСередина = @УзелСередина;
-type УзелСередина (Узел){
-    Имя: ARRAY[32]БАЙТ,
+ТИП ДеревоСередина = @УзелСередина;
+ТИП УзелСередина (Узел){
+    Имя: МАССИВ[32]БАЙТ,
     Подузел: Дерево,
 }
-type Функция = FN (x: INT): INT;
+ТИП Функция = FN (x: ЦЕЛОЕ): ЦЕЛОЕ;
 ```
 
 ### 6.1 Встроенные линейные типы
@@ -345,13 +346,13 @@ type Функция = FN (x: INT): INT;
 
 Встроенные линейные типы:
 
-- `BOOL` -- принимает значения `TRUE` и `FALSE`
+- `БУЛ` -- принимает значения `TRUE` и `FALSE`
 - `БАЙТ` -- целые числа от 0 до 255, размер фиксированный в 8 бит
-- `INT` -- целые числа, размер зависит от реализации
-- `REAL` -- дробные числа, размер зависит от реализации
+- `ЦЕЛОЕ` -- целые числа, размер зависит от реализации
+- `ВЕЩ` -- дробные числа, размер зависит от реализации
 
-Тип `БАЙТ` совместим с типом `INT`, но наоборот требуется прведение.
-Тип `INT` совместим с типом `REAL`, но наоборот требуется прведение.
+Тип `БАЙТ` совместим с типом `ЦЕЛОЕ`, но наоборот требуется прведение.
+Тип `ЦЕЛОЕ` совместим с типом `ВЕЩ`, но наоборот требуется прведение.
 В любом случае приведение *всегда* выполняется явно.
 
 ### 6.2 Встроенные векторные типы
@@ -364,19 +365,19 @@ type Функция = FN (x: INT): INT;
 Массив - это структура, состоящая из фиксированного количества элементов, тип элементов одинаковый для всех элементов данного типа массива. Количество элементов массива называется его длиной. Элементы массива обозначаются индексами, которые являются целыми числами от 0 до (длины - 1).
 
 ```bash
-var ТипМассива = ARRAY[длина {"," длина}]тип_элемента;
-var длина = КонстантноеВыражение;
+ЗНАЧ ТипМассива = МАССИВ[длина {"," длина}]тип_элемента;
+ЗНАЧ длина = КонстантноеВыражение;
 ```
 
 Форма объявления
 
-> ARRAY[N0, N1, ..., Nk]T
+> МАССИВ[N0, N1, ..., Nk]T
 
 Примеры типов массивов:
 
 ```bash
-var listUser=ARRAY[NN]INT;
-var moments=ARRAY[10, 20]REAL;
+ЗНАЧ listUser=МАССИВ[NN]ЦЕЛОЕ;
+ЗНАЧ moments=МАССИВ[10, 20]ВЕЩ;
 ```
 
 `Литеральная строка` при создании представляет собой набор байт в виде букв в двойных кавычках. После привоения фактически -- это массив байт.
@@ -384,7 +385,7 @@ var moments=ARRAY[10, 20]REAL;
 Пример:
 
 ```bash
-var strHello="Привет";
+ЗНАЧ strHello="Привет";
 ```
 
 Все встроенные векторные типы *всегда* передаются по ссылке.
@@ -394,7 +395,7 @@ var strHello="Привет";
 Сущность `структура`, состоящая из фиксированного количества элементов возможно разных типов. Объявление типа структуры задаёт для каждого элемента, которое называется полем, его тип и имя, которое првязывает это поле. Область действия этих имён полей - само определение структуры, но они также видны как неотъемлемые части экземпляра структуры в форме "через точку", которая ссылается на элементы самого экземпляра структуры.
 
 ```bash
-ТипЗаписи = STRUCT ["(" БазовыйТип")"] [СписокПолейТипа].
+ТипЗаписи = СТРУКТ ["(" БазовыйТип")"] [СписокПолейТипа].
 БазовыйТип = квалификатор.
 СписокПолейТипа= СписокПолей{";" СписокПолей}.
 СписокПолей = СписокИмён":" тип.
@@ -406,13 +407,13 @@ var strHello="Привет";
 **Определение**. Тип T расширяет тип T0, если он является T0, или если он непосредственно расширяет расширение T0. И наоборот, тип T0 является базовым типом для типа T, если он является T, или если он является прямым базовым типом базового типа T. Примеры типов структур:
 
 ```bash
-type Year struct{
-    день, месяц, год: INT,
+ТИП Year СТРУКТ{
+    день, месяц, год: ЦЕЛОЕ,
 }
-type User struct{
-    имя, фамилия: ARRAY[32]БАЙТ,
-    возраст: INTEGER,
-    зарплата: REAL,
+ТИП User СТРУКТ{
+    имя, фамилия: МАССИВ[32]БАЙТ,
+    возраст: `ЦЕЛОЕ`,
+    зарплата: ВЕЩ,
 }
 ```
 
@@ -421,7 +422,7 @@ type User struct{
 Типы структур с точки *всегда* связываются по ссылке.
 
 ```bash
-type ТипСсылка = тип;
+ТИП ТипСсылка = тип;
 ```
 
 ### 6.5 Тип функции
@@ -441,17 +442,17 @@ type ТипСсылка = тип;
 Переменные, имена которых отображаются через запятую имеют один и тот же тип. Примеры объявления переменных (см. Примеры в главе 6):
 
 ```modula
-var i, j, k: INT;
-var x, y: REAL;
-var p, q: BOOL;
-var f: fn();
-var a: ARRAY[100]REAL;
-type text struct{
+ЗНАЧ i, j, k: ЦЕЛОЕ;
+ЗНАЧ x, y: ВЕЩ;
+ЗНАЧ p, q: БУЛ;
+ЗНАЧ f: fn();
+ЗНАЧ a: МАССИВ[100]ВЕЩ;
+ТИП text СТРУКТ{
     лит: БАЙТ,
-    счётчик: INT,
+    счётчик: ЦЕЛОЕ,
 }
-var w: ARRAY[16]text;
-var t: Дерево;
+ЗНАЧ w: МАССИВ[16]text;
+ЗНАЧ t: Дерево;
 ```
 
 ## 8. Выражения
@@ -481,10 +482,10 @@ var t: Дерево;
 Примеры обозначений (см. Примеры в главе 7):
 
 ```bash
-i              (INT)
-а[I]           (REAL)
+i              (ЦЕЛОЕ)
+а[I]           (ВЕЩ)
 w[3].ch        (БАЙТ)
-t.ключ         (INT)
+t.ключ         (ЦЕЛОЕ)
 t.левый.правый (Дерево)
 t(УзелСредний).подузел(Дерево)
 ```
@@ -521,26 +522,28 @@ t(УзелСредний).подузел(Дерево)
 
 ### 8.2.1 Логические операции
 
-| Символ | Результат             |
-| ------ | --------------------- |
-| OR     | логическая дизъюнкция |
-| AND    | логическое соединение |
-| NOT    | логическое отрицание  |
+| Символ | Результат                |
+| ------ | ------------------------ |
+| ИЛИ    | OR логическая дизъюнкция |
+| И      | И логическое соединение  |
+| НЕ     | НЕ логическое отрицание  |
 
-Эти операции применяются к операндам BOOL и дают результат BOO.
+Эти операции применяются к операндам БУЛ и дают результат BOO.
 
-> р OR q  // означает «если р, то TRUE, иначе q»
-> p AND q // обозначает «если р, то q, иначе FALSE»
-> NOT P   // означает "не p"
+> р ИЛИ q  // означает «если р, то ДА, иначе q»
+> p И q // обозначает «если р, то q, иначе НЕТ
+> НЕ P   // означает "не p"
 
 ### 8.2.2 Арифметические операции
-	Символ	Результат
-	+		сумма
-	-		разница
-	*		умножение
-	/		деление
-	DIV		целое частное
-	MOD		модуль
+
+| Символ | Результат                |
+| ------ | ------------------------ |
+| +      | сложение                 |
+| -      | вычитание                |
+| *      | умножение                |
+| /      | деление                  |
+| ДИВ    | целое частное от деления |
+| МОД    | целое модуль  от деления |
 
 Операции +, -, * и / применяются к операндам числовых типов. Оба операнда должны быть одного типа, что также определяет тип результата. При использовании в качестве унарных операций "-" обозначает инверсию знака, а "+" обозначает операцию идентичности. Операции DIV и MOD применяются только к целочисленным операндам. Пусть q = x DIV y, а r = x MOD y. Тогда множитель q и остаток r определяются уравнением
 	X = q * y + r 		0 <= r < y
@@ -567,19 +570,19 @@ t(УзелСредний).подузел(Дерево)
 	IS		проверка типа
 
 Результат операций отношения является базовым типом BOOLEAN. ОперацияОтношение упорядочения <, <=,>,> = применяется к числовым типам, CHAR и литерным массивам. Отношения = и # применимы также к типам BOOLEAN, SET, ссылкам и процедурным типам.
-x IN s    означает "x является элементом s". x должен иметь тип INTEGER и s должен быть типом SET.
+x IN s    означает "x является элементом s". x должен иметь тип `ЦЕЛОЕ` и s должен быть типом SET.
 v IS T    означает «v имеет тип T» и вызывает проверку типа. Это применимо, если
 	1. T - расширение объявленного типа T0 для v, и если
 	2. v - параметр, как переменная типа записи или v - ссылка.
 
 Предполагая, например, что T является расширением T0 и что v является ссылкой на тип T0, тогда проверка v IS T определяет, является ли фактически указанная переменная (также, а не только T0) типом T. Значение NIL IS T не определено.
 Примеры выражений (см. Примеры в главе 7):
-	1987				(INTEGER)
-	I DIV 3			(INTEGER)
+	1987				(`ЦЕЛОЕ`)
+	I DIV 3			(`ЦЕЛОЕ`)
 	~ P OR q			(BOOLEAN)
-	(I + j) * (i-j)		(INTEGER)
+	(I + j) * (i-j)		(`ЦЕЛОЕ`)
 	S - {8, 9, 13}		(SET)
-	A [i + j] * a [i-j]	(REAL)
+	A [i + j] * a [i-j]	(ВЕЩ)
 	(0 <= i) & (i <100)	(BOOLEAN)
 	T.ключ = 0			(BOOLEAN)
 	K IN {i .. j-1}		(BOOLEAN)
@@ -644,7 +647,7 @@ v IS T    означает «v имеет тип T» и вызывает про
 	END
 
 9.5 Предписание CASE
-Составное предписание CASE определяет выбор и выполнение последовательности предписаний в соответствии со значением выражения. Сначала вычисляется выражение CASE, затем выполняется последовательность предписаний, чей список меток содержит полученное значение. Если выражение CASE имеет тип INTEGER или CHAR, все метки должны быть целыми или однолитерными строками, соответственно.
+Составное предписание CASE определяет выбор и выполнение последовательности предписаний в соответствии со значением выражения. Сначала вычисляется выражение CASE, затем выполняется последовательность предписаний, чей список меток содержит полученное значение. Если выражение CASE имеет тип `ЦЕЛОЕ` или CHAR, все метки должны быть целыми или однолитерными строками, соответственно.
 Предписание_CASE= CASE выражение OF выбор{"|" выбор} END.
 выбор = [СписокМеток_CASE ":" ПоследовательностьПредписаний].
 СписокМеток_CASE = МеткиДляВыбора{"," МеткиДляВыбора}.
@@ -663,15 +666,15 @@ END
 Пример:
 TYPE
 тЗапись = RECORD
-a : INTEGER
+a : `ЦЕЛОЕ`
 END;
 
 R0 = RECORD (тЗапись)
-b: INTEGER
+b: `ЦЕЛОЕ`
 END;
 
 	R1 = RECORD (тЗапись)
-b: REAL
+b: ВЕЩ
 END;
 	 	R2 = RECORD (тЗапись)
 b: SET
@@ -680,7 +683,7 @@ END;
 	P0 = POINTER TO R0;
 		P1 = POINTER TO R1;
 	P2 = POINTER TO R2;
-VAR
+ЗНАЧ
 p: P;
 
 CASE p OF
@@ -744,7 +747,7 @@ S;
 v := v + inc
 END
 
-Типы v, beg и end должны быть INTEGER, а inc должен быть целым (константное выражение). Если шаг не указан, предполагается, что он равен 1.
+Типы v, beg и end должны быть `ЦЕЛОЕ`, а inc должен быть целым (константное выражение). Если шаг не указан, предполагается, что он равен 1.
 
 10. Объявление процедур
 Объявление процедуры состоит из заголовка процедуры и тела процедуры. Заголовок определяет имя процедуры, формальные параметры и тип результата (если таковой есть). Тело содержит объявления и предписания. Имя процедуры повторяется в конце объявления процедуры.
@@ -757,26 +760,26 @@ END
 ТелоПроцедуры = ПоследОбъявлений[BEGIN ПоследПредписаний]
 [RETURN Выражение] END.
 ПоследОбъявлений = [КОНСТ {ОбъявлениеКонстант ";"}]
-[TYPE {ОбъявлениеТипов ";"}] [VAR {ОбъявлениеПеременных ";"}]
+[TYPE {ОбъявлениеТипов ";"}] [ЗНАЧ {ОбъявлениеПеременных ";"}]
 {ОбъявлениеПроцедуры ";"}.
 
 10.1 Формальные параметры
 Формальные параметры (или просто параметры) -- это имена, которые обозначают фактические параметры (аргументы), указанные в вызове процедуры. Соответствие между аргументами и параметрами устанавливается при вызове процедуры. Существует два типа параметров, а именно переменные и значения. Переменная соответствует фактическому параметру, который является переменной, и она обозначает эту переменную. Значение соответствует фактическому параметру, который является выражением, и он обозначает его значение, которое невозможно изменить при передаче. Однако, если значение имеет базовый тип, он представляет собой локальную переменную, которой первоначально присваивается значение фактического выражения.
-Тип параметра указывается в списке формальных параметров: переменные обозначаются ключевым словом VAR, а  значения не имеют такого префикса.
+Тип параметра указывается в списке формальных параметров: переменные обозначаются ключевым словом ЗНАЧ, а  значения не имеют такого префикса.
 Функция-процедура без параметров должна иметь пустой список параметров. Она должна быть вызвана через имя функции, список фактических параметров которой также пуст.
 Формальные параметры являются локальными для процедуры, т. е. их область действия - это текст программы, который представляет собой объявление процедуры.
 Формальныйпараметр = "(" [Секция_FP {";" Секция_FP}] ")" [":" квалификатор].
-Секция_FP = [VAR] имя{"," имя} ":" ФормальныйПараметр.
-ФормальныйПараметр = {ARRAY OF} квалификатор.
+Секция_FP = [ЗНАЧ] имя{"," имя} ":" ФормальныйПараметр.
+ФормальныйПараметр = {МАССИВ OF} квалификатор.
 Тип каждого формального параметра указан в списке параметров. Для переменных он должен быть идентичен типу соответствующего фактического параметра, за исключением случаев записи, где он должен быть базовым типом соответствующего типа фактического параметра.
 Если тип формального параметра указан как
-ARRAY OF T
+МАССИВ OF T
 параметр называется открытым массивом, а соответствующий фактический параметр может быть произвольной длины.
 Если формальный параметр указывает тип процедуры, то соответствующий фактический параметр должен быть либо объявленный глобально, либо переменной (или значением) этого типа процедуры. Это не может быть встроенная процедура. Тип результата процедуры не может быть ни записью, ни массивом.
 Примеры объявлений процедур:
-PROCEDURE Целое_Читать(VAR x: INTEGER);
-VAR
-i : INTEGER;
+PROCEDURE Целое_Читать(ЗНАЧ x: `ЦЕЛОЕ`);
+ЗНАЧ
+i : `ЦЕЛОЕ`;
 ch: CHAR;
 BEGIN
 i := 0; Read(ch);
@@ -786,10 +789,10 @@ Read(ch)
 END;
 x := i
 END Целое_Читать
-PROCEDURE Целое_Писать(x: INTEGER); (* 0 <= x < 10^5 *)
-VAR
-i: INTEGER;
-buf: ARRAY 5 OF INTEGER;
+PROCEDURE Целое_Писать(x: `ЦЕЛОЕ`); (* 0 <= x < 10^5 *)
+ЗНАЧ
+i: `ЦЕЛОЕ`;
+buf: МАССИВ 5 OF `ЦЕЛОЕ`;
 BEGIN
 i := 0;
 REPEAT
@@ -803,9 +806,9 @@ Write(CHR(buf[i] + ORD("0")))
 UNTIL i = 0
 END Целое_Писать
 
-PROCEDURE log2(x: INTEGER): INTEGER;
-VAR
-y: INTEGER; (*assume x>0*)
+PROCEDURE log2(x: `ЦЕЛОЕ`): `ЦЕЛОЕ`;
+ЗНАЧ
+y: `ЦЕЛОЕ`; (*assume x>0*)
 BEGIN
 y := 0;
 WHILE x > 1 DO
@@ -827,26 +830,26 @@ x: числовой тип
 соответствует типу x
 абсолютное значение числа
 ODD(x)
-x: INTEGER
+x: `ЦЕЛОЕ`
 BOOLEAN
 x MOD 2 = 1
 LEN(v)
-v: ARRAY
-INTEGER
+v: МАССИВ
+`ЦЕЛОЕ`
 длина v
 LSL(x, n)
-x, n: INTEGER
-INTEGER
+x, n: `ЦЕЛОЕ`
+`ЦЕЛОЕ`
 логический сдвиг влево,
 x * 2n
 ASR(x, n)
-x, n: INTEGER
-INTEGER
+x, n: `ЦЕЛОЕ`
+`ЦЕЛОЕ`
 знаковый сдвиг вправо,
 x DIV 2n
 ROR(x, n)
-x, n: INTEGER
-INTEGER
+x, n: `ЦЕЛОЕ`
+`ЦЕЛОЕ`
 x сдвигается вправо 	на n бит
 
 
@@ -857,19 +860,19 @@ x сдвигается вправо 	на n бит
 Тип результата
 Функция
 FLOOR(x)
-REAL
-INTEGER
+ВЕЩ
+`ЦЕЛОЕ`
 округление вниз
 FLT(x)
-INTEGER
-REAL
+`ЦЕЛОЕ`
+ВЕЩ
 преобразование типа
 ORD(x)
 CHAR, BOOLEAN, SET
-INTEGER
+`ЦЕЛОЕ`
 порядковый номер x
 CHR(x)
-INTEGER
+`ЦЕЛОЕ`
 CHAR
 литера по порядковому номеру x
 
@@ -879,34 +882,34 @@ CHAR
 Тип аргумента
 Функция
 INC(v)
-INTEGER
+`ЦЕЛОЕ`
 v := v + 1
 INC(v, n)
-INTEGER
+`ЦЕЛОЕ`
 v := v + n
 DEC(v)
-INTEGER
+`ЦЕЛОЕ`
 v := v - 1
 DEC(v, n)
-INTEGER
+`ЦЕЛОЕ`
 v := v - n
 INCL(v, x)
-v: SET; x: INTEGER
+v: SET; x: `ЦЕЛОЕ`
 v := v + {x}
 EXCL(v, x)
-v: SET; x: INTEGER
+v: SET; x: `ЦЕЛОЕ`
 v := v - {x}
-NEW(v)
+НОВ(v)
 тип ссылки
 размещение v^
 ASSERT(b)
 BOOLEAN
 прервать, если ~b
 PACK(x, n)
-REAL; INTEGER
+ВЕЩ; `ЦЕЛОЕ`
 упаковать x и n в x
 UNPK(x, n)
-REAL; INTEGER
+ВЕЩ; `ЦЕЛОЕ`
 распаковать x в x и n
 
 
@@ -930,16 +933,16 @@ UNPK - это обратная операция. Получаемый x норм
 MODULE Вывод; (*экспортирует процедуры: Write, WriteInt, WriteLn*)
 IMPORT Текст,
 Oberon;
-VAR
+ЗНАЧ
 W: Текст.Writer;
 PROCEDURE Write*(ch: CHAR);
 	BEGIN
 Текст.Write(W, ch)
 	END ;
-PROCEDURE WriteInt*(x, n: INTEGER);
-VAR
-i: INTEGER;
-a: ARRAY 16 OF CHAR;
+PROCEDURE WriteInt*(x, n: `ЦЕЛОЕ`);
+ЗНАЧ
+i: `ЦЕЛОЕ`;
+a: МАССИВ 16 OF CHAR;
 BEGIN
 i := 0;
 IF x < 0 THEN
@@ -986,14 +989,14 @@ END Out.
 Функция
 ADR(v)
 любой
-INTEGER
+`ЦЕЛОЕ`
 адрес переменной v
 SIZE(T)
 любой тип
-INTEGER
+`ЦЕЛОЕ`
 размер в байтах
 BIT(a, n)
-a, n: INTEGER
+a, n: `ЦЕЛОЕ`
 BOOLEAN
 n бит в mem[a]
 
@@ -1005,17 +1008,17 @@ n бит в mem[a]
 Тип результата
 Функция
 GET(a, v)
-a: INTEGER;
+a: `ЦЕЛОЕ`;
 v: любой базовый тип
 v := mem[a]
 PUT(a, x)
-a: INTEGER;
+a: `ЦЕЛОЕ`;
 x: любой базовый тип
 mem[a] := x
 COPY(src, dst, n)
 все
 
-INTEGER
+`ЦЕЛОЕ`
 
 копировать n последовательных 	слов из src в dst
 
@@ -1032,19 +1035,19 @@ VAL(T, n)
 T
 преобразование
 ADC(m, n)
-INTEGER
-INTEGER
+`ЦЕЛОЕ`
+`ЦЕЛОЕ`
 сложение с флагом переноса C
 SBC(m, n)
-INTEGER
-INTEGER
+`ЦЕЛОЕ`
+`ЦЕЛОЕ`
 вычитание с флагом переноса C
 UML(m, n)
-INTEGER
-INTEGER
+`ЦЕЛОЕ`
+`ЦЕЛОЕ`
 беззнаковое умножение
 COND(n)
-INTEGER
+`ЦЕЛОЕ`
 BOOLEAN
 IF Cond(n) THEN ...
 
@@ -1054,7 +1057,7 @@ IF Cond(n) THEN ...
 Тип аргумента
 Функция
 LED(n)
-INTEGER
+`ЦЕЛОЕ`
 отображает n на LED-экране
 
 
@@ -1074,7 +1077,7 @@ INTEGER
 КонстВыражение = выражение.
 ОпрТипа 	= ОпрИмени "=" тип.
 тип 		= квалификатор| ТипМассива | ТипЗаписи | ТипСсылка | ТипПроцедуры.
-ТипМассива = ARRAY длина {"," длина} OF тип.
+ТипМассива = МАССИВ длина {"," длина} OF тип.
 длина 	= КонстВыражение .
 ТипЗаписи 	= RECORD ["(" БазовыйТип ")"] [ПоследСписокПолей] END.
 БазовыйТип = квалификатор.
@@ -1126,11 +1129,11 @@ DO ПоследПредписаний END.
 
 ПоследОпределений = [КОНСТ {ОпрКонстант ";"}]
 [TYPE {ОпрТипа ";"}]
-[VAR {ОпрПеременной ";"}]
+[ЗНАЧ {ОпрПеременной ";"}]
 {ОпрПроцедуры ";"}.
 ФормальныеПараметры = "(" [Секция_FP {";" Секция_FP}] ")" [":" квалификатор].
-Секция_FP 	= [VAR] имя {"," имя } ":" ФормальныйТип.
-ФормальныйТип = {ARRAY OF} квалификатор.
+Секция_FP 	= [ЗНАЧ] имя {"," имя } ":" ФормальныйТип.
+ФормальныйТип = {МАССИВ OF} квалификатор.
 
 модуль	= MODULE имя ";" [СписокИмпорта] ПоследОпределений
 [BEGIN ПоследПредписаний ] END имя "."