|
|
@@ -29,15 +29,22 @@
|
|
|
- [8. Выражения](#8-выражения)
|
|
|
- [8.1 Операнды](#81-операнды)
|
|
|
- [8.2 Операторы](#82-операторы)
|
|
|
- - [8.2.1 Логические операции](#821-логические-операции)
|
|
|
- - [8.2.2 Арифметические операторы](#822-арифметические-операторы)
|
|
|
- - [8.2.3 Отношения](#823-отношения)
|
|
|
+ - [8.2.1 Логические операции](#821-логические-операции)
|
|
|
+ - [8.2.2 Арифметические операторы](#822-арифметические-операторы)
|
|
|
+ - [8.2.3 Отношения](#823-отношения)
|
|
|
- [9. Предписания](#9-предписания)
|
|
|
- [9.1 Предписание ПРИСВОЕНИЕ](#91-предписание-присвоение)
|
|
|
- - [9.2 Предписание ВЫЗОВ\_ФУНКЦИИ](#92-предписание-вызов_функции)
|
|
|
- - [9.3 Последовательность предписаний](#93-последовательность-предписаний)
|
|
|
- - [9.4 Предписание\_ЕСЛИ](#94-предписание_если)
|
|
|
- - [9.5 Предписание ВЫБОР](#95-предписание-выбор)
|
|
|
+ - [](#)
|
|
|
+ - [9.3 Последовательность предписаний](#93-последовательность-предписаний)
|
|
|
+ - [9.4 Предписание\_ЕСЛИ](#94-предписание_если)
|
|
|
+ - [9.5 Предписание\_ВЫБОР](#95-предписание_выбор)
|
|
|
+ - [9.6 Предписание ПОКА](#96-предписание-пока)
|
|
|
+ - [9.7 Предписание ДЛЯ](#97-предписание-для)
|
|
|
+ - [10. Объявление функций](#10--объявление-функций)
|
|
|
+ - [10.1 Формальные параметры](#101-формальные-параметры)
|
|
|
+ - [10.2. Встроенные функции](#102-встроенные-функции)
|
|
|
+ - [11. Модули](#11--модули)
|
|
|
+ - [11.1 Модуль SYSTEM](#111-модуль-system)
|
|
|
- [Ссылки](#ссылки)
|
|
|
|
|
|
## 0. Введение
|
|
|
@@ -190,78 +197,80 @@ flowchart TD
|
|
|
|
|
|
Ниже перечислен полный список `ключевых символов`
|
|
|
|
|
|
-| Символ | Комментарий |
|
|
|
-| ------- | ------------------------------------------------- |
|
|
|
-| + | Сложение |
|
|
|
-| ++ | Инкремент операнда |
|
|
|
-| += | Сложение операндов с присвоением операнду слева |
|
|
|
-| = | Присвоение |
|
|
|
-| - | Минус |
|
|
|
-| -- | Декремент |
|
|
|
-| -= | Вычитание операндов, с присвоением операнду слева |
|
|
|
-| ^ | Исключающее ИЛИ |
|
|
|
-| ^= | Исключающее ИЛИ с присвоением операнды слева |
|
|
|
-| * | Умножение |
|
|
|
-| ** | Возведение в степень |
|
|
|
-| **= | Возведение в степень с присвоением операнда слева |
|
|
|
-| / | Деление |
|
|
|
-| /= | Деление с присвоением операнду слева |
|
|
|
-| ~ | Отрицание |
|
|
|
-| < | Меньше |
|
|
|
-| > | Больше |
|
|
|
-| & | Логическое И |
|
|
|
-| &= | Логическое И с присвоением операнду слева |
|
|
|
-| = | Присвоить |
|
|
|
-| // | Линейный комментарий |
|
|
|
-| /* | Начало многострочного комментария |
|
|
|
-| */ | Конец многострочного комментария |
|
|
|
-| (* | Начало многострочного комментария |
|
|
|
-| *) | Конец многострочного комментария |
|
|
|
-| . | Точка |
|
|
|
-| <= | Меньше или равно |
|
|
|
-| , | Запятая |
|
|
|
-| >= | Больше или равно |
|
|
|
-| ; | Точка с запятой |
|
|
|
-| ... | Перечисление |
|
|
|
-| \| | Логическое ИЛИ |
|
|
|
-| : | Определить тип переменной |
|
|
|
-| ( | Открывающая круглая скобка (выражение) |
|
|
|
-| ) | Закрывающая круглая скобка (выражение) |
|
|
|
-| [ | Открывающая квадратная скобка (массив) |
|
|
|
-| ] | Закрывающая квадратная скобка (массив) |
|
|
|
-| { | Фигурная открывающая скобка (область видимости) |
|
|
|
-| } | Закрывающая фигурная скобка (область видимости) |
|
|
|
-| ЕСТЬ | IS Проверка типа |
|
|
|
-| БУЛ | BOOL Белвый тип |
|
|
|
-| ДА | TRUE Булево значение |
|
|
|
-| НЕТ | FALSE Отрицание логического значения |
|
|
|
-| БАЙТ | BYTE Тип байт |
|
|
|
-| ЦЕЛОЕ | INT Дробное число |
|
|
|
-| ВЕЩ | REAL Дробное число |
|
|
|
-| МАССИВ | ARRAY Массив элементов |
|
|
|
-| ПРОВЕР | SWITCH Проверка на выбор |
|
|
|
-| ТИП | TYPE Объявление типа |
|
|
|
-| МОДУЛЬ | MODULE Объявление начала модуля |
|
|
|
-| ИМПОРТ | IMPORT Импорт модуля |
|
|
|
-| КОНСТ | CONST Объявление константы |
|
|
|
-| ТИП | TYPE Определение типа |
|
|
|
-| СТРУКТ | STRUCT Объявление структуры |
|
|
|
-| ЗНАЧ | VAR Объявление переменной |
|
|
|
-| МУТ | MUT Признак изменяемости |
|
|
|
-| ФН | FN Объявление функции |
|
|
|
-| ВЕРНУТЬ | RETURN Возврат из функции |
|
|
|
-| НОВ | NEW Создать новую переменную |
|
|
|
-| ЕСЛИ | IF Начало условия |
|
|
|
-| ТОГДА | THEN Действие после условия |
|
|
|
-| ИНАЧЕ | Альтернативная ветка ЕСЛИ |
|
|
|
-| МОД | MOD Модуль от целочисленного деления |
|
|
|
-| ДИВ | DIV Остаток от целочисленного деления |
|
|
|
-| НИЧ | NIL Пустое состояние объекта |
|
|
|
-| ПОКА | WHILE Условие проверки продолжения цикла на входе |
|
|
|
-| ПОКА | UNTIL Условие продолжения цикла на выходе |
|
|
|
-| ИЛИ | OR Логическое ИЛИ |
|
|
|
-| ПОВТОР | REPEAT Повторить выполнение |
|
|
|
-| ДЛЯ | FOR Объявление цикла |
|
|
|
+| Символ | Комментарий |
|
|
|
+| -------- | ---------------------------------------------------- |
|
|
|
+| + | Сложение |
|
|
|
+| ++ | Инкремент операнда |
|
|
|
+| += | Сложение операндов с присвоением операнду слева |
|
|
|
+| = | Присвоение |
|
|
|
+| - | Минус |
|
|
|
+| -- | Декремент |
|
|
|
+| -= | Вычитание операндов, с присвоением операнду слева |
|
|
|
+| ^ | Исключающее ИЛИ |
|
|
|
+| ^= | Исключающее ИЛИ с присвоением операнды слева |
|
|
|
+| * | Умножение |
|
|
|
+| ** | Возведение в степень |
|
|
|
+| **= | Возведение в степень с присвоением операнда слева |
|
|
|
+| / | Деление |
|
|
|
+| /= | Деление с присвоением операнду слева |
|
|
|
+| ~ | Отрицание |
|
|
|
+| < | Меньше |
|
|
|
+| > | Больше |
|
|
|
+| & | Логическое И |
|
|
|
+| &= | Логическое И с присвоением операнду слева |
|
|
|
+| = | Присвоить |
|
|
|
+| // | Линейный комментарий |
|
|
|
+| /* | Начало многострочного комментария |
|
|
|
+| */ | Конец многострочного комментария |
|
|
|
+| (* | Начало многострочного комментария |
|
|
|
+| *) | Конец многострочного комментария |
|
|
|
+| . | Точка |
|
|
|
+| <= | Меньше или равно |
|
|
|
+| , | Запятая |
|
|
|
+| >= | Больше или равно |
|
|
|
+| ; | Точка с запятой |
|
|
|
+| ... | Перечисление |
|
|
|
+| \| | Логическое ИЛИ |
|
|
|
+| : | Определить тип переменной |
|
|
|
+| ( | Открывающая круглая скобка (выражение) |
|
|
|
+| ) | Закрывающая круглая скобка (выражение) |
|
|
|
+| [ | Открывающая квадратная скобка (массив) |
|
|
|
+| ] | Закрывающая квадратная скобка (массив) |
|
|
|
+| { | Фигурная открывающая скобка (область видимости) |
|
|
|
+| } | Закрывающая фигурная скобка (область видимости) |
|
|
|
+| ЕСТЬ | IS Проверка типа |
|
|
|
+| БУЛ | BOOL Белвый тип |
|
|
|
+| ДА | TRUE Булево значение |
|
|
|
+| НЕТ | FALSE Отрицание логического значения |
|
|
|
+| БАЙТ | BYTE Тип байт |
|
|
|
+| ЦЕЛОЕ | INT Дробное число |
|
|
|
+| ВЕЩ | REAL Дробное число |
|
|
|
+| МАССИВ | ARRAY Массив элементов |
|
|
|
+| ПРОВЕР | SWITCH Проверка на выбор |
|
|
|
+| ТИП | TYPE Объявление типа |
|
|
|
+| МОДУЛЬ | MODULE Объявление начала модуля |
|
|
|
+| ИМПОРТ | IMPORT Импорт модуля |
|
|
|
+| КОНСТ | CONST Объявление константы |
|
|
|
+| ТИП | TYPE Определение типа |
|
|
|
+| СТРУКТ | STRUCT Объявление структуры |
|
|
|
+| ЗНАЧ | VAR Объявление переменной |
|
|
|
+| МУТ | MUT Признак изменяемости |
|
|
|
+| ФН | FN Объявление функции |
|
|
|
+| ВЕРНУТЬ | RETURN Возврат из функции |
|
|
|
+| НОВ | NEW Создать новую переменную |
|
|
|
+| ЕСЛИ | IF Начало условия |
|
|
|
+| АЕСЛИ | IF Альтернативноее, если предыдущее не сработало |
|
|
|
+| МОД | MOD Модуль от целочисленного деления |
|
|
|
+| ДИВ | DIV Остаток от целочисленного деления |
|
|
|
+| НИЧ | NIL Пустое состояние объекта |
|
|
|
+| ПОКА | WHILE Условие проверки продолжения цикла на входе |
|
|
|
+| ПЕТЛЯ | LOOP Бесконечный цикл |
|
|
|
+| ДАЛЬШЕ | NEXT Продолжить цикл с пропуском следующих выражений |
|
|
|
+| ПРЕРВАТЬ | BREAK Прервать цикл с пропуском следующих выражений |
|
|
|
+| ИЛИ | OR Логическое ИЛИ |
|
|
|
+| И | AND Логическое И |
|
|
|
+| НЕ | NOT Логическая инверсия |
|
|
|
+| ДЛЯ | FOR Объявление цикла |
|
|
|
|
|
|
## 4. Объявления имён и область видимости
|
|
|
|
|
|
@@ -526,7 +535,7 @@ t(УзелСредний).подузел(Дерево)
|
|
|
|
|
|
Множество [m..n] обозначает [m, m + 1, ..., n-1, n], а если m>n, то пустое множество. Доступные операции перечислены в следующих таблицах. В некоторых случаях несколько разных операций обозначаются одним и тем же символом операции. В этих случаях фактическая операция определяется типом операндов.
|
|
|
|
|
|
-### 8.2.1 Логические операции
|
|
|
+#### 8.2.1 Логические операции
|
|
|
|
|
|
| Символ | Результат |
|
|
|
| ------ | ------------------------ |
|
|
|
@@ -540,7 +549,7 @@ t(УзелСредний).подузел(Дерево)
|
|
|
> p И q // обозначает «если р, то q, иначе НЕТ
|
|
|
> НЕ P // означает "не p"
|
|
|
|
|
|
-### 8.2.2 Арифметические операторы
|
|
|
+#### 8.2.2 Арифметические операторы
|
|
|
|
|
|
| Символ | Результат |
|
|
|
| ------ | ------------------------ |
|
|
|
@@ -561,7 +570,7 @@ t(УзелСредний).подузел(Дерево)
|
|
|
> x = q * y + r
|
|
|
> 0 <= r < y
|
|
|
|
|
|
-### 8.2.3 Отношения
|
|
|
+#### 8.2.3 Отношения
|
|
|
|
|
|
| Символ | Результат |
|
|
|
| ------ | ---------------- |
|
|
|
@@ -597,11 +606,13 @@ T ЕСТЬ УзелСредний (`БУЛ`)
|
|
|
|
|
|
## 9. Предписания
|
|
|
|
|
|
-Предписания обозначают *языковые действия*. Есть простые и сложные предписания. Простые предписания не состоят из каких-либо частей, которые сами являлись бы предписаниями. Простые предписания -- просто присваивания, либо вызов процедур.
|
|
|
+Предписания обозначают *языковые действия*. Есть простые и составные предписания. Простые предписания не состоят из каких-либо частей, которые сами являлись бы предписаниями. Простые предписания -- просто присваивания, либо вызов процедур.
|
|
|
|
|
|
-Сложные предписания состоят из частей, которые сами являются предписаниями. Они используются, чтобы выразить последовательное и условное, выборочное и повторное действие. Предписания также могут быть пустыми, и в этом случае они не обозначают никаких действий. Пустое предписание включено в язык для того, чтобы ослабить правила пунктуации в последовательностях предписаний.
|
|
|
+Составные предписания состоят из частей, которые сами являются предписаниями. Они используются, чтобы выразить последовательное и условное, выборочное и повторное действие.
|
|
|
|
|
|
-> Предписание = [Присвоение | ВызовПроцедур | Предписание_ЕСЛИ | Предписание_ВЫБОР | Предписание_ПОКА | Предписание_ПОВТОРЯТЬ | Предписание_ДЛЯ].
|
|
|
+Предписания также могут быть пустыми, и в этом случае они не обозначают никаких действий. Пустое предписание включено в язык для того, чтобы ослабить правила пунктуации в последовательностях предписаний.
|
|
|
+
|
|
|
+> Предписание = [Присвоение | ВызовПроцедур | Предписание_ЕСЛИ | Предписание_ВЫБОР | Предписание_ПОКА | Предписание_ДЛЯ].
|
|
|
|
|
|
### 9.1 Предписание ПРИСВОЕНИЕ
|
|
|
|
|
|
@@ -632,29 +643,14 @@ t.key = i
|
|
|
w[i+1].ch = "A"
|
|
|
```
|
|
|
|
|
|
-## 9.2 Предписание ВЫЗОВ_ФУНКЦИИ
|
|
|
-
|
|
|
-Простое предписание ВЫЗОВ_ФУНКЦИИ служит для исполнения функции. Функция может содержать список фактических параметров (аргументов), которые заменяются вместо соответствующих формальных параметров (параметров), заданных в объявлении функции (см. Главу 10). Соответствие устанавливается порядком параметров в списках аргументов и параметров соответственно.
|
|
|
-
|
|
|
-Параметр ссылается на элемент структурной переменной в любой момент выполнением процедуры. Если переменная является выражением, то выражение вычисляется до вызова функции, и результирующее значение присваивается аргументу, который теперь представляет собой локальную переменную относительно вызываемой функции(см. Также 10.1.).
|
|
|
-
|
|
|
-> ВЫЗОВ_ФУНКЦИИ = Переменная [Актуальные_Параметры].
|
|
|
-
|
|
|
-Примеры вызова фнкций:
|
|
|
-
|
|
|
-```с
|
|
|
-Целое_Читать(i) // (см. Главу 10)
|
|
|
-Целое_Записать(2*j + 1, 6)
|
|
|
-w[k].count++
|
|
|
-```
|
|
|
-
|
|
|
-## 9.3 Последовательность предписаний
|
|
|
+####
|
|
|
+### 9.3 Последовательность предписаний
|
|
|
|
|
|
Последовательности предписаний обозначают последовательность действий, заданную частями операторов, разделенными точкой с запятой.
|
|
|
|
|
|
> Последовательность_Предписаний = Предписание{";" Предписание}.
|
|
|
|
|
|
-## 9.4 Предписание_ЕСЛИ
|
|
|
+### 9.4 Предписание_ЕСЛИ
|
|
|
|
|
|
```bash
|
|
|
Предписание_ЕСЛИ = ЕСЛИ Выражение ТОГДА{
|
|
|
@@ -676,336 +672,326 @@ w[k].count++
|
|
|
};
|
|
|
```
|
|
|
|
|
|
-## 9.5 Предписание ВЫБОР
|
|
|
+### 9.5 Предписание_ВЫБОР
|
|
|
|
|
|
-Составное предписание `ВЫБОР` определяет выбор и выполнение последовательности предписаний в соответствии со значением выражения. Сначала вычисляется выражение `ВЫБОР`, затем выполняется последовательность предписаний, чей список меток содержит полученное значение. Если выражение CASE имеет тип `ЦЕЛОЕ` или CHAR, все метки должны быть целыми или однолитерными строками, соответственно.
|
|
|
-Предписание_CASE= CASE выражение OF выбор{"|" выбор} END.
|
|
|
-выбор = [СписокМеток_CASE ":" ПоследовательностьПредписаний].
|
|
|
-СписокМеток_CASE = МеткиДляВыбора{"," МеткиДляВыбора}.
|
|
|
+Составное предписание `ВЫБОР` определяет выбор и выполнение последовательности предписаний в соответствии со значением выражения. Сначала вычисляется выражение `ВЫБОР`, затем выполняется последовательность предписаний, чей список меток содержит полученное значение. Если выражение `ВЫБОР` имеет тип `ЦЕЛОЕ` или `БАЙТ`, все метки должны быть целыми или байтами, соответственно.
|
|
|
+```bash
|
|
|
+Предписание_ВЫБОР= ВЫБОР выражение {выбор..}.
|
|
|
+выбор = [СписокМеток_ВЫБОР ":" ПоследовательностьПредписаний].
|
|
|
+СписокМеток_ВЫБОР = МеткиДляВыбора["," МеткиДляВыбора].
|
|
|
МеткиДляВыбора = Метка[".." Метка].
|
|
|
Метка = целое | строка | квалификатор.
|
|
|
+```
|
|
|
|
|
|
Пример:
|
|
|
-CASE k OF
|
|
|
-0: x := x + y
|
|
|
-| 1: x := x − y
|
|
|
-| 2: x := x * y
|
|
|
-| 3: x := x / y
|
|
|
-END
|
|
|
-
|
|
|
-Тип T выражения CASE (CASE переменная) также может быть типом записи или ссылки. Тогда метки CASE должны быть расширениями Т, а в предписаниях Si, помеченных Ti, переменная Case рассматривается как тип Ti.
|
|
|
+```c
|
|
|
+ВЫБОР k {
|
|
|
+ | 0: x = x + y
|
|
|
+ | 1: x = x − y
|
|
|
+ | 2: x = x * y
|
|
|
+ | 3: x = x / y
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+Тип `T` выражения `ВЫБОР` (переменная после ключевого символа `ВЫБОР`) также может быть типом структуры. Тогда метки для `ВЫБОР` должны быть расширениями `Т`, а в предписаниях `Si`, помеченных `Ti`, переменная `ВЫБОР` рассматривается как тип `Ti`.
|
|
|
+
|
|
|
Пример:
|
|
|
-TYPE
|
|
|
-тЗапись = RECORD
|
|
|
-a : `ЦЕЛОЕ`
|
|
|
-END;
|
|
|
-
|
|
|
-R0 = RECORD (тЗапись)
|
|
|
-b: `ЦЕЛОЕ`
|
|
|
-END;
|
|
|
-
|
|
|
- R1 = RECORD (тЗапись)
|
|
|
-b: ВЕЩ
|
|
|
-END;
|
|
|
- R2 = RECORD (тЗапись)
|
|
|
-b: SET
|
|
|
-END;
|
|
|
- P = POINTER TO тЗапись;
|
|
|
- P0 = POINTER TO R0;
|
|
|
- P1 = POINTER TO R1;
|
|
|
- P2 = POINTER TO R2;
|
|
|
-ЗНАЧ
|
|
|
-p: P;
|
|
|
-
|
|
|
-CASE p OF
|
|
|
-P0: p.b := 10 |
|
|
|
-| P1: p.b := 2.5 |
|
|
|
-| P2: p.b := {0, 2}
|
|
|
-END
|
|
|
-
|
|
|
-
|
|
|
-9.6 Предписание WHILE
|
|
|
-Составное предписание WHILE определяет повторение. Если любое из булевых выражений (охрана) дает TRUE, выполняется соответствующая последовательность предписаний. Вычисление выражения и выполнение предписаний повторяются до тех пор, пока ни одно из булевых выражений не даст TRUE.
|
|
|
-Предписание_WHILE = WHILE Выражение DO
|
|
|
+
|
|
|
+```c
|
|
|
+ТИП СвязьЦел СТРУКТ{
|
|
|
+ a : ЦЕЛОЕ
|
|
|
+}
|
|
|
+
|
|
|
+р0 := СвязьЦел{
|
|
|
+ а:5,
|
|
|
+}
|
|
|
+
|
|
|
+ТИП СвязьВещ СТРУКТ{
|
|
|
+ а:ВЕЩ
|
|
|
+}
|
|
|
+
|
|
|
+р1 := СвязьВещ{
|
|
|
+ а:6.1,
|
|
|
+}
|
|
|
+
|
|
|
+P := тЗапись{};
|
|
|
+P0 = R0;
|
|
|
+P1 = R1;
|
|
|
+P2 = R2;
|
|
|
+
|
|
|
+ВЫБОР p {
|
|
|
+ | P0: p.а = 10
|
|
|
+ | P1: p.а = 2.5
|
|
|
+ | P2: p.а = 0, 2
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+### 9.6 Предписание ПОКА
|
|
|
+
|
|
|
+Составное предписание `ПОКА` определяет повторение. Если любое из булевых выражений (охрана) дает `ДА`, выполняется соответствующая последовательность предписаний. Вычисление выражения и выполнение предписаний повторяются до тех пор, пока в итоге булевы выражения охрыны не дадут `НЕТ`.
|
|
|
+
|
|
|
+```bash
|
|
|
+Предписание_ПОКА = ПОКА Выражение {}
|
|
|
ПоследовательностьПредписаний
|
|
|
-{ELSIF Выражение DO
|
|
|
-ПоследовательностьПредписаний}
|
|
|
-END.
|
|
|
+АЕСЛИ Выражение {
|
|
|
+ ПоследовательностьПредписаний
|
|
|
+}
|
|
|
+```
|
|
|
|
|
|
Пример:
|
|
|
-WHILE j > 0 DO
|
|
|
-j := j DIV 2;
|
|
|
-i := i+1
|
|
|
-END
|
|
|
-WHILE (t # NIL) & (t.key # i) DO
|
|
|
-t := t.left
|
|
|
-END
|
|
|
-WHILE m > n DO
|
|
|
-m := m – n
|
|
|
-ELSIF n > m DO
|
|
|
-n := n – m
|
|
|
-END
|
|
|
-
|
|
|
-9.7 Предписание REPEAT
|
|
|
-Составное предписание REPEAT указывает повторное выполнение последовательности предписаний до тех пор, пока условие не будет выполнено. Последовательность предписаний выполняется хотя бы один раз.
|
|
|
-Предписание_Repeat = REPEAT
|
|
|
-ПоследовательностьПредписаний
|
|
|
-UNTIL Выражение.
|
|
|
|
|
|
-9.8 Предписание FOR
|
|
|
-Составное предписание FOR указывает повторное выполнение последовательности предписаний заданное количество раз, одновременно последовательно увеличивая значение переменной, которая называется управляющая переменная для предписания FOR.
|
|
|
-Предписание_For =
|
|
|
-FOR Имя ":=" Выражение TO Выражение[BY КонстантаВаражения] DO
|
|
|
-ПоследовательностьПредписаний
|
|
|
-END.
|
|
|
+```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 Предписание ДЛЯ
|
|
|
+
|
|
|
+Составное предписание `ДЛЯ` указывает повторное выполнение последовательности предписаний заданное количество раз, одновременно последовательно увеличивая значение переменной, которая называется управляющая переменная для предписания FOR.
|
|
|
+```bash
|
|
|
+Предписание_ДЛЯ =
|
|
|
+ДЛЯ Имя ":=" Выражение ДО Выражение[ПО КонстантаВаражения]{
|
|
|
+ ПоследовательностьПредписаний
|
|
|
+}
|
|
|
+```
|
|
|
|
|
|
-Предписание FOR
|
|
|
-FOR v := beg TO end BYinc DO
|
|
|
-S
|
|
|
-END
|
|
|
+Предписание `ДЛЯ`
|
|
|
+> ДЛЯ v := beg ДО end ПО inc {
|
|
|
+> S
|
|
|
+> }
|
|
|
|
|
|
есть, если inc>0, что эквивалентно
|
|
|
+
|
|
|
+```c
|
|
|
v := beg;
|
|
|
-WHILE v <= end DO
|
|
|
-S;
|
|
|
-v := v + inc
|
|
|
-END
|
|
|
+ПОКА v <= end {
|
|
|
+ S();
|
|
|
+ v = v + inc;
|
|
|
+}
|
|
|
+```
|
|
|
|
|
|
и если inc<0, то это эквивалентно
|
|
|
+
|
|
|
+```c
|
|
|
v := beg;
|
|
|
-WHILE v >= end DO
|
|
|
-S;
|
|
|
-v := v + inc
|
|
|
-END
|
|
|
-
|
|
|
-Типы v, beg и end должны быть `ЦЕЛОЕ`, а inc должен быть целым (константное выражение). Если шаг не указан, предполагается, что он равен 1.
|
|
|
-
|
|
|
-1. Объявление процедур
|
|
|
-Объявление процедуры состоит из заголовка процедуры и тела процедуры. Заголовок определяет имя процедуры, формальные параметры и тип результата (если таковой есть). Тело содержит объявления и предписания. Имя процедуры повторяется в конце объявления процедуры.
|
|
|
-Существует два типа процедур, а именно процедуры и процедуры-функции. Последние активируются именем процедуры как частью выражения и возвращают результат, являющийся операндом в вызывающем выражении. Процедуры активируются вызовом процедуры. Процедура-функция отличается в объявлении путём указания типа её результата после списка параметров. Её тело должно заканчиваться ключевым словом RETURN, которое определяет результат процедуры-функции.
|
|
|
-Все константы, переменные, типы и процедуры, объявленные в теле процедуры, являются локальными для этой процедуры. Значения локальных переменных не определены при входе в процедуру. Поскольку процедуры могут быть объявлены как локальные объекты, объявления процедур могут быть вложенными.
|
|
|
-В дополнение к своим формальным параметрам и локально объявленным объектам -- объекты, объявленные глобально, также видны в процедуре.
|
|
|
-Использование имени процедуры в вызове в границах её объявления подразумевает рекурсивную активацию процедуры.
|
|
|
-ОбъявлениеПроцедуры = ЗаголовокПроцедуры";" ТелоПроцедуры Имя.
|
|
|
-ЗаголовокПроцедуры = PROCEDURE ИмяПроцедуры[ФормальныеПараметры].
|
|
|
-ТелоПроцедуры = ПоследОбъявлений[BEGIN ПоследПредписаний]
|
|
|
-[RETURN Выражение] END.
|
|
|
+ПОКА v >= end {
|
|
|
+ S();
|
|
|
+ v = v + inc;
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+Типы `v`, `beg` и `end` должны быть `ЦЕЛОЕ`, а `inc` должен быть целым (константное выражение). Если шаг не указан, предполагается, что он равен 1.
|
|
|
+
|
|
|
+## 10. Объявление функций
|
|
|
+
|
|
|
+Объявление функцмй состоит из заголовка функции и её тела. Заголовок определяет имя функции, формальные параметры и тип результата (если таковой есть). Тело содержит объявления и предписания.
|
|
|
+
|
|
|
+Существует два типа функций, а именно функции и фнкции-процедуры.
|
|
|
+
|
|
|
+Первые активируются именем функции как частью выражения и возвращают результат, являющийся операндом в вызывающем выражении.
|
|
|
+
|
|
|
+Функции-процедуры активируются вызовом функции. Функция-процедура отличается в объявлении путём указания типа её результата после списка параметров. Её тело должно заканчиваться ключевым словом `ВЕРНУТЬ`, которое определяет результат функции-процедуры.
|
|
|
+
|
|
|
+Все константы, переменные и типы, объявленные в теле функции, являются локальными для этой функции. Значения локальных переменных не определены при входе в функцию.
|
|
|
+
|
|
|
+В дополнение к своим формальным параметрам и локально объявленным объектам -- объекты, объявленные глобально, также видны в функции.
|
|
|
+Использование имени функции в вызове в границах её объявления подразумевает рекурсивный вызов функции.
|
|
|
+
|
|
|
+```bash
|
|
|
+ОбъявлениеФункции = ИмяФункции{ТелоФункции}.
|
|
|
+ИмяФункции = ФН ИмяФункции(ФормальныеПараметры..)Результат.
|
|
|
+ТелоФункции = ПоследОбъявлений{ПоследПредписаний, ВЕРНУТЬ Выражение}.
|
|
|
ПоследОбъявлений = [КОНСТ {ОбъявлениеКонстант ";"}]
|
|
|
-[TYPE {ОбъявлениеТипов ";"}] [ЗНАЧ {ОбъявлениеПеременных ";"}]
|
|
|
-{ОбъявлениеПроцедуры ";"}.
|
|
|
+[ТИП {ОбъявлениеТипов ";"}] [ЗНАЧ {ОбъявлениеПеременных ";"}]
|
|
|
+{ОбъявлениеФункции ";"}.
|
|
|
+```
|
|
|
+
|
|
|
+### 10.1 Формальные параметры
|
|
|
+
|
|
|
+Формальные параметры (или просто параметры) -- это имена, которые обозначают фактические параметры (аргументы), указанные в вызове функции. Соответствие между аргументами и параметрами устанавливается при вызове функции. Переменная соответствует фактическому параметру, который является переменной, и она обозначает эту переменную. Значение соответствует фактическому параметру, который является выражением, и он обозначает его значение, которое невозможно изменить при передаче. Однако, если значение имеет базовый тип, он представляет собой локальную переменную, которой первоначально присваивается значение фактического выражения.
|
|
|
+
|
|
|
+Тип параметра указывается в списке формальных параметров: переменные обозначаются ключевым словом `ЗНАЧ`, а значения не имеют такого префикса.
|
|
|
|
|
|
-10.1 Формальные параметры
|
|
|
-Формальные параметры (или просто параметры) -- это имена, которые обозначают фактические параметры (аргументы), указанные в вызове процедуры. Соответствие между аргументами и параметрами устанавливается при вызове процедуры. Существует два типа параметров, а именно переменные и значения. Переменная соответствует фактическому параметру, который является переменной, и она обозначает эту переменную. Значение соответствует фактическому параметру, который является выражением, и он обозначает его значение, которое невозможно изменить при передаче. Однако, если значение имеет базовый тип, он представляет собой локальную переменную, которой первоначально присваивается значение фактического выражения.
|
|
|
-Тип параметра указывается в списке формальных параметров: переменные обозначаются ключевым словом ЗНАЧ, а значения не имеют такого префикса.
|
|
|
Функция-процедура без параметров должна иметь пустой список параметров. Она должна быть вызвана через имя функции, список фактических параметров которой также пуст.
|
|
|
-Формальные параметры являются локальными для процедуры, т. е. их область действия - это текст программы, который представляет собой объявление процедуры.
|
|
|
+
|
|
|
+Формальные параметры являются локальными для функции, т. е. их область действия - это текст программы, который представляет собой объявление функции.
|
|
|
+
|
|
|
+```bash
|
|
|
Формальныйпараметр = "(" [Секция_FP {";" Секция_FP}] ")" [":" квалификатор].
|
|
|
Секция_FP = [ЗНАЧ] имя{"," имя} ":" ФормальныйПараметр.
|
|
|
-ФормальныйПараметр = {МАССИВ OF} квалификатор.
|
|
|
-Тип каждого формального параметра указан в списке параметров. Для переменных он должен быть идентичен типу соответствующего фактического параметра, за исключением случаев записи, где он должен быть базовым типом соответствующего типа фактического параметра.
|
|
|
-Если тип формального параметра указан как
|
|
|
-МАССИВ OF T
|
|
|
-параметр называется открытым массивом, а соответствующий фактический параметр может быть произвольной длины.
|
|
|
-Если формальный параметр указывает тип процедуры, то соответствующий фактический параметр должен быть либо объявленный глобально, либо переменной (или значением) этого типа процедуры. Это не может быть встроенная процедура. Тип результата процедуры не может быть ни записью, ни массивом.
|
|
|
-Примеры объявлений процедур:
|
|
|
-PROCEDURE Целое_Читать(ЗНАЧ x: `ЦЕЛОЕ`);
|
|
|
-ЗНАЧ
|
|
|
-i : `ЦЕЛОЕ`;
|
|
|
-ch: CHAR;
|
|
|
-BEGIN
|
|
|
-i := 0; Read(ch);
|
|
|
-WHILE ("0" <= ch) & (ch <= "9") DO
|
|
|
-i := 10*i + (ORD(ch)-ORD("0"));
|
|
|
-Read(ch)
|
|
|
-END;
|
|
|
-x := i
|
|
|
-END Целое_Читать
|
|
|
-PROCEDURE Целое_Писать(x: `ЦЕЛОЕ`); (* 0 <= x < 10^5 *)
|
|
|
-ЗНАЧ
|
|
|
-i: `ЦЕЛОЕ`;
|
|
|
-buf: МАССИВ 5 OF `ЦЕЛОЕ`;
|
|
|
-BEGIN
|
|
|
-i := 0;
|
|
|
-REPEAT
|
|
|
-buf[i] := x MOD 10;
|
|
|
-x := x DIV 10;
|
|
|
-INC(i)
|
|
|
-UNTIL x = 0;
|
|
|
-REPEAT
|
|
|
-DEC(i);
|
|
|
-Write(CHR(buf[i] + ORD("0")))
|
|
|
-UNTIL i = 0
|
|
|
-END Целое_Писать
|
|
|
-
|
|
|
-PROCEDURE log2(x: `ЦЕЛОЕ`): `ЦЕЛОЕ`;
|
|
|
-ЗНАЧ
|
|
|
-y: `ЦЕЛОЕ`; (*assume x>0*)
|
|
|
-BEGIN
|
|
|
-y := 0;
|
|
|
-WHILE x > 1 DO
|
|
|
-x := x DIV 2;
|
|
|
-INC(y)
|
|
|
-END ;
|
|
|
-RETURN y
|
|
|
-END log2
|
|
|
-
|
|
|
-10.2. Встроенные процедуры
|
|
|
-В следующей таблице перечислены предопределенные процедуры. Некоторые из них являются общими процедурами, то есть они применяются к нескольким типам операндов. v обозначает переменную, x и n для выражений, T - тип.
|
|
|
-Процедуры-функции:
|
|
|
-Имя
|
|
|
-Тип аргумента
|
|
|
-Тип результата
|
|
|
-Функция
|
|
|
-ABS(x)
|
|
|
-x: числовой тип
|
|
|
-соответствует типу x
|
|
|
-абсолютное значение числа
|
|
|
-ODD(x)
|
|
|
-x: `ЦЕЛОЕ`
|
|
|
-BOOLEAN
|
|
|
-x MOD 2 = 1
|
|
|
-LEN(v)
|
|
|
-v: МАССИВ
|
|
|
-`ЦЕЛОЕ`
|
|
|
-длина v
|
|
|
-LSL(x, n)
|
|
|
-x, n: `ЦЕЛОЕ`
|
|
|
-`ЦЕЛОЕ`
|
|
|
-логический сдвиг влево,
|
|
|
-x * 2n
|
|
|
-ASR(x, n)
|
|
|
-x, n: `ЦЕЛОЕ`
|
|
|
-`ЦЕЛОЕ`
|
|
|
-знаковый сдвиг вправо,
|
|
|
-x DIV 2n
|
|
|
-ROR(x, n)
|
|
|
-x, n: `ЦЕЛОЕ`
|
|
|
-`ЦЕЛОЕ`
|
|
|
-x сдвигается вправо на n бит
|
|
|
+ФормальныйПараметр = МАССИВ[nn]Тип..
|
|
|
+```
|
|
|
+
|
|
|
+Тип каждого формального параметра указан в списке параметров. Для переменных он должен быть идентичен типу соответствующего фактического параметра, за исключением случаев структур, где он должен быть базовым типом соответствующего типа фактического параметра.
|
|
|
|
|
|
+Если формальный параметр указывает тип функции, то соответствующий фактический параметр должен быть либо объявленный глобально, либо переменной этого типа функции. Это не может быть встроенная функция. Тип результата функции может быть любым типом, но только *один*.
|
|
|
|
|
|
+Примеры объявлений функций:
|
|
|
+
|
|
|
+```c
|
|
|
+ФН Целое_Читать(ЗНАЧ x: `ЦЕЛОЕ`){
|
|
|
+ ЗНАЧ i : ЦЕЛОЕ;
|
|
|
+ ЗНАЧ ch: БАЙТ;
|
|
|
+ i = 0;
|
|
|
+ Читать(ch);
|
|
|
+ ПОКА ("0" <= ch) И (ch <= "9") {
|
|
|
+ i = 10*i + (ORD(ch)-ORD("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")));
|
|
|
+}
|
|
|
+
|
|
|
+ФН лог2(x: ЦЕЛОЕ):ЦЕЛОЕ{
|
|
|
+ ЗНАЧ y ЦЕЛОЕ = 0; // assume x>0
|
|
|
+ WHILE x > 1 {
|
|
|
+ x = x ДИВ 2;
|
|
|
+ y++;
|
|
|
+ }
|
|
|
+ ВЕРНУТЬ y
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+### 10.2. Встроенные функции
|
|
|
+
|
|
|
+В следующей таблице перечислены встроенные функции. Некоторые из них являются общими функциями, то есть они применяются к нескольким типам операндов. `v` обозначает переменную, `x` и `n` для выражений, `T` - тип.
|
|
|
+
|
|
|
+Функции-Процедуры:
|
|
|
+
|
|
|
+| Имя | Тип аргумента | Тип результата | Описание | Англ |
|
|
|
+| ------------- | --------------- | -------------------- | ------------------------------ | --------- |
|
|
|
+| | 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) |
|
|
|
|
|
|
Функции преобразования типов:
|
|
|
-Имя
|
|
|
-Тип аргумента
|
|
|
-Тип результата
|
|
|
-Функция
|
|
|
-FLOOR(x)
|
|
|
-ВЕЩ
|
|
|
-`ЦЕЛОЕ`
|
|
|
-округление вниз
|
|
|
-FLT(x)
|
|
|
-`ЦЕЛОЕ`
|
|
|
-ВЕЩ
|
|
|
-преобразование типа
|
|
|
-ORD(x)
|
|
|
-CHAR, BOOLEAN, SET
|
|
|
-`ЦЕЛОЕ`
|
|
|
-порядковый номер x
|
|
|
-CHR(x)
|
|
|
-`ЦЕЛОЕ`
|
|
|
-CHAR
|
|
|
-литера по порядковому номеру x
|
|
|
|
|
|
+| Имя | Тип аргумента | Тип результата | Функция | Англ |
|
|
|
+| --- | ------------- | -------------- | ------------------- | -------- |
|
|
|
+| | ВЕЩ | ЦЕЛОЕ | округление вниз | FLOOR(x) |
|
|
|
+| | ЦЕЛОЕ | ВЕЩ | преобразование типа | FLT(x) |
|
|
|
+| | БАЙТ, БУЛ | ЦЕЛОЕ | порядковый номер x | ORD(x) |
|
|
|
|
|
|
Безопасные процедуры:
|
|
|
-Имя
|
|
|
-Тип аргумента
|
|
|
-Функция
|
|
|
-INC(v)
|
|
|
-`ЦЕЛОЕ`
|
|
|
-v := v + 1
|
|
|
-INC(v, n)
|
|
|
-`ЦЕЛОЕ`
|
|
|
-v := v + n
|
|
|
-DEC(v)
|
|
|
-`ЦЕЛОЕ`
|
|
|
-v := v - 1
|
|
|
-DEC(v, n)
|
|
|
-`ЦЕЛОЕ`
|
|
|
-v := v - n
|
|
|
-INCL(v, x)
|
|
|
-v: SET; x: `ЦЕЛОЕ`
|
|
|
-v := v + {x}
|
|
|
-EXCL(v, x)
|
|
|
-v: SET; x: `ЦЕЛОЕ`
|
|
|
-v := v - {x}
|
|
|
-НОВ(v)
|
|
|
-тип ссылки
|
|
|
-размещение v^
|
|
|
-ASSERT(b)
|
|
|
-BOOLEAN
|
|
|
-прервать, если ~b
|
|
|
-PACK(x, n)
|
|
|
-ВЕЩ; `ЦЕЛОЕ`
|
|
|
-упаковать x и n в x
|
|
|
-UNPK(x, n)
|
|
|
-ВЕЩ; `ЦЕЛОЕ`
|
|
|
-распаковать x в x и n
|
|
|
|
|
|
+| Имя | Тип аргумента | Функция | Англ |
|
|
|
+| ------ | ------------- | ------------------------------ | ---------- |
|
|
|
+| НОВ(v) | перменная | размещение переменной в памяти | NEW(v) |
|
|
|
+| | BOOLEAN | прервать, если ~b | ASSERT(b) |
|
|
|
+| | ВЕЩ, ЦЕЛОЕ | упаковать x и n в x | PACK(x, n) |
|
|
|
+| | ВЕЩ, ЦЕЛОЕ | распаковать x в x и n | UNPK(x, n) |
|
|
|
|
|
|
Функция FLOOR (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.
|
|
|
-
|
|
|
-11. Модули
|
|
|
-Модуль представляет собой набор объявлений констант, типов, переменных и процедур и последовательностей предписаний с целью присвоения начальных значений переменным. Модуль обычно представляет собой текст, который можно скомпилировать как единое целое.
|
|
|
-Модуль = MODULE Имя ";" [СписокИмпорта] ПоследовательостьОбъявлений
|
|
|
-[BEGIN ПоследовательностьПредписаний] END имя"." .
|
|
|
-СписокИмпорта = IMPORT Импорт{"," Импорт} ";" .
|
|
|
-Импорт = Имя[":=" Имя].
|
|
|
-
|
|
|
-В списке импорта указаны модули, для которых текущий модуль является клиентом. Если имя x экспортируется из модуля M, и если M указан в списке импорта модуля, тогда к x обращаются как M.x. Если в списке импорта используется форма «M: = M1», экспортируемый объект x, объявленный в M1, ссылается в импортируемом модуле как M.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`.
|
|
|
+
|
|
|
+## 11. Модули
|
|
|
+
|
|
|
+Модуль представляет собой набор объявлений констант, типов, переменных и функций и последовательностей предписаний с целью присвоения начальных значений переменным. Модуль обычно представляет собой текст, который можно скомпилировать как единое целое.
|
|
|
+
|
|
|
+```bash
|
|
|
+Модуль = МОДУЛЬ Имя {
|
|
|
+ [СписокИмпорта]
|
|
|
+ ПоследовательостьОбъявлений
|
|
|
+}
|
|
|
+
|
|
|
+СписокИмпорта = ИМПОРТ {
|
|
|
+ Импорт "," Импорт
|
|
|
+}
|
|
|
+
|
|
|
+Импорт = Имя["=" МодульПуть];
|
|
|
+```
|
|
|
+
|
|
|
+В списке импорта указаны модули, для которых текущий модуль является клиентом. Если имя `x` экспортируется из модуля `M`, и если `M` указан в списке импорта модуля, тогда к `x` обращаются как `M.x`. Если в списке импорта используется форма `M1 = M`, экспортируемый объект `x`, объявленный в `M1`, ссылается в импортируемом модуле как `M1.x`.
|
|
|
+
|
|
|
Имена, которые должны быть видны в клиентских модулях, то есть должны быть экспортированы, должны быть отмечены звездочкой (отметкой экспорта) в их объявлении. Переменные всегда экспортируются в режиме только для чтения.
|
|
|
-Последовательность предписаний, следующая за ключевым словом BEGIN, выполняется, когда модуль добавляется в систему (загружается). Последующие индивидуальные (без параметров) процедуры могут быть активированы из системы, и эти процедуры служат в качестве команд.
|
|
|
+
|
|
|
+Последовательность предписаний, следующая за ключевым символом "{", выполняется, когда модуль *загружается* в систему. Последующие индивидуальные (без параметров) функции могут быть активированы из системы, и эти процедуры служат в качестве команд.
|
|
|
+
|
|
|
Пример:
|
|
|
-MODULE Вывод; (*экспортирует процедуры: Write, WriteInt, WriteLn*)
|
|
|
-IMPORT Текст,
|
|
|
-Oberon;
|
|
|
-ЗНАЧ
|
|
|
-W: Текст.Writer;
|
|
|
-PROCEDURE Write*(ch: CHAR);
|
|
|
- BEGIN
|
|
|
-Текст.Write(W, ch)
|
|
|
- END ;
|
|
|
-PROCEDURE WriteInt*(x, n: `ЦЕЛОЕ`);
|
|
|
-ЗНАЧ
|
|
|
-i: `ЦЕЛОЕ`;
|
|
|
-a: МАССИВ 16 OF CHAR;
|
|
|
-BEGIN
|
|
|
-i := 0;
|
|
|
-IF x < 0 THEN
|
|
|
-Текст.Текст(W, "-");
|
|
|
-x := -x
|
|
|
-END ;
|
|
|
-REPEAT
|
|
|
-a[i] := CHR(x MOD 10 + ORD("0"));
|
|
|
-x := x DIV 10;
|
|
|
-INC(i)
|
|
|
-UNTIL x = 0;
|
|
|
- REPEAT
|
|
|
-Текст.Write(W, " ");
|
|
|
-DEC(n)
|
|
|
-UNTIL n <= i;
|
|
|
- REPEAT
|
|
|
-DEC(i);
|
|
|
-Текст.Write(W, a[i])
|
|
|
-UNTIL i = 0
|
|
|
- END WriteInt;
|
|
|
-
|
|
|
-PROCEDURE WriteLn*;
|
|
|
- BEGIN
|
|
|
-Текст.WriteLn(W);
|
|
|
-Текст.Append(Oberon.Log, W.buf)
|
|
|
-END WriteLn;
|
|
|
-
|
|
|
-BEGIN
|
|
|
-Текст.OpenWriter(W)
|
|
|
-END Out.
|
|
|
-
|
|
|
-11.1 Модуль SYSTEM
|
|
|
+
|
|
|
+```c
|
|
|
+МОДУЛЬ Вывод // экспортирует процедуры: Write, WriteInt, WriteLn
|
|
|
+
|
|
|
+ИМПОРТ {
|
|
|
+ Текст;
|
|
|
+ Oberon;
|
|
|
+}
|
|
|
+
|
|
|
+ЗНАЧ {
|
|
|
+ W: Текст.Writer,
|
|
|
+}
|
|
|
+
|
|
|
+ФН Write*(ch: БАЙТ){
|
|
|
+ Текст.Write(W, ch)
|
|
|
+}
|
|
|
+
|
|
|
+ФН WriteInt*(x, n: `ЦЕЛОЕ`){
|
|
|
+ ЗНАЧ {
|
|
|
+ i: ЦЕЛОЕ = 0,
|
|
|
+ a: МАССИВ[16]BYTE,
|
|
|
+ }
|
|
|
+ ЕСЛИ x < 0 {
|
|
|
+ Текст.Текст(W, "-");
|
|
|
+ x := -x;
|
|
|
+ }
|
|
|
+ ПЕТЛЯ {
|
|
|
+ a[i] = CHR(x MOD 10 + ORD("0"));
|
|
|
+ x = x DIV 10;
|
|
|
+ i++
|
|
|
+ ЕСЛИ х == 0{
|
|
|
+ ПРЕРВАТЬ;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Текст.Write(W, " ");
|
|
|
+ n--
|
|
|
+ ПЕТЛЯ {
|
|
|
+ ЕСЛИ n >i{
|
|
|
+ ПРЕРВАТЬ
|
|
|
+ }
|
|
|
+ i--;
|
|
|
+ }
|
|
|
+ Текст.Write(W, a[i])
|
|
|
+}
|
|
|
+
|
|
|
+ФН WriteLn*{}
|
|
|
+ Текст.WriteLn(W);
|
|
|
+ Текст.Append(Oberon.Log, W.buf)
|
|
|
+}
|
|
|
+
|
|
|
+{
|
|
|
+ Текст.OpenWriter(W)
|
|
|
+}.
|
|
|
+```
|
|
|
+
|
|
|
+### 11.1 Модуль SYSTEM
|
|
|
Необязательный модуль SYSTEM содержит определения, необходимые для программирования операций низкого уровня, ссылающихся непосредственно на ресурсы, специфичные для данного компьютера и/или реализации языка/компьютера.
|
|
|
К ним относятся, например, средства доступа к устройствам, которые контролируются компьютером, и, возможно, низкоуровневым средствам для нарушения правил совместимости типов данных (иначе пришлось бы такие средства языка вводить явно).
|
|
|
В модуле SYSTEM есть две причины для упрощения процедур:
|
SVI