Справочное руководство по языку Fortran 95
перевод Балуева А. Н.
Оглавление
В начало страницы
Fortran имеет два рода процедур: функции и сабрутины. Процедуры разделяются
на категории согласно следующей таблице:
Таблица 7: Процедуры
| Функции |
Встроенные функции |
Групповые встроенные функции |
| Специальные встроенные функции | |
| Внешние функции |
Групповые внешние функции |
| Специальные внешние функции |
Внутренние функции |
Операторы-функции |
| Сабрутины |
Встроенные сабрутины |
Групповые встроенные сабрутины |
| Специальные встроенные сабрутины |
| Внешние сабрутины |
Групповые внешние сабрутины |
| Специальные внешние сабрутины |
| Внутренние сабрутины |
Встроенные процедуры предоставляются процессором Fortran'а
Внешняя процедура определяется отдельной программной единицей и может быть
отдельно компилирована. Она не обязательно должна быть написана на Fortran.
На внешние и встроенные процедуры можно ссылаться в любом месте программы.
Внутренняя процедура содержится в другой программной единице. На нее можно
ссылаться только в пределах содержащей ее программной единицы.
На внутренние и внешние процедуры можно ссылаться рекурсивно, если ключевое
слово RECURSIVE включено в ее определение.
Встроенные и внешние процедуры могут быть специальными или групповыми.
Групповая процедура имеет специфические версии, на которые можно ссылаться
по групповому имени. Используемая специфическая версия определяется по типу,
разновидности и рангу аргументов.
Дополнительно процедуры могут быть элементными или не-элементными. Элементная
процедура может брать в качестве аргумента или скаляр или массив.
Если такая процедура берет массив в качестве аргумента, она воздействует на
каждый элемент массива как на скаляр.
Каждая из различных процедур в Fortran детально описывается ниже.
Встроенные процедуры
Встроенные процедуры обеспечиваются процессором Fortran. Имеется более ста
встроенных процедур. Каждая из них детально документирована в Алфавитном
справочнике. Таблица их помещена в "Встроенные процедуры" на стр. 249.
Сабрутины
Сабрутина есть самостоятельная процедура, которая вызывается оператором CALL.
Например,
program main
implicit none
interface ! an explicit interface is provided
subroutine multiply(x, y)
implicit none
real, intent(in out) :: x
real, intent(in) :: y
end subroutine multiply
end interface
real :: a, b
a = 4.0
b = 12.0
call multiply(a, b)
print*, a
end program main
subroutine multiply(x, y)
implicit none
real, intent(in out) :: x
real, intent(in) :: y
multiply = x*y
end subroutine multiply
Эта программа вызывает сабрутину multiply и передает ей фактические аргумента
типа REAL,
a и b. Фиктивные аргументы сабрутины multiply, x и y, ссылаются
на ту же память, что a и b в главной программе. После выхода из сабрутины
a имеет значение 48.0, b остается без изменения.
Синтаксис определения сабрутины таков:
subroutine-stmt
[use-stmts]
[specification-part]
[execution-part]
[internal-subprogram-part]
end-subroutine-stmt
Здесь:
subroutine-stmt есть оператор SUBROUTINE.
use-stmts есть 0 или более операторов USE.
specification-part есть 0 или более операторов спецификации.
execution part есть 0 или более исполнимых операторов.
internal-subprogram-part есть
CONTAINS
procedure-definitions
procedure-definitions есть одно или более определений процедур.
end-subroutine-stmt есть
END [ SUBROUTINE [subroutine-name] ]
subroutine-name есть имя сабрутины.
Функции
Функция есть процедура, которая выдает один скалярный или массивный результат.
Она используется в выражениях так же как и переменные. Например, в следующей
программе
program main
implicit none
interface ! an explicit interface is provided
function square(x)
implicit none
real, intent(in) :: x
real :: square
end function square
end interface
real :: a, b=3.6, c=3.8, square
a = 3.7 + b + square(c) + sin(4.7)
print*, a
stop
end program main
function square(x)
implicit none
real, intent(in) :: x
real :: square
square = x*x
return
end function square
square(c) и sin(4.7) есть ссылки на функции. Синтаксис ссылки на функцию
таков:
function-name (actual-arg-list)
где: function-name есть имя функции,
actual-arg-list есть список фактических
аргументов.
Функция может быть определена как внутренняя или внешняя функция или как
оператор-функция.
Внешние функции
Внешние функции могут вызываться в любой точке программы. Синтаксис
определения внешней функции:
function-stmt
[use-stmts]
[specification-part]
[execution-part]
[internal-subprogram-part]
end-function-stmt
Здесь:
function-stmt есть оператор FUNCTION.
use-stmts есть 0 или более операторов USE.
specification-part есть 0 или больше операторов спецификации.
execution part есть 0 или более исполнимых операторов.
internal-subprogram-part есть
CONTAINS
procedure-definitions
procedure-definitions есть одно или более определений процедур.
end-function-stmt есть
END [FUNCTION [function-name] ]
function-name есть имя функции.
Операторы-функции
Оператор-функция (см. "Операторы оператор-функция" на стр. 217) есть функция,
определенная в одной строке одним выражением. На нее можно ссылаться только
в пределах программной единицы, в которой она определена.
Оператор-функции лучше использовать там, где скорость важнее повторного
размещения информации в других ячейках и где функция определяется
одним выражением. Приведем пример, эквивалентный примеру внешней функции в
"Функции" на стр. 43:
program main
real :: a, b=3.6, c=3.8, square
square(x) = x*x
a = 3.7 + b + square(c) + sin(4.7)
print*, a
end
Встроенные процедуры
Процедура может содержать другие процедуры, на которые можно ссылаться в
пределах процедуры-хоста. Такие процедуры называются внутренними. Внутренняя
процедура определяется в хост-процедуре вслед за оператором CONTAINS, который
должен располагаться после исполнимого кода содержащей подпрограммы. Ее форма
такова же как и форма внешней процедуры.
Пример:
subroutine external ()
...
call internal () ! ссылка на процедуру internal
...
contains
subroutine internal () ! вызываема только из external()
...
end subroutine internal
end subroutine external
Имена из хост-процедуры доступны внутренней процедуре. Это называется
хост-ассоциация
Рекурсия
Fortran-процедура может ссылаться на себя, как непосредственно, так и косвенно,
если в ее определении фигурирует ключевое слово RECURSIVE. Функция, которая
вызывает себя непосредственно, должна употреблять параметр RESULT (см.
"Оператор FUNCTION" на стр. 131).
Процедуры без побочного эффекта (Pure Procedures)
Fortran-процедуры могут быть специфицированы как PURE, в том смысле что нет
шансов, что процедура может иметь побочное воздействие на данные вне процедуры.
Только такие процедуры можно использовать в специфицирующих выражениях.
Ключевое слово PURE должно быть указано в объявлении процедуры.
Элементные процедуры
Fortran-процедура может быть элементной, в том смысле, что она работает
над каждым элементом массива-аргумента как если бы аргумент был скаляром.
Ключевое слово ELEMENTAL должно быть использовано в объявлении такой
процедуры. Заметим, что все элементные процедуры являются также процедурами
вида pure.
Аргументы процедуры
Аргументы служат средством передачи информации между вызывающей и вызываемой
процедурами. Вызывающая процедура обеспечивает список фактических аргументов.
Вызываемая процедура содержит список фиктивных аргументов.
Intent ("намерение") аргумента
Так как Fortran передает аргументы по ссылке (т.е по имени), не желаемый
побочный эффект может случиться, когда значение фактического аргумента
изменяется в вызванной процедуре. Чтобы защитить программу от таких ненужных
побочных эффектов, имеется атрибут INTENT. Фиктивный аргумент может иметь
один из следующих атрибутов:
- INTENT (IN), когда он должен быть использован только для передачи данных
вызванной процедуре, а не для возвращения результата в вызвавшую процедуру.
- INTENT (OUT), когда он должен использоваться для возвращения результатов, а
не для передачи данных; и
- INTENT (IN OUT), когда он должен нести обе функции. Такое значение он имеет
по умолчанию. Атрибут INTENT указывается для фиктивных аргументов либо с
помощью операторов INTENT, либо в операторе объявления типа.
Ключевые аргументы
Используя ключевые аргументы, программист может указывать явно, какой
фактический аргумент соответствует какому фиктивному, независимо от его
позиции в списке фактических аргументов. Чтобы добиться этого, нужно указывать To
имя фиктивного аргумента вместе с фактическим аргументом, используя такой
синтаксис:
keyword = actual-arg
где:
keyword есть имя фиктивного аргумента, actual-arg есть фактический аргумент.
Пример:
...
call zee(c=1, b=2, a=3)
...
subroutine zee(a,b,c)
...
В этом примере фактические аргументы указаны в обратном порядке.
В вызове процедуры можно использовать ключевые аргументы для нуля, некоторых
или всех фактических аргументов (см. "Необязательные аргументы" ниже).
Для тех аргументов, которые не имеют ключевых слов, порядок фактических
аргументов в списке определяет их соответствие фиктивным аргументам в их
списке. Ключевые аргументы должны располагаться после не ключевых.
Заметим, что для вызова процедуры с использованием ключевых аргументов
должен присутствовать явный интерфейс (см. "Процедурные интерфейсы" на стр.
49).
Необязательные аргументы
Фактический аргумент не является обязательным для фиктивного аргумента с
атрибутом OPTIONAL. Чтобы сделать аргумент необязательным, нужно указать
атрибут OPTIONAL для фиктивного аргумента либо в операторе объявления типа,
либо в операторе OPTIONAL.
Необязательный аргумент, расположенный в конце списка фиктивных аргументов,
может быть просто опущен в соответствующем списке фактических аргументов.
Ключевые аргументы необходимо использовать, чтобы опустить другие
необязательные аргументы в том случае, когда не все остальные аргументы в
ссылке нужно опустить. Например:
subroutine zee(a, b, c)
implicit none
real, intent(in), optional :: a, c
real, intent(in out) :: b
...
end subroutine zee
В этой сабрутине a и c --- необязательные аргументы. В следующих вызовах
опущены разные комбинации необязательных аргументов:
call zee(b=3.0) ! a и c опущены, нужны ключевые аргументы
call zee(2.0, 3.0) ! c опущено
call zee(b=3.0, c=8.5) ! a опущено, нужны ключевые аргументы
Обычно в теле процедуры нужно знать, были ли предусмотрены необязательные
аргументы. Встроенная функция PRESENT имеет в качестве аргумента имя одного
из необязательных аргументов и возвращает true если аргумент присутствует и
false в противном случае. На фиктивный аргумент процедуры, который отсутствует,
ссылаться нельзя, за исключением случаев аргумента функции PRESENT или
необязательного аргумента в обращении к процедуре.
Отметим, что для того, чтобы процедура имела необязательный аргумент, она
должна обладать явным интерфейсом (см. "Процедурные интерфейсы" на стр. 49).
Многие встроенные процедуры Fortran имеют необязательные аргументы.
optional arguments.
Альтернативный возврат (устаревшее)
Процедура может возвращать управление помеченному оператору в вызывающей
подпрограмме, используя альтернативный возврат. Синтаксис фиктивного аргумента
альтернативного возврата таков
*
Синтаксис фактического аргумента альтернативного возврата есть
* label
где label означает помеченный исполнимый оператор в вызывающей подпрограмме.
Аргумент для оператора RETURN используется в вызванной подпрограмме для
указания того, какой альтернативный возврат в списке фиктивных аргументов
нужно выбрать. Например,
...
call zee(a,b,*200,c,*250)
...
subroutine zee(a, b, *, c, *)
...
return 2 ! возврат к метке 250 в вызывающей процедуре
...
return 1 ! возврат к метке 200 в вызывающей процедуре
return ! нормальный возврат
Фиктивные процедуры
Фиктивный аргумент может быть именем, на которое надо сослаться в вызванной
подпрограмме, или который должен находиться в блоке интерфейса, или в
операторах EXTERNAL или INTRINSIC. Соответствующий фактический аргумент не
должен быть именем встроенной процедуры или оператора-функции.
Процедурные интерфейсы
Интерфейс процедуры составляют все характеристики процедуры, которые
представляют интерес для процессора Fortran при вызове процедуры. Эти
характеристики включают имя процедуры, количество, порядок и тип параметров,
форму и intent аргументов ; являются ли аргументы необязательными; не есть ли
они указатели; и если речь идет о вызове функции, то ее тип, параметры типа ,
ранг результата и то, не является ли он указателем. Если результат функции
не есть указатель, его форма представляет важную характеристику. Интерфейс
может быть явным, и в таком случае Fortran-процессор имеет доступ ко всем
характеристикам интерфейса процедуры, или неявным, и в этом случае
Fortran-процессор должен делать предположения об интерфейсе.
Явные интерфейсы
Для избежания ошибок желательно создавать явные интерфейсы там, где это
возможно. В каждом из следующих случаев явный интерфейс обязателен:
Если обращение к процедуре появляется
- с ключевым аргументом,
- как определяемое присваивание,
- в выражении как определяемый оператор, или
- как ссылка по ее групповому имени;
или процедура имеет
- необязательный фиктивный аргумент,
- или результат типа массив,
- фиктивный аргумент, который может быть массивом с предполагаемой формой,
указателем или назначением,
- результат CHARACTER, значение параметра разновидности которого не
предполагаемое и не константа, или
- имеет результатом указатель.
Интерфейс всегда явный у встроенной процедуры, внутренней процедуры и
процедуры-модуля. Интерфейс оператора-функции всегда неявный. В остальных
случаях явный интерфейс можно установить, используя интерфейсный блок с
синтаксисом:
interface-stmt
[interface-body] ...
[module procedure statement] ...
end-interface statement
где:
interface-stmt есть операторis INTERFACE.
interface-body есть function-stmt
[specification-part]
end stmt
или
subroutine-stmt
[specification-part]
end-stmt
module-procedure-stmt есть оператор MODULE PROCEDURE.
end-interface-stmt есть END INTERFACE statement.
function-stmt есть FUNCTION statement.
subroutine-stmt есть оператор SUBROUTINE.
specification-part есть специфицирующая часть процедуры.
Процедурные интерфейсы
end-stmt есть оператор END.
Пример:
interface
subroutine x(a, b, c)
implicit none
real, intent(in), dimension (2,8) :: a
real, intent(out), dimension (2,8) :: b, c
end subroutine x
function y(a, b)
implicit none
logical, intent (in) :: a, b
end function y
end interface
В этом примере явными интерфейсами снабжены процедуры x и y. Всякие ошибки
в ссылках на эти процедуры в единице видимости интерфейсного блока будут
обнаружены во время компиляции.
Групповые (Generic) интерфейсы
Оператор INTERFACE с групповым именем (см. "Оператор INTERFACE" на стр.152)
указывает групповой интерфейс для каждой из процедур в интерфейсном блоке.
На этом пути можно создавать внешние групповые процедуры, аналогичные
встроенным групповым процедурам.
Пример:
interface swap ! групповая переустановочная рутина
subroutine real_swap(x, y)
implicit none
real, intent (in out) :: x, y
end subroutine real_swap
subroutine int_swap(x, y)
implicit none
integer, intent (in out) :: x, y
end subroutine int_swap
end interface
Здесь групповая процедура swap может использоваться и с REAL и с INTEGER типами.
Определяемые операции
Операторы могут расширяться и могут создаваться новые операторы определенных
пользователем или встроенных типов данных. Это можно делать с помощью
интерфейсных блоков с INTERFACE OPERATOR (см. "Оператор INTERFACE" на стр. 152).
Определяемая операция имеет вид
operator operand
для одноаргументной определяемой операции, и
operand operator operand
для бинарной определяемой операции, где operator есть один из встроенных
операторов или определенный пользователем оператор вида
.operator-name.
где .operator-name. состоит из от одной до 31 букв.
Например, каждый из операторов
a .intersection. b
или
a * b
можно использовать для указания пересечения двух множеств. Групповой блок
интерфейса может выглядеть подобен следующему
interface operator (.intersection.)
function set_intersection (a, b)
implicit none
type (set), intent (in) :: a, b, set_intersection
end function set_intersection
end interface
для первого примера и
interface operator (*)
function set_intersection (a, b)
implicit none
type (set), intent (in) :: a, b, set intersection
end function set_intersection
end interface
для второго примера.
Функция set_intersection должна содержать код для
определения пересечения a и b. Приоритет определяемого оператора такой же
как и у соответствующего встроенного оператора, если встроенный оператор
расширяется. Если используется оператор, определенный пользователем,
унарный оператор имеет высший приоритет по сравнению с другими определяемыми
операциями, а бинарная определяемая операция имеет более низкий приоритет
чем всякая другая
операция.
Встроенная операция (такая как сложение) не может быть переопределена
для правильных операндов встроенного типа. Например, нельзя переопределить
плюс на операцию минус для численных типов. Функции, указанные в интерфейсном
блоке, имеют либо один аргумент, в случае определения унарной операции, или
два аргумента при определяемом бинарном операторе.
Операнд или операнды
в определяемой операции становятся аргументами функции, указанной в блоке
интерфейса в зависимости от их типа, рода или ранга. Если выполняется
определяемая бинарная операция,
левый операнд соответствует первому аргументу, а правый операнд --- второму
аргументу. И унарные и бинарные определяемые операции для определенных
операндов могут быть специфицированы в одном и том же блоке.
Определяемые присваивания
Оператор присваивания может быть расширен использованием интерфейсного блока
с INTERFACE ASSIGNMENT (см. "Оператор INTERFACE" на стр. 152). Механизм
этого подобен используемому при определении бинарной операции (см.
"Определяемые операции" на стр. 51), с переменной в левой стороне присваивания,
соответствующей первому аргументу сабрутины в интерфейсном блоке и объектом
данных справа, соответствующим второму аргументу. Первый аргумент должен
быть INTENT (OUT) или INTENT (IN OUT); второй аргумент должен быть
INTENT (IN).
Пример:
interface assignment (=) ! use = for integer to
! logical array
subroutine integer_to_logical_array (b, n)
implicit none
logical, intent (out) :: b(:)
integer, intent (in) :: n
end subroutine integer_to_logical_array
end interface
Здесь оператор присваивания расширяется до конвертирования данных INTEGER
в массив LOGICAL.
В начало страницы
Программная единица есть самый маленький элемент Fortran-программы, который
можно отдельно компилировать. Имеются пять родов программных единиц:
- Программа Main
- Подпрограмма внешней функции
- Подпрограмма внешней сабрутины
- Программная единица блок данных
- Программная единица Module
Внешние функции и сабрутины описаны в "Функции" на стр. 43 и "Встроенные
процедуры" на стр. 42.
Главная программа
Выполнение Fortran-программы начинается с первого исполнимого оператора
в главной программе и кончается на операторе STOP где-то в программе
или на операторе END главной программы. Форма главной программы:
[program-stmt]
[use-stmts]
[specification-part]
[execution-part]
[internal-subprogram-part]
end-stmt
Здесь:
program-stmt есть оператор PROGRAM.
use-stmts есть один или более оператор USE.
specification-part есть один или более операторов спецификаций или
интерфейсных блоков.
execution-part есть один или более исполнимых операторов, отличных от RETURN
или ENTRY.
internal-subprogram есть одна или более внутренних процедур.
end-stmt есть оператор END.
Программная единица блок данных
Блок данных обеспечивает начальные значения данных в одном или более блоков,
называемых блоками common. В этой программной единице могут быть только
операторы спецификации. На блок данных можно ссылаться только в операторах
EXTERNAL, расположенных в других программных единицах. Форма этого блока
такова:
block-data-stmt
[specification-part]
end-stmt
Здесь:
block-data-stmt есть оператор BLOCK DATA.
specification-part есть один или более операторов спецификаций, отличных от
ALLOCATABLE,INTENT, PUBLIC, PRIVATE, OPTIONAL и SEQUENCE.
end-stmt есть оператор END.
Программная единица MODULE
Программные единицы модули дают средства упаковки всего, что требуется более
чем одной единице видимости (единица видимости есть программная единица,
подпрограмма, определение производного типа или тело процедурного интерфейса,
исключая другие единицы видимости, которые она содержит). Модули могут
содержать спецификации типов, интерфейсные блоки, исполнимые коды в
подпрограммах модуля, ссылки на другие модули. Имена в модуле могут быть
специфицированы оператором PUBLIC (такие имена доступны при использовании
модуля) или оператором PRIVATE (доступны только внутри самого модуля).
Обычно модуль используется для
- для объявления и инициализации данных, используемых в более чем одной
подпрограмме, без употребления блоков common.
- для спецификации явных интерфейсов процедур.
- для определения производных типов и создания повторно используемых
абстрактных типов данных (производные типы и процедуры, производящие действия
над ними)
Во входном файле компилятора LF95 каждый программный модуль должен
располагаться раньше всех других программных единиц.
Форма модуля:
module-stmt
[use-stmts]
[specification-part]
[module-subprogram-part]
end-stmt
Здесь:
module-stmt есть оператор MODULE.
use-stmts есть один или более оператор USE.
specification-part есть один или более блоков интерфейса или операторов
спецификации, отличных от OPTIONAL или INTENT.
module-subprogram part есть CONTAINS, за которым следует одна или более
процедур модуля.
end-stmt есть оператор END.
Пример:
module example
implicit none
integer, dimension(2,2) :: bar1=1, bar2=2
type phone_number !определение производного типа
integer :: area_code,number
end type phone_number
interface !явные интерфейсы
function test(sample,result)
implicit none
real :: test
integer, intent(in) :: sample,result
end function test
function count(total)
implicit none
integer :: count
real,intent(in) :: total
end function count
end interface
interface swap !групповой интерфейс
module procedure swap_reals,swap_integers
end interface
contains
function swap_reals !процедура-модуль
...
end function swap_reals
function swap_integers !процедура-модуль
...
end function swap_integers
end module example
Процедуры-модули
Процедуры-модули имеют те же самые правила и организацию как внешние
процедуры, хотя они аналогичны внутренним процедурам в том, что имеют доступ к
данным в хост-модуле. Только те программные единицы, которые используют
хост-модуль, имеют доступ к его процедурам-модулям. Процедуры могут быть
сделаны локальными для модуля указанием атрибута PRIVATE в операторе PRIVATE
или в объявлении типа внутри модуля.
Использование модулей
Содержащаяся в модуле информация может быть сделана доступной для других
программных единиц с помощью оператора USE. Например,
use set_module
даст текущей единице видимости доступ к именам в модуле set_module. Если имя
в set_module вступает в конфликт с именем в текущей единице видимости,
ошибка случается только при ссылке на это имя. Для избежания таких
конфликтов оператор USE имеет средство для установки псевдонимов:
use set_module, a => b
Так объект b в модуле получает в текущей единице видимости имя a .
Другой путь избежания конфликтов имен, когда определенное в модуле имя
примитива не нужно в текущей единице видимости, состоит в форме ONLY в
операторе USE:
use set_module, only : c, d
Здесь объявлено, что только имена c and d доступны в текущей единице
видимости.
В компиляторе LF95 не допускаются ссылки вперед на модули. То есть, если
модуль используется в том же самом входном файле, в котором он расположен,
программа модуля должна появиться раньше ссылки на него.
В начало страницы
Имена программных единиц, блоков common и внешних процедур имеют глобальную
область действия. То есть на них можно ссылаться в любом месте программы.
Глобальное имя может отождествлять только один примитив в программе.
Имена фиктивных аргументов операторов-функций действуют только в пределах
оператора. То же имя можно использовать для другого примитива вне оператора,
и имя не должно обозначать более оного примитива внутри оператора.
Имена неявных параметров DO в операторах DATA и конструктах массивов имеют
областью действия список неявных параметров. То же самое имя может
использоваться для различных примитивов вне неявных списков DO, и такое имя
не может идентифицировать более одного примитива в пределах неявного списка DO.
Другие имена имеют локальные области действия, называемые единицей видимости.
Единица видимости есть одно из:
- определение производного типа, исключая имя производного типа;
- тело интерфейса, исключая все определения производных типов или тела
интерфейсов в его пределах;
- программная единица или подпрограмма, исключая определения компонент
производных типов, тела интерфейсов и подпрограмм, содержащихся в ней;
На имена в единице видимости можно ссылаться из единицы видимости,
содержащейся внутри внешней единицы, за исключением тех же имен, объявленных
во внутренней единице. Такое положение называется хост-ассоциацией.
Например:
subroutine external ()
implicit none
integer :: a, b
...
contains
subroutine internal ()
implicit none
integer :: a
...
a=b ! a is the local a;
! b is available by host association
...
end subroutine internal
...
end subroutine external
В операторе a=b переменная a есть a, объявленное в сабрутине internal, а не
a, объявленное в сабрутине external. b доступно из external согласно
host-ассоциации.
Совместное использование данных
Чтобы сделать примитив доступным для более чем одной программной единицы,
можно передавать его как аргумент, помещать его в блок common (см.
"COMMON Statement" на стр. 88), или объявить его в модуле и использовать
модуль (см. "Программная единиц Module" на стр. 55).
|