Описание_языка_Фортран_5

О П И С А Н И Е Я З Ы К А
**********************************************************************
1. ЭЛЕМЕНТЫ ЯЗЫКА ФОРТРАН
В данном разделе описываются основные конструкции программ на
языке ФОРТРАН: специальные символы, идентификаторы областей видимости
и именования в языке ФОРТРАН, допустимые типы данных, правила их
использования. Рассмотрены
также
разрешенные
арифметические
и
логические функции.
1.1
Символы
Исходные ФОРТРАН-файлы могут содержать любые печатаемые символы,
входящие в состав символьного набора кодов ASCII.
Коды
ASCII
перечислены в приложении 1 и включают:
- 52 строчные и прописные буквы латинского алфавита (от A до Z, и
от а до z).
Кроме того, как буквенный символ обрабатывается и знак доллара
($). При выполнении процедуры сортировки имен, знак доллара появляется
сразу после буквы Z.
В компиляторе языка ФОРТРАН строчные буквы интерпретируются как
прописные в любом контексте за исключением случаев использования
символьных констант и полей Холлерита. В символьных константах и полях
Холлерита регистр букв является значащим. Например, операторы WRITE
(*, *) и write (*, *) будут тождественны; символьная же константа
'ijk' будет отличаться от символьной константы 'IjK'.
При учете регистра в символьных
константах
имеется
одно
исключение. Для символьных констант, специфицированных с операторами
языка ФОРТРАН, перечисленными в разделе 4 "Операторы", регистр не
является значащим, если не специфицирована метакоманда $STRICT.
В операторе CLOSE, например, пользователь может ввести символьную
константу для спецификации того, следует ли сохранять или удалять
файл. Синтаксис этого параметра следующий: [,STATUS=<status>], а
допустимыми значениями поля <status> будут значения 'KEEP' и 'DELETE'.
До тех пор, пока не установлена метакоманда $STRICT, установка
параметра STATUS со значением 'KEEP' эквивалентна установкам этого
параметра со значениями, например, 'кeep' или 'КeEp'.
Следует
заметить,
что поскольку слово STATUS является
ключевым словом языка ФОРТРАН, оно может быть записано либо строчными
либо прописными буквами;
- 10 цифр (от 0 до 9). Цифры могут быть включены в имена,
определяемые пользователем, однако цифра не должна быть
первым
символом в имени;
- все печатаемые символы из символьного набора кодов ASCII:
! # % & ' ( ) * + , - . / : ; < = > ? @ [ ] ^ _ '{:} ~
- символ пробела;
- символ табуляции.
В языке ФОРТРАН фирмы Microsoft знак доллара ($) и символ
подчеркивания
(_)
могут
быть
включены в имена, определяемые
пользователем. Однако, символ подчеркивания не должен быть первым
символом имени.
В исходных ФОРТРАН-программах пробелы не являются значащими, за
исключением случаев, перечисленных ниже. Таким образом, основная
"функциональная нагрузка" пробелов, используемых в исходной программе,
состоит в том, чтобы сделать программу пользователя более простой и
удобной
для
чтения.
Исключениями
являются
следующие
случаи
использования пробелов:
- пробелы в символьных константах и полях Холлерита являются
значащими;
- пробел или 0 в колонке 6 указывает на начальную строку
предложения (см. подразд.2.1 "Строки").
Интерпретация символа табуляции зависит от того, в какой колонке
он будет указан:
Колонка
Интерпретация
---------------------------------------------------------------------1-5
Символ, следующий за символом табуляции, указанным
в колонках от 1 до 5, рассматривается так, как будто
он находится в колонке 7.
6-72
Если символ табуляции указан в колонках от 6 до 72,
то он рассматривается как пробел,
исключая
тот
случай, если он не присутствует в символьной или
текстовой константе (см. подразд.3.7.1.2).
Символ табуляции в символьной или текстовой константе
(константа Холлерита) интерпретируется как
символ
табуляции.
---------------------------------------------------------------------1.2
Имена
Все переменные, массивы, функции, программы и
подпрограммы
пользователя
идентифицируются
их
уникальными
именами.
Имена
представляют собой последовательности буквенно-цифровых символов и
должны удовлетворять следующим правилам:
- первый символ имени должен быть буквой; последующие символы
должны быть буквенно-цифровыми символами. Следует отметить, что в
данной версии языка ФОРТРАН знак доллара рассматривается как буквенный
символ, следующий (при сортировке имен) после буквы Z в сравнивающей
последовательности IMPLICIT для
имен.
В
именах
также
может
использоваться символ подчеркивания, но он не может быть перым
символом имени;
- пробелы в именах игнорируются. Таким образом, имена low voltage
и lowvoltage будут для компилятора тождественными;
- если не указана метакоманда $NOTRUNCATE, то значащими в имени
будут первые 6 буквенно-цифровых символов; последующие символы будут
игнорироваться. Символы пробелов не рассматриваются как значащие:
имена delicate и d e l i c a t e будут интерпретироваться как
delicate, но в том случае, если указана метакоманда $NOTRUNCATE или
$STRICT;
- компилятор ограничивает длину имени 31 символами. Используемая
пользователем
версия операционной системы или компоновщик могут
налагать на длину имени другие ограничения.
Ключевые слова не являются зарезервированными именами, как это
сделано в некоторых других языках. Компилятор распознает ключевые
слова по контексту их использования. Например, в программе может
использоваться
массив
с
именем
IF,
read или Goto. Однако,
использование
ключевых
слов
для
имен
переменных
усложняет
читабельность и понимаемость программ. Для улучшения читабельности
следует избегать использования имен, совпадающих с ключевыми словами
или частями операторов языка ФОРТРАН.
Другой тип ошибок возникает в тех случаях, когда типографическая
ошибка приводит к тому, что компилятор интерпретирует ключевое слово
языка ФОРТРАН как часть имени переменной. Рассмотрим, например,
следующие два оператора:
DO 5 INC = 1.20
DO 5 INC = 1,20
В первом операторе переменной с именем DO5INC присваивается
значение 1.20; второй оператор представляет собой первый (начальный)
оператор DO-цикла. Следует отметить, что единственное различие этих
двух операторов состоит в том, что в первом операторе указана точка, а
во втором - запятая. Компилятор не сможет уловить ошибку этого типа.
Следующие три предопределенных имени не могут быть использованы
для именования программы:
1. _main, представляющее собой внешнее имя для головных программ
(использование имени "main" допустимо в некоторых случаях, но не
рекомендуется. См. также подразд.2.7);
2. COMMQQ, представляющее собой системное имя для "пустых"
(заполненных пробелами) блоков общего пользования;
3. BLKDQQ, представляющее собой имя для подпрограмм обработки
блоков данных, принимаемое по умолчанию.
Кроме того, все имена, начинающиеся с двух символов подчеркивания
(__) или оканчивающиеся символами QQ, например __main или MAINQQ,
зарезервированы
компилятором.
Если
пользователю
необходимо
использовать имена, начинающиеся с двух символов подчеркивания или
оканчивающихся двумя символами QQ, то необходимо применять атрибут
ALIAS.
1.2.1
Глобальные и локальные имена
Существует два основных типа имен: глобальные и локальные.
Глобальные имена распознаются по всему тексту заданной программы;
таким образом они могут иметь только одно глобальное описание (в любом
месте текста заданной программы). Имена процедур, функций, блоков
общего пользования и программ являются глобальными. Например, если
пользователь использует процедуру с именем Sort в одной программе, то
в этой же программе он уже не может использовать в качестве имени
функции имя Sort.
Однако, пользователь может использовать имя Sort как локальное
имя в различных программных модулях, обеспечив при этом, что в таких
модулях не будет ссылок на глобальное имя Sort. Например, программа,
содержащая функцию с именем Sort, может также содержать процедуру, в
которой объявлена переменная с именем Sort, но при условии, что
процедура не будет обращаться к функции Sort.
Имена блоков общего пользования являются случаями специального
использования глобальных имен. Пользователь может использовать одно и
тоже имя для блока общего пользования в одной программе и как
локальное имя в той же самой программе. Это разрешено потому, что
имена "общих" блоков всегда заключены в слэши и, следовательно, их
можно отличить от других имен. Например, если программа пользователя
вкючает блок общего пользования с именем /distance/, пользователь
также может назвать этим именем distance и массив в данной программе
(массивы имеют локальные имена).
Локальные
имена определены только в конкретном программном
модуле. В другом программном модуле в той же программе это (локальное)
имя должно быть определено повторно для ссылки на тот же программный
объект или другой объект.
Локальные имена имеют все
переменные,
массивы,
параметры
(аргументы) и операторные функции.
Аргументы операторных функций являются специальными случаями
использования локальных имен. Эти агументы определяются только в
операторе
операторной
функции.
Если, однако, имена аргументов
используются вне оператора
операторной
функции,
то
локальная
переменная во включающей подпрограмме должна иметь тот же тип, что и
аргументы операторной функции с таким
же
именем
(см.
также
подразд.4.2).
1.2.2
Необъявляемые имена
Если имя не задано явно, то компилятор классифицирует это имя
согласно контекста, в котором это имя было использовано впервые. Если
объявлено IMPLICIT NONE, то при первом использовании переменной, не
имеющей явного описания типа, будет генерироваться сообщенение об
ошибке. Если пользователь указал метакоманду $DECLARE, то при первом
использовании любой переменной, которой не было назначено значение в
операторе DATA,
PARAMETER
или
операторе
присваивания,
будет
сгенерировано предупреждающее сообщение. В приведенном ниже списке
объясняется, каким образом выполняется классификация необъявляемых
имен:
Использование имени
-----------------------Как переменная или
в вызове функции
Как объект оператора
CALL
Классификация
-------------------------------------------По первой букве имени определяется
тип
переменной или возвращаемое значение функции
По
умолчанию,
переменным
с
именами,
начинающимися с букв I,J,K,L,M,N (прописные
или строчные буквы), задается тип INTEGER;
именам, начинающимся с других букв или со
знака
доллара,
задается тип REAL. Для
изменения зависимости типа переменной
и
первой
буквы
имени
пользователь может
использовать оператор IMPLICIT.
Компилятор рассматривает указанное имя как
имя процедуры.
Процедура не возвращает значение по его
имени.
1.3
Типы данных
В данном подразделе рассматриваются шесть основных типов данных
языка ФОРТРАН:
- целый (INTEGER, INTEGER*1, INTEGER*2, INTEGER*4);
- вещественный (REAL, REAL*4, DOUBLE PRECISION, REAL*8);
- комплексный (COMPLEX, COMPLEX*8, DOUBLE COMPLEX и COMPLEX*16);
- логический (LOGICAL, LOGICAL*1, LOGICAL*2, LOGICAL*4);
- символьный (CHARACTER[*n], где 1 <= n <= 32.767);
- запись (переменные, описываемые с типами STRUCTURE).
Тип данных переменная, массив, символьная константа или функция
может быть объявлен в операторе описания (спецификации). Если тип
данного не объявлен, компилятор определяет тип данного по первой букве
его имени (см. подразд.1.2.2). Оператор типа может также включать
информацию о размерности и может быть использован для инициализации
переменных и массивов (см. раздел 4 "Операторы").
В последующих подразделах описаны существующие
Требования по памяти указаны в табл.1.1.
типы
данных.
Таблица 1.1
Требование по памяти
---------------------------------------------------------------------Тип
: Байты :
Примечание
----------------:-------:--------------------------------------------INTEGER
:2 или 4:По умолчанию принимается 4 байта. Установка
:
:метакоманды
$STORAGE
определяет
:
:размер значений типа INTEGER и LOGICAL
INTEGER*1
:
1
:
INTEGER*2
:
2
:
INTEGER*4
:
4
:
REAL
:
4
:То же, что и REAL*4
REAL*4
:
4
:
DOUBLE PRECISION:
8
:То же, что и REAL*8
REAL*8
:
8
:
COMPLEX
:
8
:То же, что и COMPLEX*8
COMPLEX*8
:
8
:
DOUBLE COMPLEX : 16
:То же, что и COMPLEX*16
COMPLEX*16
: 16
:
LOGICAL
:2 или 4:По
умолчанию
принимается
4
байта.
:
:Установка метакоманды $STORAGE определяет
:
:размер значений INTEGER и LOGICAL
LOGICAL*1
:
1
:
LOGICAL*2
:
2
:
LOGICAL*4
:
4
:
CHARACTER
:
1
:CHARACTER и CHARACTER*1 тождественны
CHARACTER*n
:
n
:Максимальное значение n равно 32.767
RECORD
:размер :Максимально 65535 байтов;
:структ.:зависит от метакоманды $PACK
:типа
:
---------------------------------------------------------------------1.3.1
Типы данных целые
Целочисленное
значение
является
точным
представлением
соответствующего целого. В табл.1.2 показаны различные типы целых,
сколько байтов памяти отводится под каждый тип, диапазон значений
каждого типа. Следует отметить, что переменные и функции, объявленные
как INTEGER, размещаются в памяти как имеющие тип INTEGER*4, если,
однако, не указана метакоманда $STORAGE для спецификации двухбайтового
размещения
памяти.
Метакоманда
$STORAGE
также определяет для
целочисленных констант размер памяти, выделяемый для их размещения по
умолчанию. Если, например, указана метакоманда $STORAGE:2, то длина
целочисленной константы по умолчанию будет составлять 2 байта. Если,
однако, константа "выходит" за диапазон, установленный для типа
INTEGER*2, то для ее хранения отводится 4 байта памяти.
Таблица 1.2
Целые
---------------------------------------------------------------Тип данных
: Байты :
Диапазон
----------------:-------:--------------------------------------INTEGER*1
: 1
: от -128 до 127
INTEGER*2
: 2
: от -32.768 до 32.767
INTEGER*4
INTEGER
: 4
: от -2.147.483.648 до 2.147.483.647
:2 или 4: Зависит от установки метакоманды
:
: $STORAGE
---------------------------------------------------------------Хотя константа или переменная типа INTEGER*4 может принимать
любое значение в полном
32-х
байтном
диапазоне,
им
должно
присваиваться
наименьшее отрицательное значение (-2.147.483.648),
когда это значение выражается как числовая константа. Например,
оператор
varname = -2147483648 приводит к возникновению ошибки
переполнения
компилятора.
Если
пользователю
требуется
задать
четырехбайтовое целочисленное значение, то правая часть оператора
присваивания должна быть математическим выражением.
СИНТАКСИС
По умолчанию константы интерпретируются как имеющие основание
системы счисления, равное 10. Для спецификации константы с основанием,
отличным от 10, следует использовать следующий синтаксис:
[<sign>][[<base>]#]<constant>
где <sign> - знак числа (плюс или минус; необязателен);
<base> - основание;
<constant> - константа.
Основание <base> может быть любым целым числом в диапазоне от 2
до 36. Если поле <base> опущено, но указан символ #, то целое
интерпретируется как имеющее основание 16. Если опущены и поле <base>
и знак #, то целое интерпретируется как имеющее основание 10. В
системах счисления с основаниями от 11 до 36 числа с основанием 10,
значения которых равны или превышают 10, представляются буквами от A
до Z. Для основания 36, например, буква A представляет 10, B
представляет 11, C - 12 и т.д. до буквы Z, представляющей число 35.
Отметим, что регистр букв не является значащим.
ПРИМЕР
Следующим семи целочисленным переменным присваивается значение,
равное десятичному числу 3.994.575:
I = 2#1111001111001111001111
m = 7#45644664
j = +8#17171717
k = #3CF3CF
n = +17#2DE110
L = 3994575
index = 36#2DM8F
Десятичная точка в целочисленной константе недопустима.
Целочисленные константы должны также находиться в диапазонах,
указанных выше. Однако, для чисел с основанием, отличным от основания
10, компилятор может читать числа со значениями "2 в степени 32". Они
интерпретируются как отрицательные числа с соответствующим внутренним
представлением.
Например,
число
16#FFFFFFFF
дает
результат
арифметического
значения
-1.
Если метакоманда $DEBUG является
действительной, то на этапе компиляции будет генерироваться ошибка
нарушения диапазона допустимых значений.
1.3.2
Тип данных вещественный с одинарной точностью
Тип данных вещественный с одинарной точностью (REAL или REAL*4)
представляет собой подмножество вещественных чисел. В общем случае
значение вещественного
числа
с
одинарной
точностью
является
аппроксимацией заданного вещественного числа и занимает 4 байта
памяти. Точность чисел данного типа колеблется в пределах
6-7
десятичных
цифр.
Следует
отметить,
что
пользователь
может
специфицировать более 6 цифр, однако для вещественных чисел
с
одинарной точностью значащими являются только первые 6 десятичных
цифр. Диапазон значений вещественных чисел с одинарной точностью
включает
отрицательные
числа
примерно
от
-3.4028235Е+38
до
-1.1754944Е-38, число 0,
и
положительные
числа
примерно
от
+1.1754944-38 до +3.4028235Е+38.
СИНТАКСИС
Вещественные константы имеют следующий формат:
[<sign>][<integer>][.][<fraction>][.E<exponent>]
где
<sign>
<integer>
- есть знак (плюс или минус);
- есть целое. Могут быть опущены либо <integer>,
либо <fraction>, но не оба сразу;
.
- десятичная точка;
<fraction> - мантисса (дробная часть), состоящая из одной или
более десятичных цифр. Могут быть опущены либо
<fraction>, либо <integer>, но не оба сразу;
E<exponent> - порядковая часть (показатель степени), состоящая из
одно- или двухцифровой целочисленной константы (необязательно со
знаком).
Показатель
степени показывает, что предшествующее ему
значение должно быть умножено на 10, возведенное в степень, значение
которой равно <exponent>.
ПРИМЕР
Следующие
вещественные
вещественное число (1.23):
константы
представляют
одно
и
тоже
+1.2300Е0 .012300Е2 1.23Е0 123Е-2
+1.2300 123.0Е-2 .000123Е+4 1230Е-3
1.3.3
Тип данных вещественный с двойной точностью
Тип данных вещественный с двойной точностью (REAL*8 или DOUBLE
PRECISION)
представляют
собой
подмножество вещественных чисел.
Значения вещественных чисел с двойной точностью являются в общем
случае аппроксимацией заданного вещественного числа и занимают 8
байтов памяти. Точность этих чисел лежит в пределах 15-16 десятичных
цифр. Пользователь может указать и больше десятичных цифр, однако
значащими являются только первые 15. Диапазон значений вещественных
чисел с двойной точностью включает отрицательные числа со значениями
примерно от 1.797693134862316D+308 до -2.225073858507201D-308 и число
0.
Он
также
включает
положительные
числа
примерно
от
+2.2250738585007201D-308 до +1.797693134862316D+308.
Формат вещественных констант с двойной точностью совпадает с
форматом
вещественных
констант
с одинарной точностью, за тем
исключением, что для указания показателя степени используется буква D
вместо
буквы E и задание показателя степени обязательно. Если
порядковая часть опущена, то число интерпретируется как константа с
одинарной точностью.
ПРИМЕР
5.2D-2
+.00052D+2
1.3.4
.052DO
52.000D-3
52D-3
Типы даных комплексные
Тип данных COMPLEX или COMPLEX*8 представляет собой упорядоченную
пару вещественных чисел с одинарной точностью. Типы данных DOUBLE
COMPLEX или COMPLEX*16 являются упорядоченной парой вещественных чисел
с двойной точностью. Первое число в паре представляет действительную
часть комплексного числа, второе число в паре представляет мнимую
часть. И действительная и мнимая компоненты чисел типа COMPLEX или
COMPLEX*8 являются числами типа REAL*4, так что числа типа COMPLEX или
COMPLEX*8 занимают 8 байтов в памяти. Действительная и
мнимая
компоненты чисел типа DOUBLE COMPLEX или COMPLEX*16 являются числами,
имеющими тип REAL*8, так что числа типа DOUBLE COMPLEX или COMPLEX*16
занимают 16 байтов в памяти.
СИНТАКСИС
[<sign>](<real>,<imag>)
где
<sign>
-
есть знак (плюс или минус). Если знак указан,
то он относится и к действительной и к мнимой
части комплексного числа;
<real>
- целое
вещественное
число,
представляющее
действительную часть комплексного числа;
<imag>
- целое
или
вещественное
число,
представляющее
мнимую часть комплексного числа.
Например, упорядоченная пара (7,3.2) представляет комплексное
число 7.0+3.2i. Упорядоченная пара (-.11E2,#5F)
представляет
комплексное число 11.0-95.0i.
1.3.5
Типы даных логические
Логический тип данных включает два логических значения, TRUE и
FALSE. Переменная типа LOGICAL занимает 2 или 4 байта памяти, в
зависимости от
установки
метакоманды
$STORAGE.
По
умолчанию
принимается 4 байта. Значимость логической переменной не зависит от
метакоманды $STORAGE, функция которой состоит в основном в обеспечении
совместимости с требованиями стандарта
ANSI,
согласно
которым
логические,
вещественные
с одинарной точностью и целочисленные
переменные имеют одинаковый размер.
Значения типа LOGICAL*1 занимают единственный байт, в котором
сохраняется либо значение 0 (.FALSE.), либо значение 1 (.TRUE.).
Значения типа LOGICAL*2 занимают 2 байта: младший значащий (первый)
байт содержит значение LOGICAL*1; старший значащий байт неопределен.
Переменные типа LOGICAL*4 занимают 2 слова: младшее значащее (первое)
слово
содержит
значение
LOGICAL*2;
старшее
значащее
слово
неопределено.
1.3.6
Символьные
переменные
Тип данных символьный
занимают
один
байт
памяти
для каждого
символа и назначаются последовательности байтов, независимо от границ
слов. Однако, когда символьная и несимвольная переменные размещаются в
одном
общем блоке, компилятор помещает несимвольные переменные,
которые следуют за символьными переменными, по границе слова. (См.
также подразд.4.2).
Значение
длины
символьной переменной, элемента символьного
массива, структурного элемента, символьной функции или символьной
константы с символическим именем должно находиться в диапазоне от 1 до
32.767. Длина может быть указана одним из следующих способов:
- как целочисленная константа без знака в диапазоне от 1 до
32.767;
- как выражение, заключенное в круглые скобки, вычисляемое со
значением целого в диапазоне от 1 до 32.767;
- как звездочка, заключенная в круглые скобки (*), указывающая на
длину строки.
ПРИМЕРЫ
Следующие примеры показывают случаи правильного использования:
CHARACTER*32 string
CHARACTER string*32
CHARACTER string*(const*5)
CHARACTER string*(*)
CHARACTER*(*) string
Дополнительные сведения приведены в подразд.4.2.
Символьное значение представляет собой последовательность из
одного или более печатаемых символов кода ASCII, заключенных в пару
апострофов (') или кавычки (").
Апострофы
или
кавычки,
в которые заключается строка, не
сохраняются вместе со строкой. Для представления апострофа внутри
строки необходимо указать последовательно два апострофа (они не должны
разделяться пробелами).
ПРИМЕЧАНИЕ
Апостроф представляет
не левую кавычку.
собой единственную правую кавычку ('), но
Символы пробела и табуляции разрешены в символьных константах и
являются значащими. Значащим является также и регистр буквенных
символов. Строка может содержать любые печатные символы из набора
кодов ASCII. Для задания непечатаемых символов или для спецификации
пустой строки (null-строки) пользователь может использовать Си-строки
(см. подразд.1.3.6.1).
Длина символьной константы равна числу символов, заключенных в
апострофы
или
кавычки.
Последовательная
пара
апострофов
рассматривается как единственный апостроф. Пара кавычек в строке,
разделенная символом кавычки, рассматривается как единственный символ.
Ниже показаны некоторые примеры символьных констант:
Строка
-----------------------'String'
'1234!@#$'
'Blanks count'
''''''
Константа
------------------------String
1234!@#$
Blanks count
''
'Case is Significant'
Case is Significant
"''"
''
"""Double"" quotes count
"Double" quotes count
as one"
as one
--------------------------------------------------Следует отметить, что строки в исходных файлах на языке ФОРТРАН
имеют в длину 72 символа (позиции) (символы в колонках
73-80
игнорируются компилятором), а строки короче 72 символов дополняются
пробелами. Поэтому, когда символьная константа выходит за границу
длины строки, ее значение включает любые пробелы, добавленные к
строкам. Рассмотрим, например, следующий оператор языка ФОРТРАН:
Sample FORTRAN continuation line
Heading (secondcolumn) = 'Acceleration of Particles
$from Group A'
Оператор присваивает элементу массива heading (secondcolumn)
значениие 'Acceleation of Particles from Group A'. Между словами
Particles и from указано 14
пробелов,
т.к.
слово
Particles
оканчивается в колонке 58, а 14 пробелов дополняют ее до 72-ой
колонки.
1.3.6.1
Си-строки
Строковые значения в языке Си завершаются пустыми (фиктивными)
символами (CHAR (0)) и могут содержать непечатаемые символы (например,
символ
новой
строки
или
символ
возврата).
Они могут быть
специфицированы при помощи символа обратного слэша, используемого как
спецсимвол,
за которым следует единственный символ, указывающий
требуемый непечатаемый символ. В языке ФОРТРАН такой тип строки может
быть специфицирован при помощи стандартной строковой константы, за
которой следует символ C. Затем стандартная строковая константа
интерпретируется как константа языка Си. Обратные слэши обрабатываются
как спецсимволы; пустые (фиктивные) символы автоматически добавляются
в конец строки (даже если строка уже оканчивается пустым символом). В
таблице 1.3 показаны корректные последовательности спецсимволов. Если
в строковой константе указана такая последовательность,
которая
отсутствует в данной таблице (например, \z), то обратный слэш будет
игнорироваться.
Таблица 1.3
Строковые ESC-последовательности языка Си
------------------------------------------------------------Последовательность:
Символ
-------------------:----------------------------------------\a
: Звонок
\b
: Возврат ("backspace")
\f
: Прогон бумаги
\n
: Новая строка
\r
: Возврат каретки
\t
: Горизонтальная табуляция
\v
: Вертикальная табуляция
\'
: Единственная кавычка (*)
\"
: Двойная кавычка
\\
: Обратный слэш
\ooo
: Шаблон восьмеричного бита
\xhh
: Шаблон шестнадцатеричного бита
------------------------------------------------------------(*) Для указания такой
должен ввести \ ' '.
последовательности
в
ФОРТРАНе
пользователь
Си-строка должна быть корректной ФОРТРАН-строкой. Поэтому, если
строка разделяется апострофами, то все апострофы в строке должны
представляться двойными апострофами. При указании последовательности
\'a будет выдана синтаксическая ошибка компилятора, т.к. ФОРТРАН
интерпретирует апостроф как конец строки.
Корректной будет следующая запись: \''a. Си-строки и обычные
строки отличаются только тем, как пользователь специфицирует значение
строки. Компилятор, например, обрабатывает оба типа строки одинаковым
образом.
Последовательности \ooo и \xhh предоставляют возможность задавать
любой символ из символьного набора ASCII как одно- или трехцифровой
восьмеричный или одно- или двухцифровой шестнадцатеричный символьный
код. Цифра "o" должна находиться в диапазоне от 0 до 7, а цифра h - в
диапазоне от 0 до F. Например, обе Си-строки, '\010'C и '\х08'C,
представляют символ возврата, за которым следует пустой символ.
Си-строка '\\abcd'C эквивалентна строке '\abcd', в конец которой
добавляется пустой символ. Строка ''C представляет пустой символ
ASCII.
Следует
отметить, что символьная константа '' является
некорректной, т.к. имеет длину 0; строка ''C будет правильной, т.к. ее
длина равна 1.
1.3.6.2
Символьные подстроки
Подстроки имеют тип символьный и используются
смежной (непрерывной) части в символьной переменной.
для доступа к
СИНТАКСИС
<variable>([<first>]:[<last>])
где
<variable>
- есть символьная переменная или элемент в символьном
массиве;
<first> - арифметическое выражение или целочисленное выражение,
которое определяет первый (самый левый) символ в подстроке. Компилятор
"округляет" значение <first> до целочисленного значения. По умолчанию
значение <first> равно 1, так что если <first> не специфицировано, то
подстрока начинается с первого символа в строке;
<last> - арифметическое выражение, которое определяет последний
(самый правый) символ в подстроке. Компилятор "округляет" значение
<last> до целочисленного значения. По умолчанию значение <last> равно
длине строки, так что если <last> не специфицировано, подстрока
оканчивается последним символом в строке.
Длина подстроки равна <last> - <first> + 1. Например, если 10-и
байтовая символьная переменная с именем name содержит подстроку 'Jane
Doe', то истинными будут следующие строки:
Символьная переменная
--------------------name(:5)
name(6:)
name(3:7)
name(:)
Эквивалентная строка
-------------------'Jane'
'Doe'
'ne Do'
'Jane Doe'
Следует отметить, что name (:) эквивалентно name.
Если символьная переменная имеет длину <length>,
выполняться следующее отношение:
то
должно
1 <= <first> <= <last> <= <length>
Другими словами, и <first> и <last> должны быть больше 0; <last>
должно быть больше или равно <first>; ни <first>, ни <last> не должны
быть больше <length>.
Следующие спецификации подстрок для 10-и байтовой символьной
переменной name будут некорректными:
name(0:4)
name(6:5)
name(11:12)
name(0:)
name(:11)
Если действительна метакоманда $DEBUG, то в случае нарушения
указанных отношений (т.е. когда они имеют значение "ложь") будет
генерироваться ошибка. Если метакоманда $DEBUG не задана, результат
будет неопределен.
ПРИМЕР
C Данная программа записывает вторую половину алфавита,
C за которой следует первая половина
CHARACTER alpha*26
alpha = 'abcdefghijklmnopqrstuvwxyz'
WRITE(*, *) alpha(14:), alpha(:13)
END
ВЫВОД
nopqrstuvwxyzabcdefghijklm
Использование нецелочисленного выражения для параметров <first> и
<last> приводит к ошибке (это ограничение не применимо к версии языка
ФОРТРАН, если, однако, не указана метакоманда $STRICT).
1.4
Записи
Запись является
"структурной"
переменной.
Структура
есть
определяемый пользователем составной тип данных, состоящий из описаний
типа переменных и групп отображений, рассмотренных ниже. Каждый
элемент внутри структуры называется "структурным элементом".
ПРИМЕР
Следующий пример есть описание структуры
содержащей данные о кадрах работников:
STRUCTURE /employee data/
CHARACTER*25 last_name
CHARACTER*15 first_name
CHARACTER*20 street_name
INTEGER*2
street_number
для
типа
переменной,
INTEGER*2
CHARACTER*20
CHARACTER*2
INTEGER*4
INTEGER*4
INTEGER*2
INTEGER*2
INTEGER*2
LOGICAL*2
INTEGER*2
END STRUCTURE
apt_number
city
state
zip
telephone
date_of_birth
date_of_hire
social_security(3)
married
dependents
Спецификация структуры не является переменной, но имеет тип
переменной. Структурные переменные определяются оператором RECORD. Для
группы в 200 работающих следующий оператор будет описывать массив
структурных переменных для получения сведений о датах поступления на
работу, используя указанное ранее описание структуры:
RECORD /employee_data/ employees(200)
Ссылки на структурные элементы осуществляются путем спецификации
последовательности элементов, необходимых для "достижения" требуемого
элемента. Элементы разделяются точками. Например, число подчиненных
для девяносто девятого работника специфицируется строкой employees
(99).dependents. Первая буква имени штата, где живет
работник,
задается
следующей строкой: employees (99).state (1:1). Следует
отметить, что тип данных ссылки структуры есть тип элемента, на
который делается ссылка. В двух приведенных в данном подразделе
примерах первая ссылка имеет тип INTEGER*2. Вторая ссылка имеет тип
CHARACTER*2.
Поскольку
для разделения структурных элементов используются
точки, элемент не может иметь имя отношения или логического оператора
(NOT, AND, OR, GE, EQ и т.д.). Если имя оператора отношения или
логического оператора используется, то компилятор будет пытаться
интерпретировать имя как оператор отношения.
ПРИМЕР
Описание
структуры
может
содержать объявления структурных
переменных. Например, имена работников и их адреса описываются как
отдельные структурные типы:
STRUCTURE /employee_name/
CHARACTER*25 last_name
CHARACTER*15 first_name
END STRUCTURE
STRUCTURE /employee_addr/
CHARACTER*20 street_name
INTEGER*2
street_number
INTEGER*2
apt_number
CHARACTER*20 city
CHARACTER*2
state
INTEGER*4
zip
END STRUCTURE
Следующие переменные
структуры employee_data:
становятся структурными переменными внутри
STRUCTURE /employee data/
RECORD /employee_name/ name
RECORD /employee_addr/ addr
INTEGER*4
telephone
INTEGER*2
date_of_birth
INTEGER*2
date_of_hire
INTEGER*2
social_security(3)
LOGICAL*2
married
INTEGER*2
dependents
END STRUCTURE
Описание структуры также может содержать группы отображений.
Отображение
специфицирует,
что
одна
или
более
переменных
позиционируются в памяти последовательно. Переменные могут быть любого
типа, включая структуры, как это показано ниже:
MAP
INTEGER*4 manny, moe, jack
CHARACTER*21 myname
END MAP
В указанных примерах 4-х байтовые целые manny, moe,
jack
появляются в памяти первыми, за ними сразу следует 21-байтовая
символьная переменная myname. Начальные адреса каждой переменной
определяются путем установки метакоманды $PACK или опции /Zp командной
строки.
Ниже показан другой пример отображения:
MAP
CHARACTER*7 yourname
REAL*4 meg, joe, amy, zelda
END MAP
Отображения могут появляться только внутри оператора UNION. Когда
отображения
объединены
в
объединение
("группу"),
переменные
перекрывают друг друга, как это делается в операторе EQUIVALENCE; это
показано в следующем примере:
UNION
MAP
INTEGER*4 manny, moe, jack
CHARACTER*21 myname
END MAP
MAP
CHARACTER*7 yourname
REAL*4 meg, joe, amy, zelda
END MAP
END UNION
Предполагая, что $PACK:1 действительно, семь байтов yourname
будут перекрывать четыре байта manny и первые три байта moe. Первый
байт
meg
будет
перекрывать последний байт moe, и т.д. Если
действительно $PACK:2, то yourname
и
manny
плюс
moe
будут
перекрываться как и раньше, но дополнительный байт в конце yourname
будет пустым слева. Поэтому, первый байт meg будет начинаться в первом
байте jack. Дополнительные сведения о метакоманде $PACK приведены в
разделе 6 "Метакоманды".
Хотя индивидуальные структурные элементы могут записываться в
файл или читаться из файла, любая попытка
записи
структурной
переменной как целого будет вызывать ошибку этапа компиляции.
Дополнительные сведения приведены в подразд.4.2.
1.5
Массивы
Допустимое количество элементов массива и числа его измерений
ограничено только объемом допустимой памяти, которая может быть
использована при работе. Если, однако, специфицирована метакоманда
$STRICT, то при использовании массивов, имеющих более 7 измерений,
будет выдана ошибка (предупрежедение). Для ссылки на элемент массива
следует использовать следующий синтаксис:
<array>(<subscripts>)
где <array> - есть имя массива. Если в операторе типа тип массива не
объявлен, то элементы массива будут иметь тип, определяемый по первой
букве имени массива;
<subscripts> - индексное выражение (выражения). Если в данном
случае указано более одного индексного выражения, они должны быть
разделены запятыми. Количество индексных выражений должно совпадать с
количеством
измерений,
объявленных
для
массива.
(См.
также
подразд.4.2).
Каждый индекс должен быть арифметическим выражением. Результат
выражения преобразуется к целочисленному значению путем округления.
Если специфицирована метакоманда $STRICT, то каждый индекс должен быть
целочисленным выражением. Допустимы указатели функций и указатели
элементов массива.
Значение
индекса
<subscripts>
может
быть
положительным, отрицательным или 0.
ПРИМЕРЫ
Пример ссылок на элемент массива:
DIMENSION a(3,2), b(0:2,0:3), c(4,5), d(5,6)
v(10), q(3.2,4.5)
EQYIVALENCE (x, v(1)), (y, v(2))
d(i,j) = d(i+b(i,j),j)/pivot
c(i+1,j) = c(i,j) + a(i**2,k) * b(k*j,j-24)
READ (*, *) (v(n), n = 1, 10)
Элементы массива сохраняются последовательно в памяти, так что
элемент n+1 следует за элементом n и т.д. Внутри многомерного массива
элементы организованы в линейной последовательности, поскольку память
компьютера имеет только одно измерение.
В
языке ФОРТРАН элементы размещаются "в последовательности
возрастания номеров столбцов". Это означает, что последовательность
хранения в памяти определяется путем увеличения первоначально самого
левого индекса, затем следующего справа от него и т.д. Элементы
переменной array (3,4) сохраняются в следующей последовательности:
array(1,1)
array(1,2)
array(1,3)
array(1,4)
array(2,1)
array(2,2)
array(2,3)
array(2,4)
array(3,1)
array(3,2)
array(3,3)
array(3,4)
В языке ФОРТРАН фирмы Microsoft область
хранения
массива
может
быть размещена динамически, т.е. размер каждого измерения может
устанавливаться на этапе исполнения, а не во время компиляции. Это
делается для "размещаемых" массивов.
Для любого размещаемого массива необходимо, чтобы он был объявлен
с атрибутом ALLOCATABLE и было задано число его измерений. При
исполнении программы оператор ALLOCATE устанавливает размер каждого
измерения. После использования массива оператор DEALLOCATE возвращает
область памяти, которую занимал массив, в общий пул.
В следующем примере показано корректное использование атрибута
ALLOCATABLE и операторов ALLOCATE и DEALLOCATE:
INTEGER dataset[ALLOCATABLE](:,:,:)
INTEGER reactor, level, points, error
DATA,
reactor, level, points / 10, 50, 100 /
.
.
.
ALLOCATABLE (dataset(reactor,level,points), STAT = error)
.
.
.
DEALLOCATE (dataset, STAT = error)
Существенным расширением компилятора языка ФОРТРАН версии 5.0
является способность выполнять операции над массивами как над простыми
скалярными величинами. (Подробнее см. подразд.1.7.1).
1.6
Атрибуты
Атрибуты
позволяют
специфицировать
для
переменной,
типа
переменной, подпрограммы или формальных
параметров
подпрограммы
некоторую дополнительную информацию. Атрибуты позволяют пользователю
использовать в программах на языке ФОРТРАН, например, соглашения о
вызовах, принятые в языке ПАСКАЛЬ или Си, передавать параметры по
значению
или
по
ссылке,
использовать
сегментированные
или
несегментированные адреса, указав, что формальный параметр может быть
размещен "более чем в одном сегменте", специфицировать внешнее имя для
подпрограммы или "общего" блока. Атрибуты могут использоваться в
описаниях процедур и функций, после объявлений типов и с операторами
INTERFACE и ENTRY (см. подразд.4.2). В таблице 1.4 перечислены
атрибуты,
которые
могут использоваться с различными объектами.
Непосредственно атрибуты описаны в подразд.1.6.1-1.6.12.
Таблица 1.4
Объекты, на которые могут ссылатся атрибуты
-------------------------------------------------------------------Атрибуты
:Объявления переменной:Имена "общих":Операторы EXTERNAL
:
и массива
:
блоков
:и спецификации
:
:
:подпрограмм
-----------+---------------------+-------------+-------------------ALIAS
:
Да
:
Да
:
Да
ALLOCATABLE:
-":
Нет
:
Нет
:(только дла массивов):
:
C
:
Да
:
Да
:
Да
EXTERN
:
-":
Нет
:
Нет
FAR
:
-":
Да
:
Да
(*)
HUGE
:
-":
Нет
:
Нет
LOADDS
:
Нет
:
Нет
:
Да
NEAR
:
Да
:
Да
:
Да
(*)
PASCAL
:
-":
-":
-"REFERENCE :
-":
Нет
:
Нет
VALUE
:
-":
Нет
:
Нет
VARYING
:
Нет
:
Нет
:
Да
-------------------------------------------------------------------(*) Атрибуты FAR и NEAR не могут использоваться в операторах ENTRY
СИНТАКСИС
<object>[[<attrs>]]
Атрибуты указываются сразу после объекта, к
которому
они
относятся. Если указано более одного атрибута, они должны разделяться
запятыми.
ПРИМЕРЫ
В данном примере целочисленная переменная x передается по ссылке,
используя "короткий" адрес (указывается только смещение):
INTEGER invar[REFERENCE, NEAR]
В данном примере PasFunc является ПАСКАЛЬ-функцией с аргументами
i, j и k, которые в свою очередь являются целочисленными переменными
языка Си. Эта функция также возвращает целочисленное значение С.
INTERFACE TO INTEGER [C] FUNCTION PasFunc [PASCAL] (i, j, k)
INTEGER [C] i, j, k
END
1.6.1
Атрибут ALLOCATABLE
Данный атрибут специфицирует, что массив является "размещаемым",
т.е. что размер каждого измерения задается динамически во время
исполнения, а не во время компиляции.
Атрибут ALLOCATABLE может появляться либо в объявлении типа, либо
в
операторе
DIMENSION.
Каждое
измерение размещаемого массива
отмечается двоеточием. Если
массив
многомерный,
то
двоеточия
отделяются запятыми, например:
REAL*3
dynamic [ALLOCATABLE] (:,:,:)
Атрибут ALLOCATABLE не применим ни для формальных параметров, ни
может использоваться с атрибутом NEAR. Если пользователь предполагает,
что размер "размещаемого" массива превышает 65536 байтов, он должен
задать массив с атрибутом HUGE для обеспечения корректной адресации.
1.6.2
Атрибут ALIAS
Данный атрибут позволяет пользователю специфицировать внешнее имя
для подпрограммы или общего блока. Имя может отличаться от имени,
используемого в объявлении.
СИНТАКСИС
ALIAS:<string>
где <string> - есть символьная константа (может быть Си-строкой; см.
подразд.1.3.6.1); никакие преобразования над константой <string> не
выполняются. Например, строчные буквы не преобразуются в прописные (и
наоборот).
Такая
возможность особенно полезна при установлении
интерфейса с языками, в которых регистр букв является значащим
(например, с языком Си).
Для ссылок на подпрограмму, входящую в состав того же исходного
файла, допустимо использование только имени, специфицированного в
объявлении подпрограммы. Для ссылок на подпрограмму, "находящуюся вне
исходного файла", допустимо использование только самого имени.
Пользователь также может использовать атрибут ALIAS в операторе
INTERFACE для переопределения имени подпрограммы в другом исходном
файле, которую пользователь собирается вызвать.
Атрибут ALIAS отменяет атрибут С. Если атрибут С используется в
подпрограмме вместе с атрибутом ALIAS, подпрограмма будет использовать
соглашения о вызовах, принятые в языке Си; соглашения об именовании,
принятые в языке Си, однако, использоваться не будут.
Атрибут ALIAS не может
быть
использован
для
формальных
параметров.
ПРИМЕР
Данный
оператор
SUBROUTINE задает
OtherName вне данного исходного файла.
подпрограмме
PasSub
имя
SUBROUTINE PasSub [ALIAS:'OtherName']
1.6.3
Атрибут C
Атрибут C может быть применен для подпрограмм, "общих" блоков и
типов. В случае подпрограммы атрибут C определяет, что подпрограмма
удовлетворяет тем же соглашениям о вызовах, которы приняты для
Си-процедур. В следующем списке указаны различия между соглашениями о
вызовах языка ФОРТРАН и соглашениями, принятыми в языке Си:
Отличие
Пояснение
------------------------------------------------------------------Последовательность, В языке ФОРТРАН параметры помещаются в стэк
в которой параметры в той последовательности, как они указаны
помещаются в стек
в объявлении процедуры.
В языке Си, по умолчанию, параметры помещаются
в стэк в обратном порядке (для возможности
использования переменного числа параметров).
Размещение кода,
В языке
ФОРТРАН
этот
код
указывается
который восстанавв
вызываемой
процедуре.
При
этом
ливает стек при
получается код меньший, чем в языке Си, где
завершении исполкод следует ("указывается") сразу за вызовом
нения
процедуры.
------------------------------------------------------------------Параметры подпрограмм, для которых указан атрибут C, передаются
по значению, если, однако, для формального параметра не указан атрибут
REFERENCE. (Следует отметить, что атрибут
VARYING
может
быть
специфицирован только для подпрограмм, для которых также указан
атрибут C).
Используя
атрибут
C,
имена
подпрограмм
автоматически
модифицируются, чтобы сделать
их
проще
для
сопоставления
с
используемыми в языке Си соглашениями об именах. Внешние имена
преобазуются к виду "строчных букв"
и
начинаются
с
символа
подчеркивания (_). Для того, чтобы использовать имена, содержащие
пррописные
буквы,
следует
использовать
атрибут
ALIAS
(см. подразд.1.6.2).
В случае использования атрибута C для значений типа INTEGER, этот
тип рассматривается как целочисленный языка Си. Размеры целочисленных
типов данных, принимаемые в языках Си и ФОРТРАН по умолчанию, могут
совпадать, а могут и не совпадать, в зависимости от того, какой
макропроцессор используется. Например, при использовании процессора
8086, в языке ФОРТРАН по умолчанию для целых принимается длина, равная
32 разрядам, тогда как длина целого в языке Си составляет в этом
случае 16 разрядов. Таким образом, если пользователь компилирует свою
программу для конкретного процессора, он может использовать атрибут C
для целочисленных переменных, которые предполагается передавать между
программами на языках ФОРТРАН и Си, чтобы обеспечить корректность
используемого компилятором размера целочисленных переменных.
СИНТАКСИС
Атрибут C не может быть использован для формальных параметров, за
исключением случая, когда он применяется для типа INTEGER, например:
INTEGER[C]<argument>
Атрибут
ALIAS
отменяет атрибут С.
1.6.4
Атрибут EXTERN
Атрибут EXTERN может быть использован в объявлениях переменных.
Он указывает, что переменная размещается в другом исходном файле.
Атрибут EXTERN должен использоваться тогда, когда переменные, к
которым выполняется доступ, объявлены в подпрограммах на других языках
программирования,
и
не
должен
использоваться
для формальных
параметров.
1.6.5
Атрибут FAR
Атрибут FAR, когда он используется с формальными параметрами,
специфицирует,
что параметр будет передаваться с использованием
сегментированных
адресов.
При
использовании
атрибута
FAR
с
переменными,
он
специфицирует,
что
переменная
размещается в
"удаленных" областях данных (в памяти).
1.6.6
Атрибут HUGE
Использование атрибута HUGE является наиболее удобным способом
спецификации того, что формальный параметр или "размещаемый" массив
могут "занимать" более одного сегмента. Аналогичную функцию выполняет
метакоманда $LARGE. Например, следующие два программных фрагмента
эквивалентны:
FUNCTION Func (a[HUGE])
DIMENSION a(200)
$LARGE: a
FUNCTION Func (a)
DIMENSION a(200)
Компилятор не обеспечивает гарантий того, что атрибут HUGE
специфицируется
для
всех параметров, "занимающих" более одного
сегмента в памяти. Компилятор языка ПАСКАЛЬ версии 3.3 и ниже и
компилятор языка Си версии 3.0 и ниже не поддерживают параметры с
атрибутом HUGE.
1.6.7
Атрибут LOADDS
Атрибут LOADDS применяется только для раздельно компилируемых
подпрограмм и функций. Он предписывает компилятору создавать сегмент
данных для данных внутри этой процедуры; базовый адрес (DGROUP) новых
сегментов данных автоматически загружается в регистр DS при вызове
процедуры. Использование раздельного сегмента данных позволяет данным
процедуры вызываться при помощи 16-и разрадных ссылок типа NEAR, а не
при помощи 32-х разрядных ссылок типа FAR. При этом скорость доступа к
данным увеличивается. Сегмент данных для программ, принимаемый по
умолчанию,
автоматически
перезагружается
во
время
прерывания
исполнения процедуры.
Атрибут LOADDS применяется в основном для процедур, написанных
пользователем,
которые
включаются
в
динамическую
библиотеку
компоновщика для системы OS/2 (DLL). Он не является необходимым для
процедур, исполняемых в программах DOS, поскольку опция /ND командной
строки FL (именование сегмента данных) автоматически предполагает, что
базовый адрес нового сегмента данных уже загружен. Ниже показан пример
атрибута LOADDS:
REAL*8
FUNCTION
[LOADDS] GetNewData
1.6.8
Атрибут NEAR
Атрибут NEAR специфицирует, что фактический параметр находится в
"сегменте данных, принимаемом по умолчанию" и что в подпрограмму
передается
только
его
смещение.
Данный
атрибут может также
использоваться с блоками общего пользования. Блоки общего пользования,
имеющие атрибут NEAR, отображаются в сегмент данных, принимаемый по
умолчанию.
СИНТАКСИС
COMMON[/[<name>][NEAR]/]...
Параметр <name> есть имя "общего" блока. Если не специфицировано
ни одного имени <name> "общего" блока, то все пустые "общие" блоки
помещаются в сегмент данных, принимаемый по умолчанию. Атрибут NEAR
должен быть специфицирован по крайней мере для первого описания
"общего" блока в исходном файле.
Пользователь,
однако,
может
специфицировать
атрибут
NEAR
для
любого
оператора COMMON в
подпрограмме.
Для того, чтобы назначить "общему" блоку тип near, следует для
всех описаний "общего" блока указать атрибут NEAR. Если, однако,
пользователь выполняет модификацию существующей программы, то может
оказаться, что проще будет добавить в начало
исходного
файла
пользователя
процедуру,
которая для оставшейся части программы
определяет "общие" блоки как имеющие тип near.
Преимущество
помещения
"общих"
блоков
в сегмент данных,
принимаемый по умолчанию заключается в том, что пользователь может
специфицировать адреса, используя только смещение. При этом появляется
возможность генерации более эффективного и компактного кода. Если
пользователь не указывает атрибут NEAR, то для ссылки на любой элемент
в "общем" блоке компилятор использует сегментированные адреса.
Если "общий" блок указан как имеющий тип near
в
"одном
компилируемом объекте", но не указан с таким типом в другом, он будет
"отображаться" в сегмент данных, принимаемый по умолчанию. "Объект
компиляции", в котором "общий" блок распознается как имеющий тип near,
будет использовать "короткие" адреса (типа "short"), а другие "объекты
компиляции"
(для
доступа к "общему" блоку) будут использовать
"длинные" адреса (типа
"long").
Использование
такого
способа
спецификации и доступа к "общему" блоку обеспечивает возможности
работы с библиотеками, скомпилированными компилятором языка ФОРТРАН
версии 3.2.
Фактические параметры, передаваемые в формальные параметры типа
near, должны находиться в сегменте данных, принимаемом по умолчанию. В
параметры, определенные с типом near, нельзя передавать:
- данные из "общих" блоков, которые не специфицированы
с
атрибутом NEAR;
- массивы, специфицированные с атрибутом HUGE;
массивы,
определенные в тот момент, когда используется
метакоманда $LARGE;
- переменные, поименованные в метакоманде $LARGE.
1.6.9
Атрибут PASCAL
Атрибут PASCAL может быть использован с подпрограммами, "общими"
блоками и формальными параметрами в текущей подпрограмме. Атрибут
PASCAL не может использоваться для формальных параметров в списке
формалцных параметров. Данный атрибут идентифицирует параметр или
подпрограмму как имеющие характеристики языка ПАСКАЛЬ:
- аргумент или параметры подпрограммы передаются по значению
(если, однако, не указан атрибут REFERENCE);
- по прежнему используются соглашения о вызовах, принятые в языке
ФОРТРАН.
1.6.10
Атрибут REFERENCE
Атрибут REFERENCE может использоваться только для формальных
параметров. Он указывает на то, что передача параметров выполняется по
ссылке, а не по значению.
1.6.11
Атрибут VALUE
Атрибут VALUE может использоваться
только
для
формальных
параметров. Он указывает на то, что параметр передается по значению.
Если в описании подпрограммы указаны либо атрибут C, либо атрибут
PASСAL, то все параметры рассматриваются как имеющие атрибут VALUE,
поскольку языки Си и ПАСКАЛЬ в общем случае осуществляют передачу
параметров по значению. Символьные переменные, подстроки, массивы
"настраиваемого
размера"
и
массивы
"предполагаемого
размера"
передаваться по значению не могут.
Хотя по прежнему разрешено присвоение (значений) формальному
параметру,
значения
через
параметр возвращены быть не могут.
Элементы, передаваемые в параметры с атрибутом VALUE, могут отличаться
по типам. Если необходимо преобразование типов, то оно выполняется
непосредственно перед вызовом (обращением) и удовлетворяет правилам,
рассмотренным в подразд.1.7.1.2 "Преобразование типов арифметических
операндов".
При передаче по значению, значения не могут быть возвращены
посредством формальных параметров, поскольку формальный
аргумент
теперь адресует размечение стэка, содержащее значение фактического
параметра, а не адресует собственно фактический параметр.
В языке Си массивы никогда не передаются по значению. Если
пользователь указал атрибут C и в его подпрограмме присутствует
параметр типа массива, то массив будет передаваться так, как если бы
он являлся структурой данных языка Си (struct). Для передачи массива и
обработки его как массива (а не как структуры struct), пользователь
должен выполнить следующее:
- либо использовать для формального параметра атрибут REFERENCE;
- либо передать результат, возвращаемый функцией LOC, LOCNEAR или
LOCFAR по значению.
ПРИМЕР
В данном примере целое число x передается по значению:
SUBROUTINE Subr (x[VALUE])
INTEGER x[VALUE]
1.6.12
Атрибут VARYING
В языке ФОРТРАН формальный параметр должен быть описан для
каждого фактического параметра. Однако, в некоторых других языках,
таких как Си, допустимо использование фактических параметров, для
которых
формальных
параметров не определено. Такие фактические
параметры рассматриваются как передаваемые по значению; автоматическое
преобразование типов данных не выполняется. Когда указан атрибут C,
пользователь
также
должен специфицировать атрибут VARYING. Это
означает, что количество фактических параметров может отличаться от
количества формальных параметров. Фактические параметры, для которых
определены формальные параметры,
должны
удовлетворять
правилам
соответствия типов.
При записи ФОРТРАН-процедуры с атрибутом VARYING необходимо
убедиться, что в создаваемом коде исполняются (обрабатываются) только
обращения к параметрам, передаваемым в вызове, иначе при выполнении
процедуры может быть получен неопределенный результат.
Следует отметить, что вызывающие последовательности в языке
ФОРТРАН не поддерживают переменного числа параметров; атрибут VARYING
"не будет действовать", если пользователь в подпрограмме также не
укажет атрибут C.
1.7
Выражения
Выражение представляет собой формулу для вычисления значения.
Выражения состоят из операндов и операций. Операндами могут быть
вызовы функций, переменные, константы или другие выражения. Операции
указывают действия, которые должны быть выполнены над операндами. В
следующем выражении, например, слэш является операцией, а chickens и
coops - операндами:
chickens/coops
В языке ФОРТРАН различают четыре вида выражений:
Выражения
Результат
--------------------- --------------------------------------------
арифметические
символьные
отношения
логические
Значения: целое, вещественное, комплексное
Значения: сисмвольное или строковое
Логическое значение
Значения: логическое или целое
Выражения являются компонентами операторов. В следующем примере
полная строка представляет собой оператор; выражением является часть
строки после знака равенства (=):
cost = 10.95 *chickens / coops
Любая переменная, массив, элемент массива, структура, элемент
структуры или функция, которая возвращается в выражении, должна быть
определена к моменту ссылки на нее; в противном случае будет получен
неопределенный
результат.
Целочисленные
переменные должны быть
определены с числовым значением, а не со значением операторной метки,
устанавливаемой оператором ASSIGN.
Язык ФОРТРАН гарантирует только то,
что
выражения
будут
генерировать корректные значения, но не то, что все части выражений
будут вычислены. Например, если пользователь использует выражение,
которое
умножает (37.8 / scale**expo + factor)
на
ноль,
то
(37.8 / scale**expo + factor) может быть не вычислено. Аналогично,
если значение "ложь" и некотрое другое выражение являются операндами
оператора .AND., это выражение может быть не вычислено. Например, в
следующем выражении выражение (SWITCH .EQ. on) может
быть
не
вычислено:
((3 .LE. 1) .AND. (SWITCH .EQ. on))
В языке ФОРТРАН фирмы Microsoft
массивы
таким же образом, как и
Дополнительные сведения приведены в
массивами".
1.7.1
разрешено использовать полные
обычный (скалярный) аргумент.
подразд.1.7.5 "Выражения
над
Арифметические выражения
Значением
арифметического
выражения
является целочисленное
значение, вещественное или комплексное число или массив указанных
типов. Основными операндами арифметических выражений являются:
- арифметические константы;
- символические имена арифметических констант;
- указатели переменных;
- указатели элементов массива;
- указатели функций;
- указатели масссивов;
- указатели элементов структуры.
Другие, более сложные выражения, строятся из основных (базовых)
операндов,
перечисленных
выше,
с
использованием
скобок
и
арифметических операций (см. табл.1.5):
Таблица 1.5
Арифметические операторы
-----------------------------------------------------------: Оператор :
Операция
: Приоритет операций
:
:----------+-----------------------+-----------------------:
: * *
:Возведение в степень
: 1 (наивысший)
:
: /
:Деление
: 2
:
: *
:Умножение
: 2
:
: :Вычитание (бинарная)
: 3
:
:
:или отрицание (унарная):
:
: +
:Сложение (бинарная)
: 3
:
:
:или тождество (унарная):
:
-----------------------------------------------------------Все арифметические операции могут быть использованы как бинарные
операции, указанные между двумя операндами.
В качестве унарных операций могут использоваться также операции
"плюс" и "минус", предшествующие единственным операндам.
Когда последовательные операции имеют равный приоритет, то в
первую очередь выполняется самая левая операция. Например, выражение
first/second*third
эквивалентно
выражению
(first/second)*third.
Исключение из данного правила составляет только операция возведения в
степень: если имеются две последовательные операции возведения в
степень, то в первую очередь выполняется самая правая операция.
Например, следующие две операции эквивалентны:
first**second**third
first**(second**third)
В
языке
ФОРТРАН
запрещено последовательное указание двух
арифметических операций. Например, в языке ФОРТРАН не допускается
запись следующего вида: first**-second, но разрешена запись следующего
вида: first** (-second).
Для управления последовательностью выполнения
операторов
в
выражении
следует
использовать
круглые скобки. Ниже приведены
некоторые примеры предшествования арифметических операций:
Выражение
--------------3 * 7 + 5
-one**two
+x/y
area/g - qu**2**fact
Эквивалентное выражение
--------------------------(3 * 7) + 5
-(one**two)
+(x/y)
(area/g) - (qu**(2**fact))
Запрещены следующие арифметические операторы:
- деление на 0;
- возведение нулевого операнда в отрицательную степень;
- возведение отрицательного операнда в целочисленную
вещественную степень.
1.7.1.1
Деление целых
При делении двух целых результатом является
математическое
частное
от
деления
двух значений; результат операции деления
округляется. Таким образом, результатом деления 7/3 является 2;
результатом деления (-7)/3 является -2; в случаях операций деления
9/10 и 9/ (-10) результатом является 0.
Рассмотрим, например, следующий оператор присваивания:
X = 1/4 + 1/4 + 1/4 + 1/4
Прежде всего следует отметить, что операция деления имеет более
высокий приоритет, чем операция сложения, т.е. приведенное выше
выражение эквивалентно следующему выражению: X= (1/4)+ (1/4)+ (1/4)+
(1/4). Затем результат деления 1 на 4 округляется до 0. Таким образом,
оператор присваивания присваивает величине X значение 0.
1.7.1.2
Преобразование типов арифметических операндов
Когда все операнды арифметического выражения имеют один и тот же
тип, то значение, возвращаемое выражением, имеет тот же тип. Если
операнды определены с различными типами, то возвращаемое выражением
значение имеет тип операнда наивысшего ранга. Исключением из правила
являются операции, включающие и числа типа REAL*8, и числа типа
COMPLEX*8, возвращающие результаты с типом COMPLEX*16.
Арифметические операнды ранжированы следующим образом:
1.
2.
3.
4.
5.
6.
7.
DOUBLE COMPLEX или COMPLEX*16 (наивысший ранг)
COMPLEX[*8]
REAL*8 или DOUBLE PRECISION
REAL[*4]
INTEGER*4
INTEGER*2
INTEGER*1 (низший ранг)
Например, если операция выполняется над операндом типа INTEGER*2
и операндом типа REAL*4, то сначала INTEGER*2 преобразуется к REAL*4.
Результат операци также имеет тип REAL*4. Подобным же образом, если
выполняется операция над вещественным числом и комплексным числом, то
сначала вещественное число преобразуется к комплексному виду
и
результат операции также будет иметь тип комплексный.
Ниже
приведены
некоторые
примеры интерпретации выражений.
Переменные i1 и i2 являются целочисленными, r1 и r2 - вещественными с
одинарной точностью, c1 и c2 - комплексными числами типа COMPLEX*8:
Оператор
-------------r2=i1/i2*r1
Интерпретация
---------------------------------------------Сначала выполняется целочисленное деление (см.
подразд.1.7.1.1) переменных i1 и i2. Затем
результат преобразуется в вещественное число
и выполняется операция умножения
операнда
(частного от деления) и переменной r1.
Переменная i1 сначала преобразуется к типу
COMPLEX*8. Затем целочисленная переменная i1
складывается с переменной c2.
c1=c2+i1
Для выражений с целочисленными операндами следует отметить, что
результат имеет размерность операнда с максимальной размерностью.
Например, если переменные j и k объявлены как INTEGER*2 (и при этом не
установлена метакоманда $STORAGE), то результат выражения j+k имеет
тип INTEGER*4. (Аналогичный результат имеет место, если метакоманда
$STORAGE опущена, поскольку по умолчанию для метакоманды $STORAGE
устанавливается значение 4).
Следует также отметить, что обычно при выполнении процедуры
оптимизации компилятор "удаляет арифметику с высокой точностью", если,
однако, это не оказывает влияние на конечный результат и если не
установлена метакоманда $DEBUG. Например, промежуточное значение,
получаемое при сложении j и k, занимает 16 разрядов, даже если была
указана (ранее) метакоманда $STORAGE:4:
INTEGER*2
i = j + k
i, j, k
Использование
метакоманды
$STORAGE:4
"не оказывает влияния" на
выражения над операндами, которые определены с типом INTEGER*2,
имеющие только операции плюс (+), минус (-) или умножение (*).
Результаты будут тождественны, поскольку преобразование
к
типу
INTEGER*4 промежуточного результата не предохраняет от переполнения
при выполнении арифметических операций на числами типа INTEGER*2.
Следует отметить, что сообщения о таких "переполнениях" не выдаются,
если, однако, метакоманда $DEBUG не является действительной.
В табл.1.6 показано, каким образом арифметические
операнды
преобразуются из одного типа в другой.
Таблица 1.6
Преобразование арифметических типов
---------------------------------------------------------------------Тип данного : Преобразование к типу данного : Преобразование к типу
: более высокого ранга
: данного более низкого
:
: ранга
------------+-------------------------------+------------------------DOUBLE
:
(Наивысший ранг)
:Мнимая и действительная
COMPLEX или:
:части
преобразуются
COMPLEX*16 :
_ _ _ _ _
:отдельно, из REAL*8 в
(наивысший :
:в REAL*4(*)
ранг)
:
:
:
:
COMPLEX*8 :Мнимая и действительная части :Мнимая часть удаляется
:преобразуются
отдельно, из :
:REAL*4 в REAL*8
:
:
:
DOUBLE
:Преобразование из DOUBLE
:Наименьшие значащие
PRECISION :PRECISION в REAL*4 и добавление:разряды отбрасываются
или
:мнимой части вида 0.0 (*)
:
REAL*8
:
:
:
:
REAL*4
:Сохраняется в формате DOUBLE
:Округляется
:PRECISION
:
:
:
INTEGER*4 :Добавляется нулевая дробная
:Используется наименьшая
:часть (мантисса)
:значащая часть
:
:
INTEGER*2 :Используется младшая часть, в :Используются младшие
:старшей части устанавливается :разряды
:разряд знака
:
:
:
INTEGER*1 :Используется младшая часть, в : (Низший ранг)
:старшей части устанавливается :
:разряд знака
:
---------------------------------------------------------------------(*) Числа типа REAL*8 преобразуются к типу COMPLEX*16 путем добавления
мнимой части вида 0.0; числа типа COMPLEX*16 преобразуются к типу
REAL*8 путем удаления мнимой части.
1.7.2
Символьные выражения
Результатом символьного выражения является значение, имеющее тип
символьный.
В символьных выражениях используются шесть основных
операндов:
1. символьные константы;
2. указатели символьных переменных;
3. указатели элементов символьных массивов;
4. указатели символьных функций;
5. символьные подстроки;
6. указатели символьных элементов структуры.
В данном случае имеется только один символьный оператор: оператор
конкатенации (||). Оператор используется следующим образом:
<first>||<second>
В результате получается символьная строка, значением которой
является значение <first> (начало результирующей строки), объединенное
со значением <second> ("хвост" результирующей строки); общая длина
результирующей строки равна сумме длин строк first и second. Например,
результатом следующего выражения является строка 'AB CDE':
'AB
' || 'CDE'
При конкатенации двух или более строк результирующая строка имеет
такую длину, какие длины объявлены для строковых переменных. Ведущие и
"хвостовые" пробелы не отбрасываются. Например:
CHARACTER*10 first
CHARACTER*6
second
first = 'heaven'
second = ' sent'
WRITE (*, *) first||second
Результатом является 16-и символьная строка 'heaven
sent'.
Следует отметить, что между 'heaven' и 'sent' указывается пять
пробелов.
При конкатенации Си-строк следует помнить, что пустой символ
(null-символ; \0) автоматически добавляется в конец каждой Си-строки.
Рассмотрим, например, следующее выражение:
'hello 'C || 'world'C
Оно эквивалентно следующей Си-строке:
'hello \Oworld' C
1.7.3
Выражения отношения
Выражения отношения сравнивают значения двух арифметических или
символьных
выражений.
Сравнение
арифметической
переменной
с
символьной переменной невозможно.
В языке ФОРТРАН фирмы Microsoft допускается возможность сравнения
арифметического выражения с символьным выражением. Если арифметическое
выражение сравнивается с символьным выражением, то арифметическое
выражение
рассматривается
как
символьное
выражение (т.е. как
последовательность байтовых значений). Два выражения должны быть
идентичны с точностью до байта, в противном случае они не являются
равными.
Например, если 'А' было присвоено четырехбайтовому целому, то
ASCII-значение буквы А (41 шестнадцатеричное) будет младшим значащим
байтом переменной, а другие байты будут нулями. Если 'А' было
присвоено
символьной
переменной,
длиний в четыре символа, то
ASCII-значение буквы А (41 шестнадцатеричное) будет старшим значащим
байтом
переменной,
поскольку
символьные
переменные
являются
"выравниваемыми слева". Таким образом, две переменные будут равны,
если они "занимают" одинаковое номинальное значение.
Результат выражения отношения имеет тип LOGICAL (TRUE или FALSE).
Для сравнения значений выражения отношения могут использовать любые
операторы, указанные в табл.1.7.
Таблица 1.7
Операторы отношения
------------------------------------------: Оператор :
Операция
:
:------------+----------------------------:
:
.LT.
:
Меньше чем
:
:
.LE.
:
Меньше чем или равно
:
:
.EQ.
:
Равно
:
:
.NE.
:
Не равно
:
:
.GT.
:
Больше чем
:
:
.GE.
:
Больше чем или равно
:
------------------------------------------Все операторы отношения являются бинарными и указываются между
операндами.
Приоритетное
предшестование или ассоциативность для
операндов отношения не указывается, поскольку выражение отношения не
может содержать другого выражения отношения. Рассмотрим, например,
следующий некорректный программный фрагмент:
REAL*4 a, b, c, d
IF ((a .LT. b) .NE. c) d=12.0
Предположим, что a меньше b. После вычисления
выражения, выражение будет иметь следующий вид:
первой
части
.TRUE. .NE. c
Однако c представляет собой арифметическое выражение и сравнение
арифметического выражения с .TRUE. не возможно.
Для
сравнения
выражений
отношения
и логических значений следует использовать
логические операторы (см. подразд.1.7.4).
Выражения отношения с арифметическими операндами могут иметь один
операнд, который является целым,
и
один
операнд,
являющийся
вещественным
числом.
В
этом
случае,
целочисленный
операнд
преобразуется к виду вещественного числа прежде, чем будет выполняться
выражение отношения. Может также присутствовать и комплексный операнд;
в этом случае другой операнд сначала будет преобразован к комплексному
виду. Однако, для комплексных операндов могут использоваться только
операторы .NE. и .EQ.
Выражения
отношения над символьными операндами "сравнивают"
позиции операндов с учетом последовательности упорядочения, принятой в
ASCII. Один операнд считается меньше другого (или "младше"), если он в
последовательности упорядочивания указан раньше. Например, выражение
('apple' .LT. 'banana') возвращает
значение
.TRUE.;
выражение
('Keith' .GE. 'Susan') возвращает значение .FALSE. Если сравниваются
операнды неравной длины, то "короткий" операнд расширяется до длины
"длинного" операнда путем добавления пробелов справа.
1.7.4
Логические выражения
Результатом логического выражения является логическое значение. В
логических выражениях используются семь основных операндов:
1. логические константы
2. указатели логических переменных
3. указатели элементов логических массивов
4. указатели логических функций
5. выражения отношения
6. целочисленные константы или переменные
7. указатели элементов логических структур.
Другие логические выражения строятся из основных операндов,
используя круглые скобки и логические операторы, указанные в табл.1.8.
Таблица 1.8
Логические операторы
----------------------------------------------: Оператор : Операция
:
Приоритет
:
:----------+---------------+------------------:
: .NOT.
: Отрицание
: 1 (наивысший)
:
: .AND.
: Конъюнкция
: 2
:
: .OR.
: Включительная : 3
:
:
: дизъюнкция
:
:
: .ХOR.
: Исключительная: 4
:
:
: дизъюнкция
:
:
: .EQV.
: Равенство
: 4
:
: .NEQV. : Неравенство
: 4
:
----------------------------------------------Операторы .AND., .OR., .XOR., .EQV., и .NEQV. являются бинарными
операторами и указываются между операндами логического выражения.
Оператор
.NOT. является унарным и указывается перед операндом.
Например, если значение switch есть .TRUE.,
тогда
результатом
выражения (.NOT. switch) является .FALSE.
Логические операции допускают использование только аргументов
типа LOGICAL. В языке ФОРТРАН фирмы Microsoft разрешено
также
использование целочисленных аргументов, которыми могут быть целые
константы, целые переменные, целочисленные элементы структур или
целочисленные выражения.
Следует отметить, что результат сравнения двух целочисленных
выражений логической операцией будет иметь тип INTEGER, но не тип
LOGICAL.
Если две последовательные операции имеют равный приортет, то
первой выполняется самая левая операция.
Два оператора .NOT. не могут быть применены друг к другу; однако,
оператор .NOT. может указываться следующим сразу после любого другого
логического оператора. Допустим, например, следующий оператор:
logvar = a .AND.
.NOT.
b
Логические операторы имеют то же значение, что и аналогичные
математические операции; оператор .OR. является
"неисключающим".
Например:
.TRUE. .OR. .TRUE.
имеет результатом значение
логических выражений.
.TRUE.
В
таблице 1.9 показаны значения
Таблица 1.9
Значения логических выражений
--------------------------------------------------------------------
Операторы a и b
:
Вычисление выражений
--------------------+----------------------------------------------: a .AND. b : a .OR. b : a. EQV. b : a .NEQV. b
:
:
:
: a .XOR. b
--------------------+-----------+----------+-----------+-----------Оба имеют значение : Истина
: Истина
: Истина
: Ложь
"истина"
:
:
:
:
Один "истина",другой: Ложь
: Истина
: Ложь
: Истина
"ложь"
:
:
:
:
Оба имеют значение : Ложь
: Ложь
: Истина
: Ложь
"ложь"
:
:
:
:
-------------------------------------------------------------------ПРИМЕРЫ
В следующем программном фрагменте демонстрируется
логических выражений.
приоритетность
LOGICAL stop, go, wait, a, b, c, d, e
C Следующие два оператора эквивалентны:
stop = a .AND. b .AND. c
stop = (a .AND. b) .AND. c
C Следующие два оператора эквивалентны:
go = .NOT. a .DR. b .AND. c
go = ((.NOT. a) .OR. b) .AND. c
C Следующие два оператора эквивалентны:
wait = .NOT. a .EQV. b .OR. c .NEQV. d .AND. e
wait = ((.NOT. a) .EQV. (b .OR. c)) .NEQV. (d .AND. e)
Следующий пример демонстрирует использование целых в логических
выражениях для обработки маскирования байта:
INTEGER*2 lowerbyte, dataval, mask
mask = *00FF
! mask the most-significant byte
dataval = *1234
lowerbyte = (dataval .AND. mask)
WRITE (*, '('' '', 224)') dataval, lowerbyte
Результат будет следующим:
1234
34
1.7.5
Выражения над массивами
В языке ФОРТРАН фирмы Microsoft разрешены операции над полными
массивами как над обычными аргументами (скалярами). Например, два
массива могут быть сложены по-элементно, используя операцию сложения
(+). Каждый элемент массива может быть разделен на константное
значение. Два массива переменных типа LOGICAL или INTEGER могут
сравниваться при помощи логических операций типа .AND. или .GE. и др.
Массивы также могут передаваться в функции (как встроенные, так и
внешние).
Когда два или более массивных операндов указываются в операторе
присваивания или выражении, они все должны "согласовываться". Другими
словами, они должны иметь одинаковое количество размерностей, а
ссответствующие размерности должны
иметь
одинаковый
размер
и
одинаковые верхнюю и нижнюю границы. Например, массивы first(6,3) и
second(3,2,3) не согласуются. Хотя в памяти они и занимают одинаковые
области,
их размерности не соответствуют. Массивы third(3,4) и
fourth(-1:1,5:8) также не согласовываются. Они имеют одинаковое число
размерностей, каждая из которых, однако, имеет свой собственный
размер. Любая попытка сравнения
не
согласующихся
массивов
в
арифметических выражениях, либо присвоения одного массива другому
приводит к генерации ошибки на этапе компиляции.
Если массивы не согласуются, то размеры их размерностей должны
быть
полностью
специфицированы
во
время компиляции. Поэтому,
настраиваемые и размещаемые массивы не согласуются; они не могут
сравниваться в выражениях, даже если их размерности совпадают.
Все операции, разрешенные для скалярных аргументов, разрешены для
аргументов типа массивов. Любое массивное выражение может быть правой
частью оператора просваивания, левая часть которого есть массив.
Массивные выражения могут появляться только в операторах присваивания
и в качестве аргументов функций. Например, если array1, array2, array3
и
logarray являются согласующимися массивами, то все следующие
операторы корректны:
array1 = 42
;Присвоение константы каждому
;элементу
array3 = array1 / array2
;Деление соответствующих элементов
array2 = - array1
;Отрицание каждого элемента в array1
array1 = array2 - 3
;Вычитание константы из каждого
;элемента
array1 = array2 - array3(7) ;Вычитание значения array(3) из
;каждого элемента
array1 = array3 ** array1
;Возведение каждого элемента
в
;степень соответствующего элемента
array3 = MyFunc (array2)
;Применение MyFunc к каждому элементу
logarray = array1 .LT. array2
;Логическое
сравнение
;соответствующих элементов
logarray = .NOT. array2
;Инвертирование
битов
каждого
;элемента массива array2
chararray2 = chararray2(5:8)//chararray2(1:4) ;Переустановка
;символьной строки
Все встроенные функции, имеющие скалярные аргументы, могут также
принимать массивные аргументы. Если пользователь предполагает передать
аргументы во внешнюю функцию, принимающую скалярные аргументы, он
должен объявить внешнюю функцию в операторе INTERFACE. Ни один из
формальных аргументов функции не может быть массивом.
ПРИМЕЧАНИЕ
При обработке массивных выражений компилятор может генерировать
менее эффективную последовательность машинных команд, чем та, которая
обрабатывается в обычных DO-циклах. Если скорость выполнения является
важным фактором, то более эффективным может оказаться поэлементная
обработка массива.
1.7.6
Приоритетность
выполнения)
операторов
Когда в одном выражении
арифметические,
символьные,
(последовательность
встречаются все типы
операций
отношения
и
логические
-
последовательность их выполнения будет следующей:
1.
2.
3.
4.
арифметические операции (наивысший приоритет)
символьные операции
операции отношения
логические операции (низший приоритет).
2.
СТРУКТУРА ПРОГРАММЫ
В данном разделе рассматривается структура
ФОРТРАН-программ
пользователя:
что
в нее входит и в какой последовательности.
Приводятся сведения о типах строк и операторных метках, а также об
ограничениях
на
последовательность
операторов
и
метакоманд.
Обсуждаются
вопросы,
касающиеся
формата
программ;
затем
рассматриваются параметры и описываются типы программных модулей,
допустимые для обработки компилятором
языка
ФОРТРАН:
головные
(основные) программы, подпрограммы, функции и подпрограммы блоков
данных.
2.1
Строки
Позиции символов в строках языка ФОРТРАН являются значащими.
Строки
формируются
из
последовательностей
символов.
Символы
интерпретируются по-разному, в зависимости от того, в какой колонке
они указаны, а именно:
Колонка
-------1-5
Интерпретация символа
------------------------------------------------Метка оператора. Знак доллара ($) в колонке 1
указывает на метакоманду. Звездочка или прописная
или строчная буква C в колонке 1 указывает на
комментарий.
6
Символ продолжения.
7-72
Оператор языка ФОРТРАН.
73 и выше
Игнорируются.
----------------------------------------------------------------Строки длиной короче 72 символов "дополняются" пробелами.
В языке ФОРТРАН используются пять типов строк:
Тип строки
-------------Строки
комментария
Описание
-----------------------------------------------------Строка
комментария имеет звездочку или прописную
или строчную букву C в первой позиции, либо строка
может
полностью
состоять
из
пробелов.
Знак
восклицания, появляющийся как первый непустой символ в
строке, также указывает на строку комментария в языке
ФОРТРАН. (Строка со знаком восклицания в колонке 6
интерпретируется как строка комментария).
Строка
комментария
на
процесс
выполнения
ФОРТРАН-программы не влияет.
Строки
комментария
могут
указываться
внури операторов, которые имеют строки продолжения.
Следует отметить, что отладочные строки, описанные
ниже, иногда могут быть
обработаны
как
строки
комментария. (См. также подразд.6.2).
Ниже показаны примеры строк комментария:
C This is a comment line,
*
and so is this,
! as is this line.
Комментарии могут также добавляться к программным
строкам. В таком случае комментарий должен начинаться
со знака восклицания:
hyp = SQR (a**2 + b**2)
Начальные
строки
! hypotenuse
Первая (или единственная) строка оператора
языка
ФОРТРАН называется "начальной" строкой.
Начальная строка оператора в колонке 6 имеет либо
пробел либо ноль; в колонках 1-5 указывается либо
метка
оператора
либо
пробелы.
За исключением оператора, следующего за логическим
IF, все операторы ФОРТРАНа начинаются с начальной
строки, например:
GOTO 100
0002 CHARACTER*10 name
100 0CONTINUE
1000STOP ' '
Метакоманды
В первой позиции строки метакоманды
присутствует
знак доллара ($). Метакоманда
управляет
работой
компилятора языка ФОРТРАН, например:
$DEBUG:'pdq'
$DECLARE
$LINESIZE:132
Строки
продолжения
Строка
продолжения
представляет
собой
строку,
имеющую пробелы в колонках 1-5 и символ (отличный
от пробела или нуля) в колонке 6. Строка продолжения
увеличивает
размер
"участка",
в
который
записывается оператор. Оператор может быть расширен
для включения такого количества строк продолжения,
сколько позволит доступная для использования область
памяти. Если установлена метакоманда $STRICT, то в
том случае, если
используется
более
19
строк
продолжения,
будет
выдано
предупреждение.
В
приведенном
ниже
примере вторая строка является
строкой продолжения:
C
Отладочные
строки
Sample Continuation line
INTEGER*4 count, popu, local,
+
ovrflo, incrs, provnc
Отладочные
строки содержат
любые
прописные или
строчные буквенные символы, за исключением C и c
в позиции 1.
Если
метакоманда
$DEBUG
специфицирует
символ,
находящийся
в
позиции
1
отладочной
строки,
то
этот
символ
обрабатывается
как символ пробела и строка компилируется как и
любая
другая строка. Если метакоманда $DEBUG не
специфицирует символ в первой колонке, то строка
обрабатывается
как строка комментария (см. также
подразд.6.2). В следующем примере строки являются
строками отладки:
B
Z
RETURN 1
WRITE (*, *) count
2.2
Метки операторов
Любой оператор может начинаться с метки; однако ссылаться можно
только на метки исполнительных операторов или операторов FORMAT.
Операторная метка представляет собой последовательность от 1 до 5
символов (цифр), из которых хотя бы один должен быть ненулевым. Метка
помещается в любой колонке от 1-ой до 5-ой в начальной строке; пробелы
и ведущие нули не являются значащими (например, метки 23 4 и 234
являются тождественными). Каждый помеченный оператор в исходном файле
должен иметь уникальную метку.
2.3
Представление исходного кода в "свободном формате"
Пользователь может вводить свой исходный код в
"свободном
формате",
используя
для этого метакоманду $FREEFORM; при этом
большинство ограничений, накладываемых форматом языка ФОРТРАН, не
используются.
Большинство
правил, изложенных в подразд.2.1, не
применимы к исходному коду в "свободном формате".
Необходимо придерживаться следующих правил:
- двойной апостроф в колонке 1 или знак восклицания, заданнй как
перый символ в строке, указывают на строку комментария;
- начальные строки могут начинаться в любой колонке (позиции);
- начальные строки могут начинаться с операторной метки, длиной
от 1 до 5 цифр (пробелы игнорируются). Для отделения операторной метки
от первого символа оператора указывать пробел не требуется; первый
непустой непробельный символ есть начало оператора;
- если последний ненулевой символ в строке является знаком минус,
то
он отбрасывается и следующая строка принимается как строка
продолжения. Строка продолжения может начинаться в любой позиции;
- буквенные символы и звездочки недопустимы в качестве маркеров
комментария в позиции 1.
2.4
Последовательность операторов и метакоманд
Операторы описывают, специфицируют и классифицируют элементы
программы пользователя как действия, которые эта программа должна
выполнять. Операторы языка ФОРТРАН описаны в разделе 4 "Операторы".
Стандарт
ANSI
языка
ФОРТРАН
задает
определенную
последовательность спецификации и исполнения операторов и строк,
образующих
модуль
ФОРТРАН-программы. Некоторые расширения языка
ФОРТРАН
данной
версии
требуют
удовлетворения
дополнительным
требованиям. На рис.2.1 показано, какие операторы и метакоманды должны
предшествовать,
а
какие
следовать
за
любым
оператором или
метакомандой.
-----------------------------------------------------------------:
$DO66,$[NO]FLOATCALLS,$[NO]FREEFORM,$STORAGE :
:
:-------------------------------------------------:
:
: BLOCK DATA,FUNCTION,INTERFACE,PROGRAM,SUBROUTINE:
:
:-------------------------------------------------:
:
:
:
IMPLICIT
:
:
:
:
:
:------------------:
:
:
:
:$[NO]LARGE,: COMMON,
:
:
:$[NO]DEBUG
:
:
: DIMENSION,
:
:
:$[NO]DECLARE :
:
:
:
:
:$DEFINE
:
:
:
:
:
:$ELSE
:
:
:
:
:
:$ELSEIF
:
:
:
:
:
:$ENDIF
:
:
:
:
:
:$IF
:
:при исполь-: EQUIVALENCE,
:
:
:$INCLUDE
:
:зовании без: EXTERNAL,
:PARAMETER :
:$LINESIZE
:
:параметров : INTRINSIC,
:
:
:$[NO]LIST
:
:
:
:
:
:$[NO]LOOPOPT :
:
: SAVE; Операторы :
:
:$MESSAGE
:
:
: типа; также
:
:
:$PAGE
:
:
: $[NOT]LARGE,
:
:ENTRY :$PAGESIZE
:
:
:когда используется:
:FORMAT :$[NOT]STRICT :
:
:с параметрами
:
:
:$SUBTITLE
:
:
:------------------+----------:
:$TITLE
:
:
:
:
:
:$PACK
:
:
:Операторы
:
:
:$[NO]TRUNCATE :
:
:операторной
:
:
:
:
:
:функции
:
:
:
:
:------------------------------:
DATA
:
:
:
:
Исполнительные
:
:
:
:
:
операторы
:
:
:
:
:
:
:
:
:
:----------------------------------------------------------------:
:
END
:
-----------------------------------------------------------------Рис.2.1. Последовательность операторов и метакоманд
Предположим, что имеется программа,
содержащая
программные
элементы a и b. На рис.2.1: если прямоугольник, содержащий элемент a,
находится выше прямоугольника, содержащего элемент b, тогда a должен
указываться перед b в программе пользователя. Например, оператор
IMPLICIT находится "выше" операторов COMMON, DATA, END и
т.д.
Следовательно, если в программе присутствует оператор IMPLICIT, он
должен быть указан раньше этих операторов.
Если, на рис.2.1, элемент a находится в прямоугольнике слева или
справа от элемента b, тогда a и b могут указываться в любой
последовательности.
Например,
оператор
FORMAT
находится
в
прямоугольнике слева от прямоугольника,
содержащего
большинство
метакокоманд,
и справа от прямоугольника, содержащего операторы
PARAMETER, IMPLICIT, COMMON, операторы операторной функции, DATA и
т.д. Таким образом, в программе пользователя любой из этих элементов
может быть указан до или после оператора FORMAT.
Ниже кратко изложены требования к упорядочиванию операторов и
метакоманд, показанные на рис.2.1:
- каждый программный модуль в качестве последней строки должен
иметь оператор END;
- строки комментария могут указываться везде, но не после
последнего оператора END в исходном файле;
- операторы BLOCK DATA, FUNCTION, INTERFACE ТО, PROGRAM и
SUBROUTINE должны предшествовать всем другим операторам. Они не должны
предшествовать метакомандам;
- все операторы описания должны предшествовать всем операторам
DATA, операторам операторных функций и исполнительным операторам.
(Списки операторов описания и исполнительных операторов приведены в
подразд.4.1);
- операторы IMPLICIT должны предшествовать другим операторам
описания (исключение составляет оператор PARAMETER);
операторы
операторной
функции
должны
предшествовать
исполнительным операторам;
когда
оператор
описания определяет тип константы, как
используемой в операторе PARAMETER, то оператор PARAMETER должен
следовать
за
оператором
описания.
Оператор
PARAMETER должен
предшествовать всем другим операторам описания, которые используют
описанные в нем символические константы;
операторы
INTERFACE
должны
предшествовать
указателям
подпрограмм, которые определены в этих операторах;
- метакоманды $DO66, $[NO]FLOATCALLS, $[NO]FREEFORM и $STORAGE,
если они указаны, должны указываться раньше всех других операторов.
Метакоманды $LARGE и $NOTLARGE, когда они используются без параметров,
не могут указываться внутри
секции
исполнительных
операторов.
Метакоманды $LARGE и $NOTLARGE, когда они используются с параметрами,
должны указываться в секции объявления. Другие метакоманды могут
указываться где угодно;
подпрограммы
блоков
данных
могут
содержать операторы
операторных функций, операторы FORMAT или исполнительные операторы.
2.5
Параметры
"Параметрами" являются значения, которые "передаются в" или
"передаются из" функций и процедур. Формальным параметром является
имя, по которому параметр "узнается" внутри функции или процедуры.
Фактический параметр представляет собой специфическую переменную,
выражение, массив, имя функции или другой элемент, передаваемый в
процедуру или функцию при вызове.
Количество фактических параметров должно совпадать с количеством
формальных параметров (если, однако, не задан атрибут VARYING) и
должны
быть
согласованы
соответствующие типы параметров. Если
процедура вызывается в программном модуле неоднократно, то компилятор
проверяет последовательность и согласование числа и типов фактических
параметров при каждом вызове. Если процедура или функция описаны
раньше, чем они использовались в первый раз, или если используется
оператор INTERFACE ТО, то компилятор будет
выполнять
проверку
корректности количества и типов параметров. В противном случае,
компилятор использует параметры, заданные при первом использовании
процедуры или функции для определения их количества и типов. Следует
отметить, что компилятор способен определить несоответствие типов
фактических и формальных параметров только в том случае, если известен
тип формального параметра.
В общем случае значения параметров передаются в или из процедуры
или функции по ссылке (указателю); т.е. они передают адрес памяти
параметра. В языке ФОРТРАН фирмы Microsoft это принято по умолчанию.
Для передачи параметра по значению следует использовать атрибут VALUE
(см. подразд.1.6.11).
После входа в процедуру или функцию, фактические параметры
ассоциируются с формальными параметрами. Установленная "ассоциация"
остается действительной до завершения исполнения
процедуры
или
функции. Если фактический параметр был передан по ссылке (принимается
по умолчанию), то присвоение значения формальному параметру во время
исполнения
процедуры
или
функции
может
изменить
значение
соответствующего фактического параметра.
Если фактическим параметром является константа, указатель функции
или выражение, не являющееся единственной переменной, то операция
присвоения
значения
соответствующему
формальному
параметру не
разрешена и имеет непредсказуемый результат. В следующей программе,
например,
фактический
параметр
header
является
константой и
соответствует формальному параметру title.
В
процедуре
report
параметру title присваивается значение.
C Данная программа является некорректной и имеет
C непредсказуемые результаты.
CHARACTER*20
header
REAL*4
grav
PARAMETER (header= 'Specific Gravity')
DATA grav / 2.8327 /
WRITE (*, *) header, grav
C header является фактическим параметром:
CALL Report (header,grav)
WRITE (*, *) header, grav
END
C Формальным параметром, соответствующим header, является title:
SUBROUTINE Report (title, data)
CHARACTER*20 title
REAL*4
data
C Следующий оператор запрещен, поскольку он выполняет операцию
C присвоения значения формальному параметру, который
C соответствует константе:
title = 'Density (Kg/cubic m)'
WRITE (*, *) title, data
END
Выходной
результат
приведенной
выше
программы
будет
непредсказуем. Для изменения значения title в процедуре параметр
header может быть заменен переменной (вместо константы).
Если фактическим параметром является выражение, оно вычисляется
непосредственно перед установлением взаимосвязи между формальным и
фактическим параметром. Если фактический параметр является элементом
массива, то его индексные выражения также вычисляются непосредственно
перед установлением указанной
взаимосвязи.
Индексные
выражения
остаются без изменения в процессе исполнения процедуры или функции,
даже если они содержат переменные, которые во время исполнения
процедуры или функции переопределяются.
В следующем списке показано, каким образом можно ассоциировать
(установить связь) фактические и формальные параметры:
Фактический параметр
-----------------------------------------------Переменная,
элемент
массива, выражение или
элемент структуры.
Массив или элемент массива. Количество и размер
измерений
в
формальном
параметре
может
отличаться от указанных в фактическом параметре,
однако, любая ссылка
на
формальный
массив
Формальный параметр
------------------Имя переменной
Имя массива
"должна
находиться
в
пределах",
указанных
для фактического
массива.
Следует отметить,
что ссылка на элемент, находящийся вне указанных
границ не будет классифицироваться как ошибка:
результат в этом случае будет непредсказуем.
Массив. Каждый элемент массива передается
в
процедуру (по-элементно), и процедура исполняется
однократно для каждого элемента.
Переменная.
Ее процедура должна
быть
объявлена в
операторе INTERFACE
TO,
либо
должна
быть
встроенной
функцией,
если
массив передается в
скалярный
формальный параметр
Спецификатор альтернативного возврата (*label)
в операторе CALL.
Следует
отметить,
что формальный параметр,
указанный как альтернативный возврат, является
повторяющимся.
Звездочка (*)
Имя
внешней
процедуры
или
функции, либо
Любое
уникальное
встроенная функция. Фактический параметр должен
имя,
используемое
быть
внешней
процрдурой
или
функцией,
в вызове процедуры
объявленной оператором EXTERNAL, или встроенной
или
указателе
функцией, разрешенной для связи с формальным
функции
внутри
параметром процедуры или аргументом функции.
процедуры.
Встроенная
функция
должна
быть
первой,
объявленной
оператором
INTRINSIC в
модуле
программы, где она используется как фактический
параметр.
--------------------------------------------------------------------Следующие встроенные функции не могут быть ассоциированы
формальными параметрами процедур или аргументами функций:
ALLOCATED
AMAX0
AMAX1
AMIN0
AMIN1
CHAR
CMPLX
DBLE
DCMPLX
DFLOAT
DMAX1
DMINI
DREAL
EOF
EPSILON
FLOAT
HFIX
HUGE
ICHAR
IDINT
IFIX
IMAG
INT1
INT2
INT4
INTC
INT
JFIX
LEN_TRIM
LGE
LGT
LLE
LLT
LOC
LOCFAR
LOCNEAR
LOG
LOG10
MAX
MAX0
MAX1
MAXEXPONENT
с
MIN
MIN0
MIN1
MINEXPONENT
NEAREST
PRECISION
REAL
SCAN
SNGL
TINY
VERIFY
При передаче целочисленных параметров по ссылке следует отметить,
что переменная типа INTEGER*2 не может быть передана в формальный
параметр типа INTEGER*4, а переменная INTEGER*4 не может быть передана
в формальный параметр INTEGER*2. Преобразование типов данных может
быть реализовано с использованием встроенных функций INT4 или INT2
(см. раздел 5), однако результатом в этом случае будет выражение и
процедура не сможет выполнить присвоение значения параметру. Кроме
того, следует отметить, что когда задана метакоманда $STORAGE:4
(принимается по умолчанию), то даже выражения, в которых используются
только
параметры
INTEGER*2,
будут выдавать результат с типом
INTEGER*4. Следующая программа, например, в качестве результата выдает
ошибку:
C Данная программа некорректна и ее результатом будет ошибка:
$STORAGE:4
INTEGER*2 i, k
CALL Subr(j + k)
SUBROUTINE Subr (n)
INTEGER*2 n
.
.
.
END
Ошибочный результат получается в виду того, что
результат
выражения j + к имеет тип INTEGER*4. Вызов процедуры должен быть
записан следующим образом:
CALL Subr (INT2(j + k))
Целочисленные параметры, передаваемые по значению, под действие
данного ограничения не попадают. Правила преобразования для значений
параметров совпадают с правилами преобразований,
принятыми
при
выполнении
операции
присваивания.
Например,
можно
передать
вещественное значение в целочисленный параметр, т.к. преобразование
выполняется автоматически.
2.6
Программные модули
Компилятор
языка
ФОРТРАН
обабатывает
программные модули.
Программный модуль может быть головной
программой,
процедурой,
функцией, подпрограммой (модулем) блока данных. Любой из них может
быть скомпилирован отдельно и затем они могут быть скомпонованы
вместе. В следующем списке перечислены четыре типа программных модулей
(они подробно рассмотрены в подразделах 2.7 - 2.10):
Программный модуль
--------------------Головная программа
Описание
---------------------------------------------Любой программный модуль, первым оператором
которого не являются
операторы
FUNCTION,
SUBROUTINE или BLOCK DATA. Головная программа
в
качестве
первого
оператора
имеет
оператор PROGRAM, но это не обязательно.
Процедура
Программный
модуль,
который
может
быть
вызван из другого программного модуля при
помощи оператора CALL.
Подпрограмма
блока-данных
Программный модуль, обеспечивающий назначение
начальных
значений
для
переменных
в
поименованном "общем" блоке.
Функция
Программный модуль, на который можно ссылаться
из выражения.
Внешние функции, процедуры и подпрограммы блоков данных имеют
общее наименование "подпрограммы". Процедуры и функции совместно
называются "процедурами". PROGRAM, SUBROUTINE, BLOCK DATA, FUNCTION и
операторы операторной функции детально описаны в подразд.4.2.
Используя подпрограммы, пользователь может разрабатывать большие,
сильно структурированные программы. Это особенно полезно в следующих
ситуациях:
Ситуация
-------------------пользователь имеет
большую программу
Результат
---------------------------------------------упрощается
разработка,
тестирование,
сопровождение и компиляция больших программ,
когда они "разбиты" на небольшие части
пользователю требуется
включить
некоторые
процедуры в более чем
одну программу
пользователь может создать объектные файлы,
которые содержат эти процедуры и компоновать
их с каждой программой,
в
которой
они
используются
необходимо,
чтобы
поцедура
была
реализована несколькими
способами
можно "поместить" процедуру в ее собственный
файл (т.е. реализовать ее отдельным файлом)
и компилировать его отдельно. Затем,
для
улучшения
процесса обработки, пользователь
может изменить реализацию процедуры или даже
переписать ее на языке ассемблера, ПАСКАЛЬ,
или Си. "Оригинальная" процедура при этом не
изменяется
2.7
Головная программа
Головной программой может быть любой программный модуль, который
в качестве первого оператора не имеет оператор FUNCTION, SUBROUTINE
или BLOCK DATA. Первым оператором головной программы может быть
оператор PROGRAM. Головным программам всегда присваивается глобальное
имя _main; это имя для других целей использовано быть не может (имя
_main разрешено использовать в качестве имени
"общего"
блока,
локальной
переменной
в подпрограмме, используемой вне головной
программы, либо в качестве имени подпрограммы в модуле, который не
содержит оператор PROGRAM. Однако, в виду того, что при работе могут
возникать "некоторые проблемы" при использовании имен, использование
имени "main" для других целей, отличных от указанной выше, не
рекомендуется). Если в головной программе указан оператор PROGRAM, то
имя, специфицированное в операторе PROGRAM, присваивается программе
дополнительно к имени _main.
Исполнение программы всегда начинается с первого исполнимого
оператора в головной программе; таким образом в исполнимой программе
должна быть только одна головная программа. (См. также подразд.4.2).
2.8
Процедуры
Процедурой является программный модуль, который может быть вызван
из других программных модулей при помощи оператора
CALL.
При
активизации
процедура
выполняет
набор
операций
(действий),
определенных ее исполнительными операторами. Затем процедура передает
управление в оператор, следующий сразу за оператором вызова процедуры,
либо в оператор, специфицированный как "изменяемый возврат" (см. также
подразд.4.2).
Процедура
непосредственно
не
возвращает значение. Однако,
значения могут быть переданы назад в вызывающий программный модуль
через параметры или "общие" переменные. (См. также подразд.4.2).
2.9
Подпрограммы (модули) блоков данных
Подпрограммы данного типа представляют собой программные модули,
которые описывают начальные значения переменных в
поименованных
"общих" блоках.
Обычно переменные инициализируются при помощи операторов DATA.
Переменные в поименованных "общих" блоках могут быть инициализированы
только в подпрограммах данного типа, причем таким способом не могут
быть инициализированы переменные, находящиеся в пустых "общих" блоках
(см. также подразд.4.2).
2.10
Функции
Указатель функции указывается в выражении; возвращаемое значение
функции используется при вычислении данного выражения. Функции также
могут возвращать значения через параметры и "общие" переменные.
Различают три вида функций:
1. внешние функции
2. операторные функции
3. встроенные функции
Каждый вид указанных функций подробно описан ниже. Встроенные
функции описаны в разделе 5 "Встроенные функции и дополнительные
процедуры".
Указатель
функций
может
присутствовать
в арифметических,
символьных или логических выражениях. При
исполнении
указателя
функции, функция вычисляется и результирующее значение используется
как операнд выражения, содержащего
указатель
функции.
Следует
отметить, что если на символьную функцию имеется ссылка в программном
модуле, то длина функции, специфицированная в программном модуле,
должна быть "выражением целочисленной константы".
Указатель функции имеет следующий синтаксис:
<fname>([<argument-list>])
где <fname> - есть имя внешней, встроенной или операторной функции;
<arguments> - фактические параметры. Если задано более одного
параметра, то они разделяются запятыми.
Правила, применяемые к параметрам функций, тождественны правилам,
применяемым для процедур (за исключением альтернативного возврата,
который в данном случае
недопустим).
Некоторые
дополнительные
ограничения, специфичные для операторных и встроенных функций, описаны
в подразд.2.10.2 и разделе 5.
2.10.1
Внешние функции
Внешняя функция является функцией, определяемой пользователем (в
отличие от встроенной функции языка ФОРТРАН). Она может быть включена
в исходный код головной программы или в отдельно компилируемый модуль.
Она начинается с оператора FUNCTION и завершается оператором END.
ПРИМЕР
C Следующий пример представляет собой внешнюю функцию,
C которая выполняет аппроксимацию определенного интеграла
C по методу Симпсона
100
INTEGER FUNCTION Simpson (delx, steps, y)
INTEGER delx, y(100), sum, steps, factor
sum = 0
DO 100 i = 0, steps
IF ((i .EQ. 0) .OR. (i .EQ. steps)) THEN
factor = 1
ELSE IF (MOD (i, 2) .EQ. 0) THEN
factor = 2
ELSE
factor=4
END IF
sum = factor * y(i) + sum
CONTINUE
Simpson = INT ((REAL (delx) /3.0) * REAL (sum))
END
2.10.2
Операторные функции
Операторная функция определяется единственным оператором и по
форме похожа на оператор присваивания. Тело операторной функции
определяет операторную функцию.
Операторная функция не является исполнимым оператором, поскольку
не находится в исполнительной последовательности как первый оператор
определенного программного модуля. Она выполняется, как и другие
функции, путем исполнения указателя функции, указанного в выражении.
Синтаксис и использование оператора операторной функции описаны в
подразд.4.2.
3. СИСТЕМА ВВОДА/ВЫВОДА
В
данном
разделе
рассматривается
система
ввода/вывода,
реализованная в языке ФОРТРАН фирмы Microsoft. В разделе описываются
типы файлов и перечислены операторы, использующиеся для обработки
данных. В дополнительных подразделах описаны разрешенные параметры
(опции) операторов ввода/вывода и использование символов управления
кареткой, форматирования ввода/вывода и дескрипторов редактирования.
Рассматриваются также ввод/вывод, управляемый списком и ввод/вывод,
управляемый именованным списком.
3.1
Общие сведения о системе ввода/вывода
В системе ввода/вывода языка ФОРТРАН данные сохраняются в файлах
и могут передаваться между файлами. Различают два основных типа
файлов:
Тип
----------------Внешние файлы
Внутренние файлы
Описание
-------------------------------------------------Либо устройство, например экран, клавиатура или
принтер; либо файл, сохраняемый на устройстве,
например файл на диске;
Символьная
подстрока,
символьная
переменная,
элемент символьного массива, символьный массив,
элемент символьной структуры
массив (см. также разд.3.5).
или
несимвольный
Все
файлы
состоят
из
записей,
представляющих
собой
последовательности символов или значений.
Ввод данных представляет собой процесс передачи данных из файла
во внутреннюю память, вывод данных - передачу данных из внутренней
памяти в файл. Ввод данных осуществляется путем их чтения из файла,
вывод данных - путем записи в файл.
3.2
Операторы ввода/вывода
Операторы ввода/вывода языка ФОРТРАН обеспечивают передачу и
преобразование данных, обработку файлов, определение или описание
возможностей взаимосвязей файлов. Операторы ввода вывода перечислены в
табл.3.1.
Таблица 3.1
Операторы ввода/вывода
-------------------------------------------------------------: Оператор
:
Функция
:
:----------------+-------------------------------------------:
:BACKSPACE
:Позиционирование файла назад на одну запись:
:CLOSE
:"Отключает" устройство
:
:ENDFILE
:Вывод записи "конец файла" во внешний файл :
:INQUIRE
:Получение информации о характеристиках и:
:
:текущем состоянии указанного внешнего файла:
:
:или устройства
:
:LOCKING
:Управление доступом к информации специфи-:
:
:ческих файлов прямого доступа и/или записей:
:OPEN
:Ассоциирование
номера
устройства
с :
:
:конкретным файлом
:
:PRINT
:Вывод данных на устройство, отмеченное :
:
:звездочкой (*)
:
:READ
:Ввод данных
:
:REWIND
:Репозиционирование файла в его начальную
:
:
:позицию
:
:WRITE
:Вывод данных
:
-------------------------------------------------------------ПРИМЕЧАНИЕ
Кроме операторов ввода/вывода в языке ФОРТРАН
присутствуют
встроенные функции ввода/вывода, а именно: функция EOF (<unitspec>),
описанная в подразд.5.1.14. Встроенная функция EOF возвращает, в
качестве значения результата, логическое значение, которое указывает
на то, остались ли в файле данные после данной позиции (т.е. позиции
конца файла).
В операторах ввода/вывода пользователь может указывать группы
параметров. Например, оператор CLOSE имеет следующий синтаксис:
CLOSE ([UNIT=]<unitspec>
[,ERR=<errlabel>]
[,IOSTAT=<iocheck>]
[,STATUS=<status>])
В
операторе
CLOSE
могут
быть
указаны
три,
необязательные,
параметра: [,ERR=<errlabel>], [,IOSTAT=<iocheck>], [,STATUS=<status>].
(Хотя дескриптор UNIT= является необязательным, <unitspec> тем не
менее должно использоваться).
Параметры позволяют пользователю выполнять операции управления
ошибками (параметры ERR= и IOSTAT=); параметр STATUS= позволяет
указать, следует ли сохранить или удалить файл после прекращения
работы с ним. Следующий
оператор,
например,
закрывает
файл,
присоединенный к устройству 2, передает управление в оператор с меткой
100, если вознокает ошибка ввода/вывода, и использует принимаемое по
умолчанию значение параметра STATUS =:
CLOSE (UNIT = 2, ERR = 100)
Параметры, используемые только в одном операторе, описаны в
подразделе 4.2. Четырнадцать параметров
операторов
ввода/вывода
используются более чем в одном операторе ввода/вывода: они рассмотрены
в данном разделе (см. табл.3.2).
Таблица 3.2
Параметры ввода/вывода
----------------------------------------------------------------┐
: Параметр
: Операторы ввода/вывода
: Подраздел :
:--------------------+-----------------------------+------------:
:ACCESS=<access>
:INQUIRE, OPEN
:3.2.3
:
:BLOKSIZE=<blocksize>:INQUIRE,OPEN
:3.2.4
:
:<editlist>
:FORMAT,PRINT,READ,WRITE
:3.2.5
:
:ERR=<errlabel>
:Все, за исключением PRINT
:3.2.6
:
:FILE=<file>
:INQUIRE, OPEN
:3.2.1
:
:[FMT=]<formatspec> :PRINT,READ,WRITE
:3.2.7
:
:FORM=<form>
:INQUIRE,OPEN
:3.2.9
:
:<iolist>
:PRINT,READ,WRITE
:3.2.10
:
:IOSTAT=<iocheck>
:Все, за исключением PRINT
:3.2.6
:
:MODE=<mode>
:INQUIRE,OPEN
:3.2.11
:
:[NML=]<nmlspec>
:PRINT,READ,WRITE
:3.2.8
:
:REC=<rec>
:LOCKING,READ,WRITE
:3.2.12
:
:SHARE=<share>
:INQUIRE,OPEN
:3.2.11
:
:[UNIT=]<unitspec>
:Все, за исключением PRINT
:3.2.2
:
----------------------------------------------------------------В
следующем
списке
дано
краткое
описание
параметров,
перечисленных в табл.3.2. Их полное описание приведено в подразделах
3.2.1-3.2.12.
Параметр
-------------------ACCESS=
BLOKSIZE=
<editlist>
END
Описание
--------------------------------------------Специфицирует или определяет метод
доступа
к файлу, который может быть 'SEQUENTIAL',
'DIRECT'
или
'APPEND'. Возвращает метод
доступа
к
файлу,
который
может
быть
'SEQUENTIAL' или 'DIRECT'.
Специфицирует
размер
внутреннего буфера,
используемого при вводе/выводе.
Перечисляет
дескрипторы
преобразования.
Параметр используется в операторах FORMAT и
спецификаторах
формата
(параметр
FMT=<formatspec>)
для
описания
формата
данных.
Передача управления в оператор с
меткой
в параметре END= при встрече конца файла.
Управляет процессом обработки ошибок ввода/
вывода.
Параметр
ERR=
указывает
метку
исполнительного оператора, куда передается
управление после возникновения ошибки.
Управляет процессом обработки ошибок ввода/
вывода. Параметр IOSTAT= указывает переменную
которая устанавливается для индикации места
возникновения ошибки.
Специфицирует имя файла.
Специфицирует
"список
дескрипторов
преобразования" <editlist> для использования
при форматировании данных.
Специфицирует
формат
файла;
может быть
'FORMATTED', 'UNFORMATTED' или 'BINARY'.
Специфицирует список входных или выходных
данных.
Управляет способом доступа к файлу других
процессов в сетевой системе.
Параметр MODE= может быть
установлен
в
состояние 'READWRITE', 'READ' или 'WRITE'.
Задает
группу
namelist как вводную или
выводную.
Управляет
способом одновременного доступа
группы процессов к файлу в сетевой системе.
Параметр SHARE= может быть установлен
в
состояние
'COMPAT', 'DENYNONE', 'DENYWR',
'DENYRD' или 'DENYRW'.
Специфицирует
первую
(или
единственную)
запись файла как защищенную, "только для
чтения", или "только для записи".
Специфицирует
устройство,
к
которому
присоединяется файл.
ERR=
IOSTAT=
FILE=
FMT=
FORM=
<iolist>
MODE=
NML=
SHARE=
REC=
UNIT=
3.2.1
Имена файлов (параметр FILE=)
Файл может иметь имя. Имена файлов должны удовлетворять правилам,
перечисленным в подразд.1.2. Имя внутреннего файла есть имя символьной
подстроки,
символьной переменной, элемента символьной структуры,
элемента символьного массива, символьного массива или несимвольного
массива, образующего файл. Имя внешнего файла есть строка символов,
тождественная имени, под которым файл известен для операционной
системы.
(Следует
помнить,
что некоторые операционные системы
"безразличны к регистру букв", используемых в имени). Операционная
система "предполагает", что файл находится в текущем рабочем каталоге,
если
пользователь не указал путь. Имена внешних файлов должны
удовлетворять
соглашениям
об
именовании
файлов,
принятым
в
используемой пользователем операционной системе.
Внешний файл может быть связан с номером модуля на языке ФОРТРАН
одним из следующих способов:
- если файл открывается с использованием оператора OPEN, то имя
файла может быть указано в операторе OPEN;
- если файл открыт при помощи оператора OPEN для устройства,
отличного от заранее присоединенных устройств (с номерами 0, 5 и 6) и
в нем не указано имя файла, то файл рассматривается как рабочий или
временный файл; в этом случае используется имя, принимаемое по
умолчанию;
если
файл
открыт при помощи оператора OPEN и в нем
специфицировано "пустое" имя файла (т.е. оно состоит из
одних
пробелов), то имя может быть взято из командной строки или назначено
пользователем (см. подразд.4.2);
- если в операторах READ или WRITE имеется ссылка (обращение) на
файл, который в данный момент еще не открыт, то выполняется неявная
операция открытия файла (см. подразд.4.2). Неявная операция открытия
файла
эквивалентна
исполнению
оператора
OPEN
с
именем,
специфицированным как "пустое" имя. Поэтому имя считывается
из
командной
строки
или
может
быть
введено пользователем (см.
подразд.4.2).
3.2.2
Устройства (параметр UNIT=)
Для
большинства
операций
ввода/вывода
файл
должен быть
идентифицирован спецификатором устройства. Спецификатор устройства
внутреннего файла является тем же самым, что и имя этого внутреннего
файла (см. подразд.3.5). Для внешнего файла пользователь
может
присоединить файл к некоторoму спецификатору устройства при помощи
оператора
OPEN.
Некоторые
спецификаторы
внешних
устройств,
перечисленные
ниже,
являются "заранее присоединенным" некоторым
устройствам и "не требуют, чтобы их специально открывали". Внешние
устройства,
которые пользователь "присоединил" к файлами, будут
"отсоединяться" при завершении (нормальном или аварийном) исполнения
программы, либо когда устройство "будет отсоединено" при помощи
оператора CLOSE.
Спецификатор
устройства
необходим
для
всех
операторов
ввода/вывода за исключением оператора PRINT (поскольку при этом вывод
всегда назначается на стандартное устройство),
оператора
READ,
указываемого только со спецификатором формата и списком ввода/вывода,
оператора INQUIRE (т.к. при этом специфицируется имя файла, а не
устройство, с которым ассоциируется файл).
Спецификатор внешнего устройства должен быть либо целочисленным
выражением, либо звездочкой (*). Значение целочисленного выражения
должно находится в диапазоне от -32.767 до 32.767. В следующем примере
внешний файл UNDAMP присоединяется к устройству 10 и выполняется
операция записи:
OPEN (UNIT = 10, FILE = 'undamp')
WRITE (10, *) ' Undamped Motion:'
Спецификатор
устройства
звездочка
(*)
является
"заранее
присоединенным" и не может быть "присоединен" к файлам при помощи
оператора
OPEN.
Данный
спецификатор
является
единственным
спецификатором, который не может быть переназначен для другого файла.
Спецификатор устройства звездочка указывает клавиатуру при чтении
файла и экран при записи. В следующем примере спецификатор устройства
звездочка используется для записи (файла) на экран:
WRITE (*, '(1x, ''Begin output.'')')
В языке ФОРТРАН
внешних устройства:
Устройство
-----------звездочка(*)
0
определены
четыре
"заранее
присоединенных"
Описание
------------------------------------------всегда представляет клавиатуру или экран
начально представляет клавиатуру или экран
5
начально представляет клавиатуру
6
начально представляет экран
---------------------------------------------------------Устройство,
определенное как звездочка (*), не может быть
определено для любого другого файла, а попытка "закрыть" такое
устройство вызовет ошибку компиляции. Устройства 0, 5 и 6, однако,
могут быть присоеденены к любым файлам при помощи оператора OPEN. Если
пользователь "закрывает" устройство 0, 5 или 6, то оно автоматически
переназначается
клавиатуре
и
экрану,
клавиатуре
или экрану,
соответственно.
При чтении или записи на устройство, которое в данный момент
отсоеднинено, файл открывается неявно (см. подразд.4.2).
ПРИМЕРЫ
В следующем примере
собой внутренний файл:
символьная
переменная
fname представляет
C Выходными данными этой программы являются FMOO4.DAT
CHARACTER*14 fname
ifile = 4
WRITE (fname, 100) ifile
100 FORMAT ('FM', I3.3, '.DAT')
WRITE (*, *) fname
END
В следующем примере выполняется операция записи на устройство 6
(экран), затем устройство 6 переназначается
внешнему
файлу
и
записывает его; в заключении устройство 6 переназначается экрану и
выполняется операция записи:
REAL a,b
C Запись на экран (устройство 6)
WRITE (6, '("Это устройство 6")')
C Для связывания устройства 6 с внешним файлом с именем 'COSINES'
C используется оператор OPEN
OPEN (UNIT= 2*3, FILE = 'COSINES', STATUS = 'NEW')
DO 200 a = 0.1, 6.3, 0.1
b = cos(a)
C Запись в файл 'COSINES'
WRITE (6, 100) a, b
100 FORMAT (F3.1, F5.2)
200 CONTINUE
C Устройство 6 назначается экрану
CLOSE (6, STATUS = 'KEEP')
C Запись на экран
WRITE(6,' ('' Cosines completed'')')
END
3.2.3
Метод доступа к файлу (параметр ACCESS=)
В следующих подразделах описываются способы доступа к файлу:
последовательный, прямой и
"позиционирование
в
конец
файла".
Последовательные
файлы
содержат
записи
данных
в
той
последовательности, в которой они были записаны в файл; "прямые" файлы
являются "файлами случайного доступа".
3.2.3.1
Последовательный метод доступа
Последовательный
файл содержит записи, упорядоченные в той
последовательности, как они записывались в файл.
Ко всем внутренним файлам применяется последовательный доступ.
Последовательный доступ применим также к файлам, ассоциированным с
"последовательными устройствами", т.е. такими
устройствами,
для
которых допустимы только операции чтения и записи. "Последовательными
устройствами" являются клавиатура, экран, принтер.
Следует
помнить, что операции прямого доступа для файлов,
открытых для последовательного доступа, не разрешены. Существующий
последовательный файл может быть открыт в режиме 'APPEND'. При этом
файл немедленно позиционируется после последней записи перед маркером
"конец-файла".
3.2.3.2
Метод прямого доступа
Файлы прямого доступа представляют собой файлы
"случайного
доступа",
записи
которых
читаются
и
записываются
в
любой
последовательности. Файл прямого доступа должен постоянно находится на
диске. Связывать файл прямого доступа с последовательным устройством
(клавиатурой, экраном или принтером) нельзя.
Записи перечислены последовательно, начиная с первой, для которой
указывается номер 1. Все записи имеют одинаковую длину, указываемую
параметром RECL= в операторе OPEN. Одна запись записывается для
каждого неформатного оператора READ или WRITE. Форматные операторы
READ и WRITE могут передавать более одной записи, используя дескриптор
редактирования в виде символа прямого слэша (/).
За исключением двоичных файлов, количество байтов, записываемых в
запись, должно быть меньше или равно длине записи. Для двоичных файлов
единственный оператор READ или WRITE может читать или записывать
столько записей, сколько их требуется для обеспечения соответствия
количеству передаваемых байтов. При выводе данных неполные форматные
записи дополняются пробелами. Неполные неформатные и двоичные записи
дополняются неопределенными байтами (нулями).
В случае файлов прямого доступа имеется возможность выводить
записи не попорядку (например, записи с номерами 9, 5 и 11); записи,
находящиеся между ними, при этом не выводятся. Удалить однажды
записанную запись не представляется возможным; однако, запись может
быть "перезаписана" с новым значением.
Операция чтения записи, которая не была записана в файл прямого
доступа, является ошибочной и приводит к ошибками на этапе исполнения.
Если запись записывается за пределами ранее назначенного признака
конца файла, то операционная система будет пытаться расширить файлы
прямого доступа. Однако выполнение такой операции возможно только при
наличии достаточного свободного места на физическом устройстве.
Каждая операция READ или WRITE для файла прямого доступа должна
явно задавать запись, к которой выполняется доступ. Следует отметить,
что в языке ФОРТРАН фирмы Microsoft для файлов, открытых как файлы
прямого доступа, допустимы также и "последовательные" операции.
В
следующем примере выполняется операция чтения третьей и
четвертой записей файла XXX:
OPEN (1, FILE= 'xxx', ACCESS = 'DIRECT', RECL = 15
+
FORM ='FORMATTED')
READ (1, '(3I5)', REC = 3) i, j, k
READ (1, '(3I5)') l, m, n
Файл создается как файл прямого доступа и открывается в режиме
'APPEND', что является принятым по умолчанию для последовательного
доступа.
3.2.4
Размер буфера ввода/вывода (параметр BLOCKSIZE=)
Одним из способов управления размером программы и скоростью ее
исполнения является использование параметра BLOCKSIZE в операторе
OPEN. Значением параметра BLOCKSIZE является целочисленное выражение,
указывающее размер внутреннего буфера, используемого при выполнении
операций ввода/вывода. Поскольку специфицированный размер блока обычно
округляется до размера следующего блока, параметр BLOCKSIZE=
в
операторе INQUIRE предоставляет возможность определять фактический
размер используемого буфера.
3.2.5
Список дескрипторов преобразования
Списки дескрипторов преобразования задают и описывают формат
данных. Они используются в операторах FORMAT и спецификаторах формата.
Список
дескрипторов преобразования (включая внешние скобки)
представляет собой символьную константу и заключается в апострофы при
его указании в операторах READ и WRITE. В версии языка ФОРТРАН фирмы
Microsoft список дескрипторов преобразования может быть заключен в
кавычки. При указании списка дескрипторов в операторе FORMAT апострофы
не задаются.
Список
представляет
собой
последовательности
форматных
дескрипторов, разделенных запятыми. Пользователь
может
опустить
запятую между двумя элементами списка, если результирующий список при
этом не станет "двусмысленным". Например, пользователь может опустить
запятую после дескриптора P или перед или после символа слэша (/).
Различаются три типа дескрипторов преобразования:
1. неповторяющиеся дескрипторы преобразования (<nonrepeatable>);
2. повторяющиеся
дескрипторы
преобразования,
которым,
необязательно, предшествует спецификатор повторения (<n-repeatable>);
3. список
дескрипторов преобразования, заключенный в круглые
скобки, которому необязательно предшествует спецификатор повторения (n
(<editlist>)).
Спецификатор
повторения
представляет
собой
ненулевую
целочисленную константу без знака (см. также подразд.3.7.2).
В
следующем списке даны примеры описаний преобразования каждого типа:
Описание
---------------<nonrepeatable>
Примеры
--------'Total='
3Hyes
SP
BN
1X
<n-repeatable>
215
15
10F8.2
3A10
E12.7E2
n(<editlist>)
2(1X,215)
(1X, 'Total=',E12.7E2)
(3A10, 10F8.2)
920 (10F8.2)
2(13(215),SP, 'Total=',F8.2)
В списке дескрипторов преобразования <editlist> допустимо до 16
уровней встроенных круглых скобок.
ПРИМЕРЫ
В следующей программе содержатся два примера списков дескрипторов
преобразования <editlist>:
INTEGER a, b
REAL x, y
DATA a /52/, b /9/, x /5832.67/, y /1.02781/
WRITE (*, 100) a, b
C Список в следующем операторе FORMAT находится
C ниже строки дефисов:------------------------------100
FORMAT (' A = ',15, 'B =', 15)
WRITE (*, 200) x, y
C Список в следующем операторе FORMAT находится
C ниже строки дефисов:-------------------------------200
FORMAT (' ', 2(F8.3, 1Hm))
END
На экран при выполнении этой программы будет записано следующее:
A =
5832.670m
52B =
9
1.028m
Следует отметить, что каждый форматный оператор WRITE в качестве
символа "управления кареткой" записывает на терминальное устройство
символ пробела.
3.2.6
Управление ошибками и концом файла
(параметры IOSTAT=, ERR=, END=)
Если во время выполнения оператора ввода/вывода
встретится
ошибочная запись или запись "конец файла", то в зависимости от наличия
и описания параметров ERR=<errlabel>, IOSTAT=<iocheck>, END=<endlabel>
будет выполнено соотвествующее действие. Следует отметить, что при
обнаружении записи "конец файла", она будет обрабатываться как ошибка
каждого оператора ввода/вывода, кроме оператора READ.
Поскольку оператор PRINT не обеспечивает возможности спецификации
ни одного из указанных параметров, то ошибка, встречающаяся во время
исполнения оператора PRINT, всегда будет генерироваться как ошибка
этапа исполнения.
В
табл.3.3
показано, какие действия выполняются, когда в
операторе READ встречается запись "конец файла" или ошибочная запись.
Следует
отметить, что в любой момент, когда в операторе READ
встречается ошибка, все элементы в списке ввода/вывода <iolist>
становятся неопределенными.
Таблица 3.3
Ошибочная запись и запись "конец файла" при выполнении
операции чтения
---------------------------------------------------------:Установка:Установка:Установка:Встретилась :Встретилась :
:IOSTAT
:END
:ERR
:запись "ко- :ошибка, или :
:
:
:
:нец файла" :ошибка и
:
:
:
:
:
:"конец файла":
:---------+---------+---------+------------+-------------:
: Нет
:
Нет
:
Нет
:Выдается
:Выдается
:
:
:
:
:ошибка этапа:ошибка этапа :
:
:
:
:исполнения :исполнения
:
:---------+---------+---------+------------+-------------:
: Нет
:
Нет
:
Да
:Переход к
:Переход к
:
:
:
:
:<errlabel> :<errlabel>
:
:---------+---------+---------+------------+-------------:
: Нет
:
Да
:
Нет
:Переход к
:Выдается
:
:
:
:
:<errlabel> :ошибка этапа :
:
:
:
:
:исполнения
:
:---------+---------+---------+------------+-------------:
: Нет
:
Да
:
Да
:Переход к
:Переход к
:
:
:
:
:<errlabel> :<errlabel>
:
:---------+---------+---------+------------+-------------:
: Да
:
Нет
:
Нет
:iocheck ус- :iocheck ус- :
:
:
:
:танавливает-:танавливает- :
:
:
:
:ся в отрица-:ся в положи- :
:
:
:
:тельное зна-:тельное зна- :
:
:
:
:чение и вы- :чение и вы- :
:
:
:
:полнение
:полнение
:
:
:
:
;продолжается:продолжается :
:---------+---------+---------+------------+-------------:
: Да
:
Нет
:
Да
:
-":
-":
:---------+---------+---------+------------+-------------:
: Да
:
Да
:
Нет
:iocheck ус- :
-":
:
:
:
:танавливает-:
:
:
:
:
:ся в отрица-:
:
:
:
:
:тельное зна-:
:
:
:
:
:чение и вы- :
:
:
:
:
:полняется
:
:
:
:
:
:переход к
:
:
:
:
:
:<endlabel> :
:
:---------+---------+---------+------------+-------------:
: Да
:
Да
:
Да
:
-":iocheck ус- :
:
:
:
:
:танавливает- :
:
:
:
:
:ся в положи- :
:
:
:
:
:тельное зна- :
:
:
:
:
:чение и вы- :
:
:
:
:
:полняется
:
:
:
:
:
:переход к
:
:
:
:
:
:<errlabel>
:
---------------------------------------------------------В приведенном ниже списке
показано,
что
происходит
при
возникновении
ошибки
(включая
запись "конец файла") во время
выполнения любого оператора ввода/вывода, отличного от операторов READ
или PRINT:
Ситуация
-----------------------Не указан ни <errlabel>
ни <iocheck>
Результат
--------------------------------------Выполнение
программы
прерывается;
выдается
сообщение об ошибке этапа
исполнения
Указан
только <errlabel>
Указан только <iocheck>
Управление
передается
указанный в <errlabel>
в
оператор,
Значение
<iocheck>
устанавливается
в
значение
положительного
целого
и управление передается (возвращается)
таким
образом,
как
если
бы оператор выполнился без ошибки
Указаны и <errlabel>
и <iocheck>
<iocheck>
устанавливается
в
положительное значение и управление
передается в оператор, указанный в
<errlabel>
---------------------------------------------------------------------Если выполнение оператора ввода/вывода прерывается, а ошибочная
запись или запись "конец файла" не встретилась, и кроме того был
специфицирован
параметр
<iocheck>,
то
параметр
<iocheck>
устанавливается в значение "ноль".
ПРИМЕРЫ
В следующем примере ни один из допустимых параметров (ERR=,
IOSTAT=, END=) не установлен, так что если для переменной i вводится
ошибочное значение, то будет выдана ошибка этапа исполнения:
INTEGER i
WRITE (*, *) 'Введите i:'
READ (*, *) i
WRITE (*, *) 'Это значение i:',i
END
В следующей программе для подсказки пользователю о необходимости
ввести правильное число используется параметр ERR=:
INTEGER i
WRITE (*, *) 'Введите i:'
50 READ (*, *, ERR = 100) i
WRITE (*, *) 'Это значение i:',i
STOP ' '
100 WRITE (*, *) 'ошибочное значение. Введите новое i:'
GOTO 50
END
В
следующей
программе
для
управления
используются параметры ERR= и IOSTAT=:
50
100
ошибочным
INTEGER i
WRITE (*, *) 'Введите i:'
READ (*, *, ERR = 100, IOSTAT = j) i
WRITE (*, *) 'Это значение i:', i, iostat=', j
STOP ' '
WRITE (*, *) 'iostat=', j, 'Введите новое i:'
GOTO 50
END
3.2.7
Спецификатор формата (параметр FMT=)
вводом
Спецификаторы
формата
либо
содержат
список
дескрипторов
преобразования,
либо
указывают,
какой
список
дескрипторов
преобразования
используется
для
спецификации
формата
данных.
Спецификаторы формата используются в операторах PRINT, READ и WRITE.
В следующих
подразделах
показаны
семь
допустимых
типов
спецификаторов
формата,
а
также приведен пример, показывающий
возможности использования каждого спецификатора формата.
3.2.7.1
Метка оператора FORMAT
Спецификатор формата может быть меткой оператора FORMAT. В этом
случае,
список
дескрипторов
преобразования,
специфицируемый в
операторе FORMAT, может использоваться для форматирования выходных или
входных данных. В следующем обобщенном примере показано, как метка
оператора FORMAT может быть использована для спецификации списка
дескриптора преобразования для оператора WRITE:
WRITE (*,<label>)<iolist>
<label> FORMAT(<editlist>)
Операторная метка <label> относится к оператору FORMAT.
3.2.7.2
Имя целочисленной переменной
Для установления "взаимосвязи" целочисленной переменной и метки
оператора FORMAT может быть использован оператор ASSIGN. В дальнейшем
целочисленная
переменная
может
использоваться как спецификатор
формата, например:
ASSIGN <label> TO <var>
<label> FORMAT(<edilist>)
WRITE (*,<var>) <iolist>
В операторе WRITE имя целочисленной переменной <var> относится к
метке <label> оператора FORMAT; назначение выполнено непосредственно
перед использованием оператора FORMAT (см. также подподразд.4.2).
3.2.7.3
Символьные выражения
Список
дескрипторов
преобразования
может
быть задан как
символьное выражение, которое в свою очередь может быть использовано
как спецификатор формата, например:
WRITE(*,'(<editlist>)')<iolist>
Символьное выражение может быть символьной константой. Оно не
может быть выражением, включающим операцию конкатенации операндов,
спецификатор длины которых является звездочкой в круглых скобках, если
этот операнд не является, однако, символическим именем константы.
3.2.7.4
Символьная переменная
Список дескрипторов преобразования может быть
записан
как
символьное выражение; это выражение может быть присвоено символьной
переменной. Затем символьная переменная может использоваться как
спецификатор формата, например:
CHARACTER*n <var>
<var> = '(<editlist>)'
WRITE(*,<var>)<iolist>
В этом примере оператор WRITE использует символьную переменную
<var> как спецификатор формата.
3.2.7.5
Звездочка (*)
Когда в качестве спецификатора формата используется звездочка
(*), тогда выполняется операция ввода/вывода, управляемая списком,
например:
WRITE (6,*)<iolist>
В данном примере вторая звездочка указывает
управляемый списком (см. также подразд.3.8).
3.2.7.6
на
ввод/вывод,
Имя символьного или несимвольного массива
Список дескрипторов преобразования
может
быть
задан
как
символьное выражение; это выражение может быть назначено массиву. В
дальнейшем массив может использоваться как спецификатор формата,
например:
CHARACTER*<bytes> <array>(<dim>)
DATA <array>/'(<editlist>)'/...
WRITE(*,<array>)<iolist>
Массив интерпретируется таким образом, как если бы все его
элементы
были
конкатенированы
в последовательности возрастания
(номеров)
столбцов
(см.
подразд.4.2,
где
описана
процедура
упорядочения
элементов
массива). Если специфицирован символьный
массив, то элементы такого массива обрабатываются как эквивалентные
символьные переменные, имеющие такую же длину.
Несимвольный массив также может быть специфицирован как массив, в
котором
элементы
обрабатываются
как
эквивалентные
символьные
переменные одинаковой длины.
Если для спецификации списка используется константа Холлерита, то
список не может содержать дескриптор преобразования в виде апострофа
или дескриптор преобразования H.
ПРИМЕР
Следующая программа использует символьный массив char и массивы
вещественных чисел real1 и real2 для записи фразы (The result are:) и
значений двух целочисленных массивов; запись выполняется трижды:
$NOTSTRICT
INTEGER array1(6), array2(4)
CHARACTER*8 char(4)
REAL*8 real1(4), real2(4)
C формат следующий ==> (" The result are: ", 616, 416)
DATA char / "(' The r", "esults a", "re: ', 6",
+
"16, 416)"
DATA real1 "(' The r", "esults a", "re: ', 6",
+
"16, 416)"
DATA real2 / 8H(' The r, 8Hesults a, 8Hre: ', 6,
+
8H16, 416)"
WRITE (*, char) array1, array2
WRITE (*, real1) array1, array2
WRITE (*, real2) array1, array2
3.2.7.7
Элемент символьного массива
Список
дескрипторов
преобразования
может
быть задан как
символьное выражение; это выражение может быть назначено элементу
символьного массива. В дальнейшем элемент символьного массива может
быть использован в качестве спецификатора формата, например:
CHARACTER*<bytes> <array>(<dim>)
array(n)='(<editlist>)'
WRITE(*,array(n))<iolist>
В данном примере оператор WRITE использует элемент символьного
массива array (n) в качестве спецификатора формата.
3.2.8
Спецификатор списка именования (параметр NML=)
Внутри
оператора
WRITE
спецификатор
списка
именования
предписывает именам и значениям всех переменных в списке именования
записываться
на
заданное
устройство.
Внутри
оператора
READ
спецификатор
"подсказывает"
пользователю
о необходимости ввода
значений для одного или нескольких переменных в списке именования.
Дополнительные сведения приведены в подразд.3.9.
3.2.9
Структура файла (параметр FORM=)
Структура файла зависит от метода доступа к файлу, определяемого
параметром ACCESS= (см. подразд.3.2.3), и формата данных в файле.
Файл может быть структурирован одним из следующих трех способов:
Формат
-------------Форматный
Неформатный
Двоичный
Описание структуры
--------------------------------------------------Файл
представляет
собой
последовательность
форматированных записей. Форматированными записями
являются
группы символов ASCII, оканчивающиеся
маркером
"конец-записи".
Записи
в
форматном
последовательном файле могут быть разной длины. Все
записи
в
форматном
файле
прямого
доступа
должны иметь одинаковую длину. Все
внутренние
файлы должны быть форматными.
Файл
представляет
собой
последовательность
неформатных
записей.
Неформатные
записи
представляют собой последовательность
значений.
Неформатный файл прямого доступа содержит только
такие данные, а каждая запись дополняется
до
фиксированной
длины
неопределенными
байтами.
Неформатные
файлы
последовательного
доступа
также
(дополнительно!)
содержат
информацию,
указывающую на границы длины каждой записи.
Двоичные
файлы
последовательного
доступа
представляют собой последовательности байтов, не
имеющих внутренней структуры. В файле такого типа
нет записей как таковых. Файл
содержит
лишь
информацию, специфицируемую как список элементов
ввода/вывода в операторах WRITE, в которых есть
ссылки на этот файл.
Двоичные файлы прямого доступа имеют очень простую
структуру.
Длина записи назначается параметром
RECL= оператора OPEN. Таким
образом
задаются
границы записей, которые используются только для
репозиционирования и добавления записей до и после
выполнения операций чтения и записи и во время
выполнения операций BACKSPACE. Эти границы записей,
однако, не ограничивают число байтов, которые могут
быть переданы во время выполнения операций чтения
или записи. Если во время выполнения операции
ввода/вывода будет предпринята попытка считать или
записать больше значений, чем содержится в записи,
то операция чтения или записи будет продолжена в
следующей записи. Следует отметить, что операции
ввода/вывода могут быть выполнены для неформатных
файлов
прямого
доступа:
при этом получается
такой же результат, что и в случае их применения
к
двоичным
файлам
прямого доступа. В обоих
случаях, т.е. для файлов
и
последовательного
и
прямого доступа, позиция считываемых данных
должна совпадать с позицией записываемых данных.
3.2.10
Список ввода/вывода
Список ввода/вывода, <iolisit>, специфицирует входные и выходные
данные
(см.
также
подразд.3.7.3,
где описано, каким образом
взаимосвязаны списки <iolist> и <editlist>).
В списке ввода/вывода <iolist> могут указываться
следующие
элементы:
* Элемента нет
(пустой список).
Список <iolist> может быть пустым. Результирующая запись
имеет нулевую длину, либо состоит только из символов дополнения:
либо
C Пример пустого списка ввода/вывода
WRITE( unit, '(1018)')
* Имя переменной, имя элемента массива, имя символьной подстроки,
либо имя элемента структуры.
Эти
элементы
указывают,
что переменная, элемент массива,
символьная подстрока или элемент структуры будут вводиться
или
выводиться:
C Пример переменной и элемента массива
C в списке ввода/вывода
READ (*, 500) n, bahb(n)
* Имя массива.
Имя
массива специфицирует все массивы в последовательности
возрастания (номеров) столбцов (см. также подразд.4.2 где описано,
каким образом массивы размещаются в памяти):
C Пример массива в списке ввода/вывода
INTEGER handle(5)
DATA handle / 5*0 /
99
WRITE (*, 99) handle
FORМАТ (1X, 515)
* Любое выражение.
Список выходных данных в операторах WRITE и PRINT может содержать
произвольные выражения, такие как числовые, логические или символьные.
* Список встроенных операторов DO.
Списки данного типа имеют следующую форму:
(<iolist>, <dovar>=<start>,<stop>[,<inc>])
В данном случае, список ввода/вывода <iolist> является списком
входных или выходных данных (и может содержать любые элементы этого
списка, включая другой список встроенных операторов DO). (См. также
подразд.4.2).
Элементы
списка
данного типа являются аналогами
операторов внутри
обычных
DO-циклов.
Если
список
встроенных
DO-операторов и цикл DO имеют одинаковые значения переменных <dovar>,
<start>, <stop>, <inc>,
тогда
элементы
в
списке
встроенных
DO-операторов считываются и записываются в той же последовательности,
что и последовательность, в которой выполняются операторы внутри
DO-цикла. В операторе READ, переменная <dovar> цикла DO (или любая
другая переменная, ассоциированная с <dovar>) не должна указываться в
списке ввода/вывода <iolist> в списке встроенных операторов DO.
Однако, переменная <dovar> может быть считана в том же операторе READ,
но прежде, чем будет "обрабатываться" список встроенных операторов DO.
C Примеры ввода и вывода с использованием
С операторов DO в списке ввода/вывода
INTEGER c, handle(10), n
WRITE (*, *) 'Enter c (<=10) and'
WRITE (*, *) 'handle(1) to handle(c)'
READ (*, 66) c, (handle(n), n = 1, c)
66
FORMAT (15, 10(:, /, 15))
WRITE (*, 99) c, (handle(n), i = 1, c)
99
FORMAT (1X,215)
END
3.2.11 Совместное использование файлов
(параметры MODE=,SHARE=)
В системах, допускающих многозадачность или использующих сетевую
обработку, к одному и тому же файлу одновременно могут обращаться
несколько программ. Для управления доступом к файлу в этом случае
используются два параметра оператора OPEN: MODE= и SHARE=. Эти
параметры также используются в операторе INQUIRE, так что пользователь
может определять статус доступа к файлу.
Значение параметра:
--------------------MODE=<mode>
Определяет:
------------------------------------------каким образом первый процесс, открывающий
этот файл,
может
использовать
данный
файл.
Пользователь
может
выбрать
режим
чтения
файла
('READ'),
записи
файла
('WRITE')
или
оба
варианта
('READWRITE')
SHARE=<share>
каким образом последующий процесс имеет
возможность обратиться к данному
файлу
(т.е.
когда
этот
файл
уже открыт).
Пользователь может выбрать режим чтения
файла
('DENYWR'),
записи
файла
('DENYRD'),
оба
варианта
('DENYNONE')
или
отказываться от данной возможности
('DENYRW'). Можно также выбрать
режим,
при котором доступ к файлу (кроме того
процесса,
который
его
открыл)
будет
запрещен для всех процессов ('COMPAT').
В таблице 3.4 показаны ограничения на открытие файла, который уже
является открытым (указаны конкретные значения <mode> и <share> для
этого файла).
Таблица 3.4
Значения параметров MODE и SHARE
------------------------------------------------------------------:Оригинальный процесс, открывае-:Параллельные процессы могут быть :
:мый со значениями параметров: :открыты со значениями параметров::
:-------------------------------+---------------------------------:
:
MODE=
:
SHARE=
:
MODE=
:
SHARE=
:
:----------------+--------------+-----------------+---------------:
:'READWRITE' или :'COMPAT'
:'READWRITE' или :'COMPAT' (толь-:
:'READ' или
:
:'READ' или
:ко оригинальным:
:'WRITE'
:
:'WRITE'
:процессором)
:
:----------------+--------------+-----------------+---------------:
:'READWRITE' или :'DENYRW'
:Файл может быть :
:
:'READ' или
:
:открыт параллель-:
:
:'WRITE'
:
:ным процессом
:
:
:----------------+--------------+-----------------+---------------:
:'READWRITE' или :'DENYWR'
:'READ'
:'DENYNONE'
:
:----------------+--------------+-----------------+---------------:
:'READ'
:'DENYWR'
:'READ'
:'DENYNONE' или :
:
:
:
:'DENYWR'
:
:----------------+--------------+-----------------+---------------:
:'WRITE'
:'DENYWR'
:'READ'
:'DENYNONE' или :
:
:
:
:'DENYRD'
:
:----------------+--------------+-----------------+---------------:
:'READWRITE'
:'DENYRD'
:'WRITE'
:'DENYNONE'
:
:----------------+--------------+-----------------+---------------:
:'READ'
:'DENYRD'
:'WRITE'
:'DENYNONE' или :
:
:
:
:'DENYWR'
:
:----------------+--------------+-----------------+---------------:
:'WRITE'
:'DENYRD'
:'WRITE'
:'DENYNONE' или :
:
:
:
:'DENYRD'
:
:----------------+--------------+-----------------+---------------:
:'READWRITE'
:'DENYNONE'
:'READWRITE' или :'DENYNONE'
:
:
:
:'READ' или
:
:
:
:
:'WRITE'
:
:
:----------------+--------------+-----------------+---------------:
:'READ'
:'DENYNONE'
:'READWRITE' или :'DENYNONE' или :
:
:
:'READ' или
:'DENYRD'
:
:
:
:'WRITE'
:
:
:----------------+--------------+-----------------+---------------:
:'WRITE'
:'DENYNONE'
:'READWRITE' или :'DENYNONE' или :
:
:
:'READ' или
:'DENYRD'
:
:
:
:'WRITE'
:
:
------------------------------------------------------------------Если, например, пользователь имеет файл, открытый с параметром
MODE='READ' и параметром SHARE='DENYRD', то этот файл может быть также
открыт
с
параметром
MODE='WRITE'
и
SHARE='DENYNONE'
или
SHARE='DENYWR'.
Предположим,
например,
что
пользователю необходимо, чтобы
несколько процессов "читали" файл, а также чтобы ни один процесс не
объявлял файл, когда процессы первой группы выполняют операцию чтения
данного файла. Прежде всего, следует определить, какой тип доступа к
файлу необходимо обеспечить для оригинального процесса. В этом случае,
пользователю
необходимо
только
чтение
файла.
Таким образом,
оригинальный процесс должен открывать файл,
используя
параметр
MODE='READ'. Теперь определяется, какой тип доступа оригинальный
процесс должен обеспечить для других процессов: в этом случае, другие
процессы должны иметь возможность только читать данный файл. Поэтому,
первый
процесс
должен
открывать
файл,
используя
параметр
SHARE='DENYWR'. Теперь, как это указано в табл.3.4, определяем, что
другие процессы также могут открыть данный файл, используя параметры
MODE='READ' и SHARE='DENYWR'.
3.2.12
Номер записи (параметр REC=)
Параметр
REC=<recnum>
используется для спецификации номера
конкретной записи. В операторе LOCKING параметр <recnum> указывает на
то, защищена или не защищена первая запись. В операторах READ и WRITE,
параметр <recnum> указывает на то, читается или записывается первая
запись. Первая запись в файле является записью с номером 1.
3.3
Выбор типов файлов
Для создания
различных
типов
файлов
пользователь
может
комбинировать
свойствами
разрешенных
для использования файлов.
Различают два общих типа файлов:
1.
Последовательные
форматные
файлы,
"присоединенные"
к
устройству, помеченному звездочкой (*) (такое устройство представляет
клавиатуру или экран).
Следует отметить, что при чтении с устройства, отмеченного
звездочкой (*) (с клавиатуры), пользователь должен завершать каждую
строку нажатием клавиши ENTER. Для исправления ошибок ввода следует
применять
и
следовать
соглашениям,
принятым
в
используемой
операционной системе.
2. Поименованные последовательные форматные внешние файлы.
ПРИМЕР
В следующем примере используются оба типа файлов, указанных выше:
C
C
C
C
Копируется файл из трех столбцов целых чисел,
каждое шириной 7 позиций, из файла, имя которого
вводится пользователем для другого файла, с именем
OUT.TXT, сохраняя при этом позиции первого и второго столбцов.
PROGRAM ColSwp
CHARACTER*64 fname
C Выдача подсказки на экран, путем указания звездочки (*):
WRITE (*, 900)
900 FORMAT('ИМЯ ВХОДНОГО ФАЙЛА -'\)
READ(*, '(A)') fname
C Использование устройства 3 для ввода из внешнего файла:
OPEN
(3, FILE = fname)
C Использование устройства 4 для вывода второго внешнего файла
OPEN
(4, FILE = 'OUT.TXT')
C Чтение и запись, пока не встретится конец файла:
100 READ
(3, 920, END = 200) i, j, k
WRITE (4, 920) j, i, k
920 FORMAT (317)
GOTO 100
200 WRITE (*, '(A)') 'Выполнено'
END
Тип используемого пользователем файла зависит
от
решаемой
прикладной задачи. В следующем списке указаны несколько предпосылок
для выбора файлов других типов:
Если:
------------------необходим случайный
доступ при выполнении операций ввода/
вывода
Тогда:
---------------------------------------пользователь может использовать файлы
прямого доступа. Обобщенным
примером
прикладной задачи данного типа является
база
данных.
Формат
файла
может
быть
двоичным,
форматным
или
неформатным
доступ
к
данным
пользователя разрешен
только из ФОРТРАНа и
особое
значение
имеет
скорость
доступа
доступ
к
двоичным
и
неформатным
файлам выполняется быстрее, чем доступ
к форматным файлам
данные
должны
передаваться
без
предварительной
системной
интерпретации
наиболее "практичными" для использовании
будут
двоичные или неформатные файлы
все 256 возможных
значений
байтов
должны
быть
передаваемыми
необходимо
использовать
неформатный ввод/вывод
необходимо управлять
устройство с однобайтовым (двоичным) интерфейсом
необходимо
использовать
двоичный или
неформатный
ввод/вывод.
В
этой
ситуации
форматный
ввод/вывод
интерпретирует
некоторые
символы,
вместо передачи
их в программу без
изменения. Предпочтительнее оказывается
двоичный
формат, поскольку в файле
двоичный или
при этом не
его структуре
содержится
информации
о
данные
должны
передаваться
без
какой- либо системной
интерпретации и должны читаться программами, не являющимися
ФОРТРАН-программами
рекомендуется
использовать
двоичный
формат.
Неформатные файлы
являются
"внутренне
блокируемыми",
так
что программы, не являющиеся ФОРТРАНпрограммами, должны
быть
совместимы
с
данным
форматом
для
корректной
интерпретации
данных. Двоичные файлы
содержат
только те данные,
которые
в них записаны
пользователь читает
файл, созданный программой, написанной
на другом языке (не
на ФОРТРАНе)
рекомендуется
использовать
двоичный
ввода/вывод.
Не-ФОРТРАН-файлы
обычно
имеют структуру, отличную от структуры
ФОРТРАН-файлов.
Двоичный
файл
прямого доступа, открытый с параметром
REC=1,
например,
очень
похож
на
потоковый
файл
в
библиотеке
Cи.
Пользователь может "переместиться"
в
позицию в файле и прочитать произвольную
последовательность
значений. Неполные
записи
не
вызывают
появления
неопределенных
значений,
т.к. размер
записи равен 1
3.4
Позиционирование файла
При открытии последовательного файла он устанавливается в свое
начало
(если,
однако,
файл
не
был
открыт
с
параметром
ACCESS='APPEND').
Если следующей операцией ввода/вывода является
операция записи, то все "старые" данные в файле "отбрасываются". Файл,
после последовательных операторов WRITE, устанавливается в позицию
записи "конец файла" (но не за ней!).
При
исполнении
оператора
ENDFILE
маркер
конца
файла
устанавливается в текущую позицию, а затем файл позиционируется после
маркера "конец-файла". Оператор BACKSPACE должен исполняться для
позиционирования файла в позицию перед маркером "конец-файла". Любые
данные после этой позиции теряются.
При исполнении оператора READ в конце файла файл позиционируется
после записи "конец-файла"; при этом выдается сообщение об ошибке.
Попытка прочитать запись "конец файла" приводит к ошибке, если в
операторе READ не специфицирован параметр END=, ERR= или IOSTAT=.
3.5
Внутренние файлы
Большинство файлов на языке ФОРТРАН являются внешними, т.е. они
либо являются физическим устройством, либо представляют собой файл,
который "известен" операционной системе. Внутренним файлом является
символьная
переменная,
символьный элемент структуры, символьная
подстрока, элемент символьного массива,
символьный
массив
или
несимвольный массив.
Различаются два основных типа внутренних файлов:
Тип файла
--------------------------
Свойства
--------------------------------------
Символьная
переменная,
элемент
символьного
массива,
символьная
построка,
несимвольный
массив, символьный элемент
структуры
Файл
имеет
только
одну
запись,
которая
имеет
ту
же длину, что
и
переменная,
элемент
массива,
подстрока
или
несимвольный массив.
Несимвольный
массив
применяется
для
обеспечения
совместимости
с предыдущими версиями языка ФОРТРАН.
Символьный массив
Файл
является
последовательностью
элементов
символьного
массива,
каждый
из
которых
представляет
собой
запись.
Последовательность
записи совпадает с последовательностью
элементов массива.
Все записи одинаковой
длины:
они
имеют длину равную длине элементов
массива.
При использовании
внутренних
файлов
необходимо
следовать
следующим правилам:
1.
Использовать
только
форматированный,
последовательный
ввод/вывод;
2. Для передачи (данных) во внутренний файл следует использовать
только операторы READ и WRITE;
3. Не использовать форматирование, управляемое списком.
Перед
исполнением
оператора
ввода/вывода внутренние файлы
позиционируются в начало файла. Для внутренних файлов пользователь
может использовать системные свойства форматирования ввода/вывода; эти
свойства
используются
для преобразования внешнего представления
символов во внутреннее представление, характерное для языка ФОРТРАН,
т.е.
при чтении из внутреннего файла происходит преобразование
символьных (ASCII) значений в числовые, логические или символьные
значения; при записи во внутренний файл происходит преобразование
значений в их (внешнее) символьное (ASCII) представление.
Если во внутренний файл записывается неполная запись, то ее
"остаток" заполняется пробелами.
ПРИМЕЧАНИЕ
Оператор DECODE языка ФОРТРАН 66 заменен внутренней функцией
READ. Оператор ENCODE заменен внутренней функцией WRITE.
ПРИМЕР
C В данном примере выдается подсказка на ввод 3-х цифрового
C идентификатора файла и используется внутренний файл для
C создания имени файла
CHARACTER fname*64
fname = 'FILE
.DAT'
WRITE (*, *) 'Ввести 1-3 цифры идентификатора файла'
READ (*, *) id
WRITE (fname(5:7), 13.3)') id
OPEN (1, FILE = fname, STATUS = 'NEW')
.
.
.
END
3.6
Управление кареткой
При передаче записи на терминальное устройство, например на экран
или принтер, используя форматный ввод/вывод, первый символ этой записи
интерпретируется как символ управления кареткой и при этом
не
печатается. Действия, выполняемые при указании символов 0, 1, + и
символа пробела в качестве первого символа записи, перечислены в
табл.3.5. Любой другой символ обрабатывается как символ пробела. Если
первый символ записи не печатается, то следует убедиться в том, что он
не интерпретируется как символ управления кареткой. В следующем
программном фрагменте, например, число 2 интерпретируется как символ
управления кареткой и обрабатывается как символ пробела:
WRITE (*, 100)
100 FORMAT ('25 years')
При выполнении этого программного фрагмента получается
результат:
следующий
5 years
В случае ввода/вывода управляемого списком первый символ не
обрабатывается как символ управления кареткой. В следующем примере
неформатного ввода/вывода отображается полная строка:
WRITE
(*, *) '25 years'
При выполнении этого программного фрагмента получается
результат:
следующий
25 years
Результаты, получаемые при использовании
символа пробела показаны в табл.3.5.
символов
0,
1, + и
Таблица 3.5
Символы управления кареткой
-----------------------------------------------------------: Символ
:
Действие
:
:---------------+------------------------------------------:
: Пробел
: Передвижение вперед на одну строку
:
:
0
: Передвижение вперед на две строки
:
:
1
: Передвижение в начало следующей страницы :
:
+
: Передвижения не происходит
:
-----------------------------------------------------------ПРИМЕЧАНИЕ
Когда на экран в качестве символа управление кареткой передается
1, то программа генерирует ASCII-код прогона бумаги, возврата на одну
позицию, пробел и перевод каретки. Это происходит потому, что в
противном случае символ прогона бумаги будет отображаться на экране
как графический символ; действие этого символа будет игнорироваться.
Следует отметить, что первый символ при вводе/выводе, управляемом
списком, не будет обрабатываться как символ управления кареткой.
При записи терминальных файлов, маркер "конец записи" в общем
случае не генерируется до тех пор, пока не будет записана следующая
запись. Однако, если операция записи на экран чередуется с операцией
чтения с клавиатуры, то символ новой строки генерируется автоматически
и строка входных данных позиционируется сразу под строкой выходных
данных.
Для подавления символа новой строки и отображения входных данных
в той же строке, где отображались предыдущие выходные данные, следует
использовать символ обратного слэша в качестве разделителя описателей
полей в операторе WRITE. Входные данные будут появляться в конце
последней записанной строки.
Поскольку
входные
строки
всегда
заканчиваются символом новой строки, то следующая операция записи
всегда начинает выполняться с новой строки. Поэтому, если последующей
операцией
является
операция
записи,
то
управление
кареткой
настраивается таким образом, что при выполнении указанной операции
записывается на один маркер конца записи меньше.
Следует отметить, что если предыдущей операцией была операция
чтения, то символ управления кареткой (+) не оказывает никакого
действия.
3.7
Форматированный ввод/вывод
Если операторы READ или WRITE содержат спецификаторы формата, то
оператор ввода/вывода является оператором форматного ввода/вывода. В
заключении данного подраздела рассматриваются элементы спецификаторов
формата, а также взаимосвязь между спецификаторами формата и списком
ввода/вывода. (См. также подразд.3.2.7).
3.7.1
Неповторяющиеся дескрипторы преобразования
Неповторяющиеся
дескрипторы
преобразования
перечислены
в
табл.3.6.
Каждый из перечисленных дескрипторов рассмотрен в последующих
подразделах.
Таблица 3.6
Неповторяющиеся дескрипторы преобразования
---------------------------------------------------------------:Формат:
Имя
: Использование :
Использование
:
:
:
:
:----------------------:
:
:
:
:для ввода :для вывода :
:------+----------------+---------------+----------+-----------:
:string:Преобразование :Передача строки:
Нет
:
Да
:
:
:апострофа
:string на уст- :
:
:
:
:
:ройство вывода :
:
:
:nH
:Преобразование :Передача следу-:
Нет
:
Да
:
:
:Холлерита (вывод:ющих n симво- :
:
:
:
:текстовых дан- :волов на уст- :
:
:
:
:ных)
:ройство вывода :
:
:
:TRc, :Преобразование :Спецификация
:
Да
:
Да
:
:Tc;TLc:позиционирования:позиции в запи-:
:
:
:
:
:си
:
:
:
:nX
:Преобразование :Спецификация
:
Да
:
Да
:
:
:позиционирования:позиции в запи-:
:
:
:
:
:си
:
:
:
:SP,SS,:Преобразование :Управление вы- :
Нет
:
Да
:
:S
:(необязательное):водом знаков
:
:
:
:
:знака "плюс"
:"плюс"
:
:
:
: /
:Редактирование :Установка в
:
Да
:
Да
:
:
:слэша
:следующую за- :
:
:
:
:
:пись или запись:
:
:
:
:
:маркера "конец :
:
:
:
:
:записи"
:
:
:
: \
:Преобразование :Продолжение за-:
Нет
:
Да (при :
:
:обратного
:писи
:
:выводе на :
:
:слэша
:
:
:терминал
:
:
:
:
:
:или прин- :
:
:
:
:
:тер)
:
: :
:Прерывание про- :Если в списке :
Нет
:
Да
:
:
:цедуры управле- :ввода/вывода
:
:
:
:
:ния форматом
:iolist больше :
:
:
:
:
:нет элементов, :
:
:
:
:
:то выполнение :
:
:
:
:
:оператора прек-:
:
:
:
:
:ращается
:
:
:
:kP
:Преобразование :Установка масш-:
Да
:
Нет
:
:
:коэффициента
:таба для экспо-:
:
:
:
:масштабирования :нент (показате-:
:
:
:
:
:лей степени) в :
:
:
:
:
:последователь- :
:
:
:
:
:ных (повторяю- :
:
:
:
:
:щихся) дескрип-:
:
:
:
:
:торах преобра- :
:
:
:
:
:зования F и E :
:
:
:BN,BZ :Интерпретация
:Задается интер-:
Да
:
Нет
:
:
:пробелов
:претация пробе-:
:
:
:
:
:лов в цифровых :
:
:
:
:
:полях
:
:
:
---------------------------------------------------------------Подробно каждый неповторяющийся дескриптор описан
3.7.1.1 - 3.7.1.10.
3.7.1.1
в
подразделах
Преобразование апострофа
Если
спецификатор
формата
содержит
символьную константу,
<string>, то она передается на устройство вывода. Встроенные в
символьную константу пробелы являются значащими.
Для
представления в символьной константе символа апострофа
необходимо использовать двойной апостроф.
Каждый
дополнительный
уровень встраивания апострофов требует двойного их указания для
каждого уровня встраивания. Следует отметить, как во втором операторе
WRITE в приведенном ниже примере установлены апострофы, которые
ограничивают выводную строку, внутри оператора FORMAT, и четыре
апострофа,
требуемые
внутри
собственно
выводной
строки
для
спецификации единственного выводимого апострофа.
Преобразование апострофа не
может
быть
использовано
при
применении операторов READ.
C Оба
оператора
записи
выводят
строку
ABC'DEF
C (Ведущий пробел является символом управления кареткой)
WRITE (*, 970)
970
FORMAT (' ABC''DEF' )
WRITE (*, '('' ABC''''DEF'')')
C Следующий оператор записи также выводит строку ABC'DEF.
C Для ввода/вывода, управляемого списком, символ управления
C кареткой использовать не надо.
WRITE (*, *) 'ABC''DEF'
3.7.1.2
Дескриптор преобразования Холлерита (H)
Дескриптор преобразования nH "передает" следующие n символов
(пробелы рассматриваются как значащие) на устройство вывода. Данный
дескриптор может использоваться в любом контексте, где встречаются
константы Холлерита (текстовые константы).
C Данные операторы записи выводят строку ABC'DEF
C (Ведущий пробел является символом управления кареткой)
WRITE (*, '(8H ABC''DEF)')
WRITE (*, 960)
960
FORMAT(8H ABC'DEF)
3.7.1.3
Дескрипторы преобразования: Tab, Tab Left, Tab Right
( T, TL, TR )
Дескрипторы преобразования T, TL и TR указывают позицию в записи,
в которую (или из которой) перемещается указатель текущей позиции.
Новая позиция может находиться в любом направлении от текущей позиции.
Этим обеспечивается возможность многократной обработки записи при
вводе. Следует отметить, что перемещение в позицию назад более чем на
512 байтов (символов) не рекомендуется.
Дескриптор преобразования Tc указывает, что указатель текущей
позиции перемещаться на "c" позиций; дескриптор TRc указывает, что
указатель текущей позиции перемещается на "c" позиций вправо от
текущей позиции; дескриптор TLc указывает, что указатель текущей
позиции перемещается на "c" позиций влево от текущей позиции.
Если дескриптор TLc указывает позицию перед первой позицией
записи, то при этом происходит перемещение в (или из) первую позицию
текущей записи (или из первой позиции текущей записи).
Левая табуляция является корректной внутри записей, записываемых
на устройство. Однако, если записываемая запись длиннее, чем буфер,
связанный с устройством, пользователь не сможет сдвинуться влево в
позицию, соответствующую предыдущему буферу.
Например, буфер, связанный с консолью, имеет длину 132 байта.
Если 140-байтная запись записывается на консоль, то левая табуляция
разрешена только для восьми байтов, поскольку 132 байта записи были
переданы на устройство и перестали быть доступными.
Если перечисленные дескрипторы используются для перемещения в
новую
позицию, которая находится справа за последним элементом
передаваемых данных, и записывается следующий элемент записи, то
промежуток между концом данных в записи и новой позицией заполняется
пробелами; рассмотрим, например, следующую программу:
100
WRITE (*, '('' '', 3(''1234567890''))')
WRITE (*, 100) 5, 9
FORMAT (15, 20X, TL10, I5)
Выходными результатами этой программы будут следующие данные (где
символ x представляет пробел):
123456789012345678901234567890
xxxx5xxxxxxxxxxxxxx9
Особенно
осторожным
следует
быть
при использовании этих
дескрипторов, если выполняется операция чтения из файлов, в которых в
качестве разделителей полей используются запятые. Если выполняется
возврат в запись при помощи дескриптора TLc или дескриптора T, где
значение
"c"
меньше номера текущей позиции в записи, запятые
"перестают рассматриваться" как разделители полей. Если контроллер
формата в такой ситуации "встретит" запятую, то будет сгенерирована
ошибка этапа исполнения. Если необходимо вернуться в запись
и
сохранить при этом запятые как разделители полей, необходимо перейти к
символу "конец записи", а затем, для перехода в начало записи,
применить оператор BACKSPACE.
3.7.1.4
Дескриптор преобразования X
Дескриптор преобразования nX указывает, что поле из n символов
должно быть пропущено при считывании или заполнено пробелами при
записи. При выводе, если дескриптор nX "перемещается" в конец данных в
записи и если в списке <iolist> еще имеются элементы, то на вывод
будут передаваться пробелы, как это описано для дескрипторов Tc и TRc.
ПРИМЕР
C B примере на экран записывается последовательность
C 1 5 10 15
WRITE (x, 100)
100 FORMAT (1X, '1', 3X, '5', 3X, '10', 3X, '15')
C Следующий оператор выводит на экран строку
C "zogoZOGozogo !"
WRITE(*, 200)
200 FORMAT( 1X, 'zogozogozogo', TL8, 'ZOG', 10X, '!')
3.7.1.5
Дескрипторы преобразования SP, SS, S
(управление выводом знака)
Дескрипторы преобразования SP, SS и S могут использоваться для
управления знаками (необязательными!) "плюс" в полях цифровых выходных
данных. Дескриптор SP указывает на вывод знака "плюс" во всех
позициях, где это возможно. Действие дескриптора SS является обратным
действию дескриптора SP: он запрещает указание знаков "плюс" во всех
позициях,
которые
процессором
распознаются
как
"поля
для
необязательных знаков "плюс"". Дескриптор S "восстанавливает" действие
дескриптора SS (принимается по умолчанию).
ПРИМЕР
C Следующие операторы выполняют операцию записи последовательности:
C 251 +251 251 -251 251
INTEGER i
i = 251
WRITE (*, 100) i, i, i, i, i
100
FORMAT (1X, 15, SP, 15, SS, 15, SP, 15, S, 15)
C Следующие операторы выполняют запись последовательности:
C .673E+4.673E+4 .673E+4.673E+4 .673E+4
REAL r
100
r = 67.3E2
WRITE (*, 100) r, r, r, r, r
FORMAT(1X,E8.3E1,SP,E8.3E1,SS,E8.3E1,SP,E8.3E1,S,E8.3E1)
3.7.1.6
Прямой слэш (/)
Слэш указывает об окончании передачи данных в текущую строку. При
вводе файл позиционируется в начало следующей записи. При выводе
записывается маркер "конец записи" и файл позиционируется для записи с
начала следующей строки.
ПРИМЕР
C Следующие операторы записывают столбец и строку
WRITE (*, 100)
100
FORMAT ('c row', /, ' o', /, ' l', /, ' u', /, ' m', /, ' n')
Выходным результатом данного примера является следующее:
C ROW
O
L
U
M
N
3.7.1.7
Обратный слэш (\)
Дескриптор (разделитель описателей полей) в виде обратного слэша
используется
исключительно
для
форматирования выходных данных,
выводимых на терминальные устройства (например, на экран или принтер).
Во всех других ситуациях он игнорируется.
В общем случае, когда контроллер форматирования завершает работу,
записывается признак "конец записи". Если последним дескриптором,
который встречается контроллеру, является символ обратного слэша, то
признак "конец строки" не записывается; таким образом, последующие
операторы ввода/вывода могут продолжать выполнять операции записи в ту
же строку.
Данный механизм может быть использован для записи подсказки на
экран и затем считывания в ту же строку экрана отклика на подсказку,
например:
WRITE (*,'(A \)') 'enter an integer -->'
READ (*, 'BN, I6)') j
3.7.1.8
Прерывание процедуры управления форматом (:)
Дескриптор
преобразования
в
виде двоеточия (:) прерывает
выполнение процедуры управления форматом, если в списке ввода/вывода
<iolist> не осталось больше данных. Данное свойство может быть
использовано для запрещения вывода, когда некоторые из символов в
формате не имеют соотвествующих данных в списке ввода/вывода <iolist>.
C В следующем примере записывается:
C a= 3.20 b= .99
REAL a, b, c, d
DATA a /3.2/, b /.9871515/
WRITE (*, 100) a, b
100 FORMAT (' a=', F5.2, :, ' b=', F5.2, :,
+
' c=', F5.2, :, ' d=', F5.2)
END
3.7.1.9
Преобразование коэффициента масштабирования (P)
Дескриптор
преобразования
kP
устанавливает
коэффициент
масштабирования (масштабный множитель) для последующих дескрипторов F
и E (см. подразд.3.7.2); он действует до тех пор, пока не будет
установлен следующий дескриптор kP. В начале каждого
оператора
ввода/вывода, коэффициент масштабирования устанавливается в исходное
значение 0. Коэффициент масштабирования воздействует на преобразование
формата следующим образом:
- при вводе данных, при использовании дескрипторов F и E (если в
поле явно не указан показатель степени) и при выводе данных, при
использовании дескриптора
F,
числа
во
внешнем
представлении
соответствуют числам, представленным во внутреннем представлении,
умноженным на 10**k ("10 в степени k");
- при вводе данных, при использовании дескрипторов F и E,
коэффициент масштабирования не оказывает никакого воздействия, если в
поле входных данных не указан (явно) показатель степени;
- при выводе
данных,
при
использовании
дескриптора
E,
вещественная часть параметра является выходным значением, умноженным
на 10**k ("10 в степени k"), и показатель степени уменьшается на k
(при этом изменяется позиция, в которой указывается десятичная точка;
выходное значение не изменяется).
ПРИМЕРЫ
В
следующем
примере
во время выполнения
используется коэффициент масштабирования:
100
READ (*, 100) a, b, c, d
FORMAT (F10.6, 1P, F10.6, F10.6, -2P, F10.6)
200
WRITE (*, 200) a, b, c, d
FORMAT (4F11.3)
операции
чтения
Предположим, что введены следующие данные:
12340000
12.34
12.34e0
12.34e3
12340000
12.34
12.34e0
12.34e3
12340000
12.34
12.34e0
12.34e3
12340000
12.34
12.34e0
12.34e3
Выходными результатами программы являются следующие:
12.340
12.340
12.340
12340.000
1.234
1.234
1.234
1.234
1.340
12.340
12340.000 12340.000
1234.000
1234.000
12.340
12340.000
Следующий
программный
фрагмент
использует
масштабирования при выполнении операции записи:
a = 12.34
WRITE (*, 100) a, a, a, a, a, a
коэффициент
100
FORMAT (1X, F9.4, E11.4E2, 1P, F9.4, E11.4E2, -2P, F9.4,
+
E11.4E2)
Данная программа имеет следующие выходные результаты:
12.3400
.1234E+02
123.40000
3.7.1.10
1.2340E+01
.1234.
.00123E+04
Дескрипторы преобразования BN,BZ
(управление вводом пробелов)
Дескрипторы преобразования BN и BZ используются для спецификации
способа интерпретации пробелов в цифровых полях входных данных.
Дескриптор BZ указывает, что все пробелы (но только не ведущие!)
интерпретируются
как
нули.
Следует
отметить,
что при вводе
вещественных чисел, пробелы, которые следуют за дескрипторами E или D,
игнорируются.
Дескриптор BN указывает, что все пробелы в числовых полях ввода
следует игнорировать, а остальные символы - выровнить справа. Поле,
состоящее из одних пробелов, соответствует нулевому значению.
По умолчанию дескриптор BN устанавливается в начало каждого
оператора ввода/вывода, если однако в операторе OPEN не специфицирован
параметр
BLANK=.
При
спецификации дескриптора BZ он остается
действителен до тех пор, пока не будет специфицирован дескриптор BN.
Рассмотрим, например, следующий програмный фрагмент:
READ (*, 100) n
100 FORMAT (BN, 16)
Если пользователь вводит любую из следующих трех
записей,
заканчивающихся
нажатием
клавиши
ENTER,
оператор
READ будет
интерпретировать эту запись как значение 123:
123
123
123
456
Поскольку повторяющийся дескриптор преобразования
связан
с
элементом n списка ввода/вывода, и максимальное n есть 16, то
считываться будут только первые 6 символов в командной записи (три
пробела перед 123 в первой записи; 123, за которым следуют три пробела
для второй и третьей записей). Тогда, поскольку пробелы игнорируются,
все три записи интерпретируются как 123.
Следующий пример показывает результат применения дескриптора BN
при вводе записи, которая имеет меньше символов, чем число символов,
специфицированное дескрипторами преобразования и в списке ввода/вывода
<iolist>. Предположим, что вводится число 502, за которым следует
команда ввода (нажать клавишу ENTER), в ответ на следующий
оператор
READ:
READ (*, '(I5)') n
Прежде всего, запись числа 502 дополняется справа пробелами до
требуемой длины, равной 5. Если
дескриптор
BZ
"действителен"
(напомним, что он принимается по умолчанию), то эти "добавленные" два
пробела будут интерпретироваться как нули и запись будет равной 50200.
Однако, если "действителен" дескриптор BN, то символы, не являющиеся
пробелами (значащие символы - 502), выравниваются справа и запись
становится равной 502.
3.7.2
Повторяющиеся дескрипторы преобразования
Для операций ввода/вывода числовых данных используются следующие
дескрипторы
преобразования: I (целый), Z (шестнадцатеричный), F
(вещественный одинарной точности), E (вещественный экспоненциальный),
G (вещественный с необязательной степенью), D (вещественный с двойной
точностью). К числовым
дескрипторам
преобразования
применяются
следующие правила:
при
вводе,
ведущие
пробелы
не
являются
значащими
(интерпретируются как нули). Другие пробелы
интерпретируются
в
зависимости
от
того,
"действительны"
или
"не действительны"
дескрипторы BN или BZ; однако поля, полностью состоящие из пробелов,
всегда принимают значение 0. Знаки "плюс" не являются обязательными.
Пробелы, добавляемые файловой системой в запись для "заполнения" до
требуемого размера, также не являются значащими;
- при вводе с использованием дескрипторов F, E, G и D явно
указываемая
в
поле
входных
данных десятичная точка изменяет
спецификацию дескриптора на значение
(явно
указанной)
позиции
десятичной точки;
- при выводе, генерируемые символы в поле выравниваются справа и
добавляются ведущими пробелами, при необходимости;
- при вводе, если число выводимых символов превышает ширину поля
или показатель степени превышает указанную величину,
все
поле
заполняется звездочками. Если вещественное число содержит больше цифр
после тесятичной точки, чем допустимо в поле, то число округляется;
- при выполнении операции чтения с использованием дескрипторов I,
Z, F, E, G, D или L, поле выходных данных может содержать, в качестве
символа конца поля, запятую. Чтение следующей записи будет начинаться
с символа, следующего за запятой. Например, рассмотрим следующий
оператор READ:
READ (*, '(BZ 3I5)') i, j, k
При вводе следующих данных: 1, 2, 3, получаются следующие
результаты: i = 1, j = 20 и k = 3. (Данную возможность применять не
следует, если предполагается использовать дескрипторы T, TL, TR или
nX);
- два последовательно интерпретируемых дескриптора типа F, E, G и
D используются для указания
преобразования
комплексных
чисел.
Дескрипторы могут использоваться в комбинации. Первый дескриптор
специфицирует действительную
часть
комплексного
числа;
второй
специфицирует мнимую часть;
- неповторяющие дескрипторы преобразования могут указываться
между повторяющимися дескрипторами преобразования. В
последующих
подразделах рассматриваются повторяющиеся дескрипторы редактирования.
В последующих подразделах подробно описаны каждый повторяющийся
дескриптор редактирования.
3.7.2.1
Дескриптор преобразования I
(преобразование целых данных)
СИНТАКСИС
Iw[.m]
При вводе любое вводимое значение, ассоциированное с дескриптором
I, должно иметь формат целого (оно не должно содержать десятичной
точки или показателя степени); в противном случае возникает ошибка
этапа исполнения. При выводе элемент списка элементов ввода/вывода,
ассоциированный с дескриптором I, должен иметь целочисленное значение,
иначе генерируется ошибка этапа исполнения.
Ширина поля составляет w символов. При вводе данных в поле может
указываться (необязательный) знак. Если специфицировано целое число m
с необязательным знаком, то в этом случае ввод совпадает с вводом,
выполняемым при использовании дескриптора Iw; однако выходные данные
дополняются ведущими нулями до заданной ширины поля, равной m.
Рассмотрим оператор:
WRITE (*, '(1X, I5, I5.3)') 7, 7
При его выполнении на экран будет выведено следующее:
7
007
3.7.2.2 Дескриптор преобразования Z
(преобразование шестнадцатеричных данных)
СИНТАКСИС
Z[w]
Дескриптор
Z
используется
для
преобразования
чисел
в
шестнадцатеричном формате. Во время преобразования внутренние данные
обрабатываются по 4 бита (разряда). Внешние поля образуются из
шестнадцатеричных символов (0-9
и
A-F).
Каждый
байт
данных
соответствует
двум
четырехбитовым
шестнадцатеричным
символам
(например, ASCII символ 'm', представляемый в двоичном виде как
01101101, соответствует шестнадцатеричным символам 6D).
Необязательный указатель ширины поля, w, указывает число читаемых
или записываемых шестандцатеричный символов. Если указатель w опущен,
то ширина поля принимается по умолчанию равной 2*n, где n есть длина
элемента
списка
<iolist>
в
байтах.
Например, тип INTEGER*2
представляется четырьмя шестнадцатеричными символами.
При выводе символьные типы данных записываются в
той
же
последовательности, в которой они указаны в памяти. Для числового и
логического типов, байты выводятся в порядке значимости, т.е. начиная
с наиболее значимого слева до наименее значимого справа. Например,
число 10
типа
INTEGER*2
будет
выводиться
как
000А,
хотя
последовательность байтов памяти для сопроцессора 8086 фактически
будет следующей: 0A00.
В
данном
случае применяются следующие правила усечения и
дополнения; значение n есть длина элемента списка <iolist> в байтах:
Операция
------------Вывод
Ввод
Правило
----------------------------------------------Если w > 2*n, то 2*n шестнадцатеричных символов
выравниваются справа и добавляются
ведущие
нули
для
того,
чтобы
ширина
внешнего
поля равнялась значению w. Если w <= 2*n, то
выводятся
w
наименьших
("самых
правых")
шестандцатеричных символов.
Если w >= 2*n, то из входнного поля берутся
2*n "самых правых" шестнадцатеричных символа.
Если
w
>
2*n,
то
w шестнадцатеричных
символов внешнего поля обрабатываются таким
образом, как если бы было достаточно ведущих
нулей
для
того,
чтобы
сделать
ширину
внешнего поля равной 2*n.
Пробелы в полях входных данных обрабатываются как нули.
Преобразование
шестнадцатеричных
чисел
отличается
от
последовательного преобразования десятичных чисел двумя существенными
аспектами. Если число шестнадцатеричных символов при выводе превышает
ширину поля, то
поле
не
заполняется
звездочками.
Напротив,
отображаются w "самых правых" символов.
При добавлении слева "коротких" вводимых полей разряд знака
вводимого значения не принимается во внимание. Например, в 8-и
символьном вводном поле, в котором вводится только FFFF символов, ввод
будет интерпретироваться как 65.535, а не как -1.
Для преобразования комплексных чисел следует использовать два
дескриптора Z: первый
дескриптор
указывает
на
преобразование
действительной части комплексного числа; второй - на преобразование
мнимой части.
ПРИМЕРЫ
В следующем примере демонстрируется возможность преобразования
шестнадцатеричных даных при выполнении операции вывода:
CHARACTER*2 alpha
INTEGER*2 num
alpha = 'YZ'
num = 4096
WRITE (*, '(1X, Z, 1X, Z2, 1X, Z6)') alpha, alpha, alpha
WRITE (*, '(1X, Z, 1X, Z2, 1X, Z6)') num, num, num
При этом на экран будет выведено следующее:
595A
1000
5A
С0
0С595A
001000
Пример операции ввода: предположим, что вводится запись 595А
(шестнадцатеричные символы) и элементы списка <iolist> имеют тип
CHARACTER*2. Запись будет считана следующим образом:
Дескриптор
---------Z
Z2
Z6
Считываемое значение
-------------------YZ
0Y
YZ
3.7.2.3 Дескриптор преобразования F
(преобразование вещественных данных)
СИНТАКСИС
Fw.d
При
выводе
элемент списка ввода/вывода, ассоциированный с
дескриптором F, должен иметь формат числа одинарной или двойной
точности, иначе возникнет ошибка этапа исполнения. При вводе вводимое
число может иметь любой целочисленный или вещественный формат.
Ширина поля составляет w символов; ширина дробной части - d
разрядов (цифр). Поле входных данных начиается с (необязательного)
знака, за которым следует строка цифр, которая может содержать
(необязательную) десятичную точку. Если десятичная точка указана, она
"замещает" спецификацию параметра d в дескрипторе преобразования; в
противном
случае младшие d цифр в строке интерпретируются как
указываемые
после
десятичной
точки
(ведущие
пробелы,
при
необходимости, замещаются нулями). Далее следует (необязательный)
показатель степени, который может быть:
- либо + (плюс) или - (минус), за которым следует целое число;
- либо
E,
за которой следует
ноль
или более пробелов,
необязательный знак и целое число.
В качестве примера может быть приведен следующий оператор READ:
READ (*, '(F8.3)') xnum
Приведенный выше оператор
образом:
Ввод
---5
24680
-24680
-246801
56789
-28E2
считывает
заданную
запись
следующим
Считываемое число
----------------.005
2.468
-24.680
-246.801
5.6789
-2.800
Выходное поле занимает w символов. Один символ есть десятичная
точка, так что для цифр остается w-1 позиция. Если знак отрицательный,
он должен обязательно указываться, т.е. в этом случае для цифр
остается w-2 позиций. Из этих w-1 или w-2 позиций, d позиций
используется для цифр справа от десятичной точки. Оставшиеся позиции
могут быть либо пробелами, либо цифрами, представляющими цифры слева
от десятичной точки.
Выходное значение "контролируется" и элементом списка <iolist> и
текущим коэффициентом масштабирования. Выходное значение округляется,
но не усекается.
ПРИМЕР
Рассмотрим следующую программу:
REAL*4 g, h, e, r, k, i, n
DATA
g /12345.678/, h /12345678./, e /-4.56E+1/, r/-365./
WRITE (*, 100) g, h, e, r
10 FORMAT (1X, F8.2)
WRITE (*, 200) g, h, e, r
200 FORMAT (1X, 4F10.1)
При выполнении программы на экране будут напечатаны
строк:
12345.68
********
-45.60
-365.00
следующие
5
12345.712345680.0
-45.6
-365.0
3.7.2.4 Дескриптор преобразования Е
(преобразование вещественных данных)
СИНТАКСИС
Ew.d[Ee]
При
выводе
элемент списка ввода/вывода, ассоциированный с
дескриптором Е, должен иметь формат числа одинарной или двойной
точности, иначе возникнет ошибка этапа исполнения. При вводе вводимое
число может иметь любой целочисленный или вещественный формат.
Ширина поля составляет w символов. Величина "e" на входные данные
"воздействия
не
оказывает".
Входное
поле
для дескриптора E
тождественно входному полю, описываемому дескриптором F, с теми же
значениями w и d.
Формат выходного поля зависит от коэффициента масштабирования
(устанавливаемого дескриптором преобразования P). Для коэффициента
масштабирования равного 0, выходное поле указывается со знаком минус
(если это необходимо), за которым следует десятичная точка, за которой
следует строка цифр, за которой следует поле показателя степени exp,
имеющего один из форматов, приведенных в табл.3.7.
Таблица 3.7
Форматы показателя степени: дескриптор преобразования E
--------------------------------------------------------------:Дескриптор: Абсолютное
: Формат показателя степени :
:
: значение показателя:
:
:----------+--------------------+-----------------------------:
:Ew.d
: │exp│<==99
:E, за которой следует знак :
:
:
:"плюс"
или
"минус",
за :
:
:
:которым следует показатель :
:
:
:степени (2 цифры)
:
:Ew.d
: 99<│exp│<==999
:Знак "плюс" или "минус", за :
:
:
:которым следуют три знака :
:
:
:показателя степени
:
:Ew.dEe
: │exp│<=(10e)-1
:Е, за которой следует знак :
:
:
:"плюс"
или
"минус",
за :
:
:
:которым следует "e" цифр, :
:
:
:которые являются показателем :
:
:
:степени
с
(возможно!) :
:
:
:ведущими нулями.
:
--------------------------------------------------------------Формат Ew.d не должен использоваться, если абсолютное значение
показателя степени (которое будет печататься) превышает 999.
Десятичной нормализацией (т.е. приведением числа к десятичному
представлению)
"управляет"
коэффициент
масштабирования.
Если
коэффициент масштабирования, k, больше чем -d и меньше или равен 0,
тогда выходное поле будет содержать ровно k ведущих нулей после
десятичной точки и d+k значащих цифр после них. Если (0<k<d+2), тогда
выходное поле содержит ровно k значащих цифр слева от десятичной точки
и (d-k-1) позиций после десятичной точки. Другие значения k будут
ошибочными.
3.7.2.5
Дескриптор
преобразования
G
(преобразование вещественных данных)
СИНТАКСИС
Gw.d[Ee]
При выводе элемент списка ввода/вывода,
ассоциированный
с
дескриптором G, должен иметь формат числа одинарной или двойной
точности, иначе возникнет ошибка этапа исполнения. При вводе вводимое
число может иметь любой целочисленный или вещественный формат.
Для любого формата ширина входного поля составляет w символов;
дробная часть составляет d позиций. Если коэффициент масштабирования
больше 1, то экспоненциальная часть составляет e позиций.
Преобразование входных данных с использованием дескриптора G
совпадает с преобразованием, выполняемым с использованием дескриптора
F. Преобразование выходных данных с использованием дескриптора G
соответствует преобразованию с использованием дескрипторов E либо F, в
зависимости от величины данных. В таблицах 3.8 и 3.9 показано, каким
образом интерпритируется дескриптор преобразования G.
Таблица 3.8
Интерпретация дескриптора преобразования G
------------------------------------------------------------------: Значение данных
:
Интерпретация
:
:------------------------------+----------------------------------:
:m<0.1
: Gw.d=Ew.d
:
:0.1<=m<1
: Gw.d=F(w-4).d,4('')
:
:1<=m<10
: Gw.d=F(w-4).(d-1),4('')
:
:т.е 10**(d-d)<=m<10**(d-(d-1)):
:
:10**(d-2)<=m<10**(d-1)
: Gw.d=F(w-4).1,4('')
:
:10**(d-1)<=m<10**d
: Gw.d=F(w-4).0,4('')
:
:10**d<=m
: Gw.d=Ew.d
:
------------------------------------------------------------------Таблица 3.9
Интерпретация дескриптора преобразования GE
--------------------------------------------------------------: Значение данных
:
Интерпретация
:
:--------------------------+----------------------------------:
:m<0.1
: Gw.dEe=Ew.d
:
:0.1<=m<1
: Gw.dEe=F(w-e-2).d,(e+2)('')
:
:1<=m<10
: Gw.dEe=F(w-e-2).(d-1),(e+2)('') :
:10**(d-d)<=m<10**(d-(d-1)):
:
:10**(d-2)<=m<10**(d-1)
: Gw.dEe=F(w-e-2).1(e+2)('')
:
:10**(d-1)<=m<10**d
: Gw.dEe=F(w-e-2).0,(e+2)('')
:
:10**d<=m
: Gw.dEe=Ew.d
:
--------------------------------------------------------------3.7.2.6 Дескриптор преобразования D
(преобразование вещественных данных)
СИНТАКСИС
Dw.d
При
выводе
элемент
списка
ввода/вывода,
ассоциированный
с
дескриптором D, должен иметь формат числа одинарной или двойной
точности, иначе возникнет ошибка этапа исполнения. При вводе вводимое
число может иметь любой целочисленный или вещественный формат. Все
параметры и правила, действительные для дескриптора Е, действительны и
для дескриптора D.
Ширина поля составляет w символов. Поле входных данных для
дескриптора D совпадает с описываемым в дескрипторе F, с аналогичными
значениями w и d.
Формат
поля
выходных
данных
зависит
от
коэффициента
масштабирования (устанавливаемого дескриптором P). Для коэффициента
масштабирования, равного 0, поле выходных данных имеет следующий
формат: знак минус (если он необходим), десятичная точка, строка цифр,
поле показателя степени exp в одном из форматов, представленных в
табл.3.10.
Таблица 3.10
Форматы показателя степени: дескриптор преобразования D
--------------------------------------------------------------:Дескриптор: Абсолютное значение : Формат показателя степени :
:
: показателя степени :
:
:----------+---------------------+----------------------------:
:Dw.d
: │exp│ <= 99
:D, знак "плюс" или "минус", :
:
:
:показатель степени (2 цифры):
:Dw.d
: 99 < │exp│ <= 999
:Знак "плюс" или "минус", по-:
:
:
:казатель степени (3 цифры) :
--------------------------------------------------------------Формат Dw.d не должен использоваться, если абсолютное значение
показателя степени превышает 999.
Децимальной нормализацией (т.е. представлением в десятичном виде)
печатаемого D поля "управляет" коффициент масштабирования.
Если
коэффициент масштабирования, k, больше -d и меньше или равен 0, тогда
выходное поле содержит равно k ведущих нулей после десятичной точки и
d+k значащих цифр после них. Если (0<k<d+2), тогда выходное поле
содержит ровно k значащих цифр слева от десятичной точки и (d-k-1)
позиций после десятичной точки. Все другие значения k рассматриваются
как ошибочные.
3.7.2.7 Дескриптор преобразования L
(преобразование логических данных)
СИНТАКСИС
Lw
Ширина поля составляет w символов. При выводе элемент списка
<iolist>,
ассоциированный
с
дискриптором L, должен быть типа
логический, иначе будет генерироваться ошибка этапа исполнения. При
вводе данных поле состоит из необязательных пробелов, за которыми
следуют: необязательная десятичная точка, затем литеры T (для значения
"истина") или F (для значения "ложь"). Все последующие символы в поле
игнорируются, но "берутся" при вводе данных, так что за w-1 пробелами
следует либо литера T, либо литера F.
3.7.2.8 Дескриптор преобразования A
(преобразование символьных данных)
СИНТАКСИС
A[w]
Если параметр w опущен (не указан), то значение параметра w равно
количеству символов элемента списка <iolist>, с которым ассоциирован
дескриптор. Элемент списка <iolist> может быть любого типа; если он не
является элементом типа CHARACTER, то он все равно рассматривается как
символьный и принимается, что одному байту элемента соответствует один
символ.
Если элемент списка <iolist> имеет тип INTEGER, REAL или LOGICAL,
то может быть использован тип данных Холлерита. При вводе элемент
списка <iolist> определяется как константа Холлерита; при выводе
элемент
списка
<iolist> должен быть определен с типом данных
Холлерита.
При вводе, если значение параметра w превышает или равно числу
символов в элементе списка <iolist>, то в качестве входных данных
используются "самые правые" символы входного поля; в противном случае
при вводе младшие значащие
символы
элемента
списка
<iolist>
отбрасываются и устанавливаются "хвостовые" пробелы.
Если число входных символов не равно w, тогда входное поле
заполняется пробелами или усекается справа до длины, равной значению
w; это выполняется до того, как будет передаваться элемент списка
<iolist>. Например, рассмотрим следующий программный фрагмент:
CHARACTER*10 char
READ (*, '(A15)') char
Предположим, что на клавиатуре набираются следующие 13 символов:
ABCDEFGHIJKLM
Будут выполняться следующие два шага:
Шаг1. Входное поле будет заполняться до 15 символов:
'ABCDEFGHIJKLM '
Шаг2. В позицию элемента списка <iolist> - char "самые правые" 10 символов:
'FGHIJKLM
будут
передаваться
'
При выводе, если значение параметра w превышает число символов,
обеспечиваемых элементом списка <iolist>, то будут указываться ведущие
пробелы; в противном случае будут выводиться w "самых левых" символов
элемента списка <iolist>.
3.7.3 Взаимодействие спецификации формата и списка ввода/вывода
Если список ввода/вывода <iolist> содержит по крайней мере один
элемент, то в спецификации формата должен присутствовать по крайней
мере один дескриптор преобразования. Если в списке <iolist> не указано
ни одного элемента, то может быть использована пустая спецификация,
().
При
выполнении
операции
записи
с
пустой спецификацией
преобразования форматный оператор WRITE записывает символ возврата
каретки и перехода к новой строке; двоичный оператор WRITE не
записывает никакой "дополнительной" информации. Оператор READ в этом
случае (т.е. с пустой спецификацией формата) выполняет переход к
следующей записи.
Если выполняется операция чтения записи, в которой общее число
символов
во
входной
записи
меньше
общего
числа
записей,
специфицированных дескрипторами преобразования и списком <iolist>, то
возможны следующие два варианта:
- запись будет добавлена пробелами справа до требуемой длины;
- любые вводимы пользователем пробелы будут интарпретироваться
"согласно действию", выполняемому при указании дескриптора BN или BZ.
Рассмотрим, например, следующий оператор
READ,
в
котором
используется дескриптор BZ:
READ (*, '(BZI5)') n
Предположим, что в качестве входных
оператора READ, введено следующее:
данных
для
соотвествующего
5
Общее число символов во входной записи равно двум (пробел и цифра
5). Запись
будет
добавлена
тремя
пробелами
справа,
однако
дополнительные пробелы будут игнорироваться. Таким образом, входная
запись интерпретируется как 5, а не 5000.
Каждый элемент в списке <iolist> ассоциирован с повторяющимся
дескриптором преобразования при выполнении оператора ввода/вывода.
Неповторяющиеся дескрипторы (при выполнении операций ввода/вывода) не
устанавливаются ассоциированными с элементами в списке <iolist>.
Во время выполнения операций форматного ввода/вывода, контроллер
формата просматривает и обрабатывает элементы формата слева направо.
Если контроллер формата встречает:
- повторяющийся дескриптор преобразования, а в списке <iolist>
указан соотвествующий элемент, тогда:
элемент и дескриптор преобразования "ассоциируются между собой"
и процедура ввода/вывода данного элемента выполняется согласно
спецификации формата, задаваемого в дескрипторе преобразования;
- повторяющийся дескриптор преобразования, а в списке <iolist>
соотвествующий ему элемент не указан, тогда:
контроллер формата прерывает выполнение операции ввода/вывода.
Например, для следующих операторов:
100
i = 5
WRITE (*, 100) i
FORMAT (1X, 'I= ', I5, ' J= ', I5, ' K= ', I5)
выходные данные будут следующие:
I=
5 J=
Выполнение операции вывода будет прервано после J=, поскольку
в списке <iolist> для второго дескриптора I5 элементов не
указано;
- завершающую правую круглую скобку в спецификации формата, а в
списке <iolist> элементов больше не указано, тогда:
контроллер формата прерывает выполнение операции ввода/вывода;
- дескриптор преобразования в виде двоеточия (:), а в списке
<iolist> элементов больше не указано, тогда:
контроллер формата прерывает выполнение операции ввода/вывода;
- дескриптор преобразования в виде двоеточия (:), а в списке
<iolist> еще имеются элементы, тогда:
дескриптор (:) игнорируется;
- завершающую правую скобку в спецификации формата, а в списке
<iolist> еще имеются элементы, тогда:
файл позиционируется в начало следующей записи и контроллер
формата
продолжает просмотр формата, начиная с того места
спецификации
формата,
где
она
была
прервана
последней
предшествующей правой круглой скобкой;
если
же
такой
предшествующей
правой
круглой скобки нет, контроллер формата повторно просматривает
формат, начиная с его начала. Внутри повторно просматриваемого
формата
должен
быть
по
крайней
мере
один
дескриптор
преобразования;
Если
повторный
просмотр
спецификации
формата
начинается повторяющейся встроенной спецификацией формата, то
фактор повторения указывает на число повторений данной встроенной
спецификации
формата. Повторный просмотр не изменяет ранее
сделанных установок коэффициента масштабирования и не отменяет
действия дескрипторов BN или BZ.
Когда контроллер формата прерывает выполнение операции ввода,
оставшиеся в записи символы пропускаются. Когда контроллер формата
прерывает
выполнение
операции
вывода,
записывается
признак
"конец-записи", если, однако, в "прерываемом" файле не был указан
разделитель описателей полей - дескриптор преобразования в виде
обратного слэша.
Для
устройств
(файлов),
присоединенных
к
терминальным
устройствам, признак "конец-строки" не записывается до тех пор, пока
следующая запись не начнет
записываться
на
устройство.
Если
устройством является экран, то для запрещения признака "конец-строки"
можно использовать разделитель описателей полей в виде обратного
слэша.
3.8
Ввод/вывод, управляемый списком
"Запись,
управляемая
списком"
представляет
собой
последовательность значений и разделителей значений. Каждое значение
должно быть одним из следующих:
- константой, необязательно умноженной на ненулевую целочисленную
константу без знака. Например: 5 или 2*5 (две последовательные
пятерки), являются допустимыми вариантами;
- пустым значением (null), необязательно умноженным на ненулевую
целочисленную константу
без
знака.
Например,
5*
есть
пять
последовательных пустых значений.
Ни одно из них, за исключением строковых констант, не может
содержать встроенных пробелов.
Разделители значений могут быть следующие:
- запятая (,);
- символ слэша (/).
Слэш, указанный как разделитель значений, во время выполнения
оператора ввода, управляемого списком, останавливает выполнение этого
оператора после присвоения предыдущего значения. Любые последующие
элементы в списке входных данных обрабатываются как пустые значения;
- один или более
последовательных
пробелов
между
двумя
константами или после последней константы.
Пробелы,
следующие за разделителями пробелов, игнорируются.
Например, запись 5, 6 / 7 эквивалентна записи 5,6/7.
ПРИМЕЧАНИЕ
Ввод/вывод, управляемый
запрещен стандартом ANSI.
3.8.1
списком,
в
или
из
внутренних
файлов
Ввод, управляемый списком
В большинстве случаев все форматы
ввода,
допустимые
для
форматного
ввода/вывода,
также допустимы и для форматирования,
управляемого списком. В данном подразделе рассмотрены исключения из
этого правила.
Следующие правила применимы для управляемого списком ввода любых
значений:
- формат входного значения должен быть допустимым для типа
элемента списка входных данных;
- пробелы всегда обрабатываются как разделители, но не как нули;
- встроенные пробелы
могут
использоваться
только
внутри
символьных констант.
Следует отметить, что признак "конец-записи" имеет такое же
действие, что и пробел, за исключением случая, когда он указан внутри
символьной константы.
В приведенном ниже списке представлены ограничения и исключения
из перечисленных выше правил:
Тип значения
---------------------Вещественные константы
одинарной или двойной
точности
Комплексные константы
Логические константы
Символьные константы
Ограничения
--------------------------------------------Вещественные
константы
или
константы
с
двойной
точностью
должны
быть
"числовыми
входными
полями", т.е. полями,
"пригодными"
для
преобразования
с
использованием дескриптора F. Предполагается,
что
они не должны иметь дробной части,
если, однако,
внутри
поля
не
указана
десятичная точка.
Комплексная константа является упорядоченной
парой
вещественных
или
целочисленных
констант, разделенных запятой и заключенных
в
круглые
скобки.
Первая
константа
пары
есть
действительная
часть
комплексной константы; вторая - мнимая ее
часть.
Логическая
константа
не может содержать
ни слэши, ни запятые среди необязательных
символов, разрешенных для дескриптора L.
Символьная
константа
представляет собой
непустую
строку
символов, заключенную в
одинарные
кавычки
(апострофы).
Каждая
одинарная кавычка внутри символьной константы
должна быть представлена двумя одинарными
кавычками; между
ними
не
должно
быть
пробелов.
Символьные константы могут быть продолжены,
начиная с конца одной записи
в
начало
следующей
записи;
конец
записи
не
обуславливает
того,
что
пробел
или
какой-либо
другой
символ
становится
частью
символьной
константы.
Константа
может быть продолжена на столько записей,
на сколько это необходимо, и может включать
Пустые значения
Пробелы
символы пробела, запятую или слэш.
Если длина элемента списка, n, меньше или
равна длине символьной константы, m, то n
"самых
левых" символов "сообщения" будут
передаваться в элемент списка.
Если n больше m, то константа передается в m
"самых
левых"
символов элемента списка.
Оставшиеся n-m символов
элемента
списка
заполняются пробелами (эта операция совпадает
с
операцией
простого
присваивания
константы
элементу
списка
в
операторе
присваивания).
Пустое (null) значение може быть указано
одним из следующих трех способов:
1.
Между
двумя
последовательными
разделителями значений никакие символы не
указываются;
2. Перед первым разделителем значений не
указывается никаких
символов
(в
первой
записи, считываемой при каждом исполнении
оператора ввода, управляемого списком);
3. Используя формат
r*
(например,
10*
эквивалентно
десяти
пустым
значениям).
Пустое
значение
не
оказывает
никакого
воздействия
на
описание соответствующего
элемента в списке
ввода.
Если
элемент
списка
входных
данных
определен,
он
сохраняет свое предыдущее значение; если он
неопределен, то элемент удаляется.
Слэш
(/),
который встречается во время
исполнения оператора
ввода,
управляемого
списком,
как
разделитель
значений,
останавливает выполнение
оператора
после
присвоения
элементу предыдущего значения.
Все
последующие
элементы
в
списке
ввода обрабатываются как пустые значения.
Все пробелы в записи входных данных, ввод
которых управляется списком, рассматриваются
как
части
некоторого
разделителя
значений, за исключением следующих случаев:
- пробелы, встроенные в символьную константу;
- ведущие
пробелы
в
первой
записи,
считываемой при исполнении каждого оператора
ввода/вывода,
управляемого списком, если,
однако, сразу после них не указан символ
слэша (/) или запятая (,).
ПРИМЕР
В данном примере используется ввод/вывод, управляемый списком:
REAL
a
INTEGER i
COMPLEX c
LOGICAL up,down
DATA a/2358.2E-8/, i /91585/, c /(705.60,819.60)/
DATA up /.TRUE./, down /.FALSE./
OPEN (UNIT = 9, FILE = 'listout', STATUS = 'NEW')
WRITE
WRITE
RETURN
READ
READ
WRITE
WRITE
END
(9,
(9,
(9)
(9,
(9,
(*,
(*,
*) a, i
*) c, up, down
*)
*)
*)
*)
a,
c,
a,
c,
i
np, down
i
up, down
Выходными результатами данной программы являются:
2.358200E-005
91585
(705.6000000,819.6000000) T
3.8.2
F
Вывод, управляемый списком
Формат значений, получаемых при выводе, управляемом списком,
совпадает с форматом значений, требуемым для ввода данных, за теми
исключениями, что перечислены в данном подразделе. Ширина строки при
выводе, управляемом списком, составляет 79 символов.
При необходимости создаются новые записи, но ни признак конца
записи, ни пробелы не могут присутствовать внутри константы (за
исключением симвльных констант). Для обеспечения управления кареткой
при печати записи, каждая выходная запись должна начинаться с символа
пробела.
Таким
образом,
пользователю
нет
необходимости специально
записывать пробел как символ управления кареткой. Кроме того, для
перечисленных ниже типов данных должны применяться следующие правила:
Тип данных
----------------------Логические константы
Характеристики
--------------------------------------------Вывод
выполняется
аналогично
выводу
с
использованием дескриптора T для истинных
значений и аналогично выводу с использованием
дескриптора F для ложных значений.
Целочисленные константы Вывод, аналогичный выводу с использованием
дескриптора преобразования I11.
Вещественные константы
Вывод, аналогичный выводу с использованием
с одинарной или двойной либо дескриптора F, либо дескриптора
Е,
точностью
в зависимости от значения константы:
Если:
Тогда:
--------------- ---------------------------1<=constant и
константа constant является
constant<10**7
"выходным
данным",
вывод
(10 в степени 7) которой
осуществляется
с использованием дескриптора
преобразования OPF15.6 для
для
чисел
с
одинарной
точностью,
или
с использованием дескриптора
OPF24.15
для
чисел
с двойной точностью.
constant<1 или
константа constant является
constant<=10**7 "выходным
данным",
вывод которой осуществляется
с
использованием
дескриптора
преобразования
1PE15.6E2
для
чисел
Символьные константы
Слэши как разделители
Значений
Пустые значения
с
одинарной
точность, и
использованием
дескриптора
1PE24.15E3
для
чисел
с двойной точность.
Не "ограничиваются" апострофами. Символьным
константам не
предшествуют
и
за
ними
не следуют разделители записей.
Каждый
внутренний апостроф представляется
одним внешним. Символ пробела вставляется
в начало любой записи, которая начинается
с
продолжения
символьной
константы
из
предыдущей записи.
Не выводятся.
Не выводятся.
ПРИМЕР
В данном примере используется вывод, управляемый списком:
INTEGER i, j
REAL
a, b
LOGICAL on, off
CHARACTER*20 c
DATA i /123456/, j /500/, a /28.22/, b /.0015555/
DATA on /.TRUE./, off/.FALSE./
DATA c /'Here''s a string'/
WRITE (*, *) i, j
WRITE (*, *) a, b, on, off
WRITE (*, *) c
END
В результате выполнения программы на экран будут выданы следующие
результаты:
123456
28.220000
Here's string
3.9
500
1.555500E-003 TF
Ввод/вывод, управляемый именованным списком
Ввод/вывод, управляемый именованным списком, является мощным
способом чтения или записи данных в файл (или на терминал). Путем
спецификации одной или более переменных в группе именованного списка
пользователь
может читать или писать значения всех переменных,
используя один оператор ввода/вывода.
Оператор ввода/вывода, управляемый именованным списком, выполняет
поиск во вводном файле имени группы. При нахождении имени оператор
выполняет поиск операторов присвоения, задающих значения для одной или
нескольких переменных в группе. Прерывание операции ввода данного типа
выполняется при задании прямого слэша. Оператор вывода записывает имя
именованного списка, за которым следует имя каждой переменной в
списке, знак равенства и текущее значение переменной. Прерывание
вывода выполняется по символу слэша.
Группа именованного списка создается оператором NAMELIST, имеющим
следующий формат:
'NAMELIST /<namelist>/ <variablelist>
где <namelist> - есть идентифицирующее имя группы, а <variablelist> есть список переменных и имен массивов.
Значения переменных в списке записываются в файл или на экран при
помощи
оператора WRITE, в котором <namelist> появляется вместо
спецификатора формата. Следует отметить,
что
требуется
список
<iolist>.
WRITE (*,NML = <namelist>)
Параметр NML= является необязательным и требуется только тогда,
когда используются другие ключевые слова (например END=).
Первая выводимая запись есть амперсанд (&), за которым сразу
следует
имя
группы именованного списка (прописными буквами). В
последующих записях перечислены имена в группе и их значения. Каждая
выводимая
запись
начинается с символа пробела для обеспечения
управления кареткой, если запись выводится на принтер. Значения имеют
формат вывода, который указан для них в случае операций ввода/вывода,
управляемого списком; исключение состоит в том, что символьная строка
ограничивается апострофами. Это позволяет создаваемый файл читать при
помощи оператора READ, который требует указания апострофов в качестве
разделителей. Последней выводимой записью является слэш.
ПРИМЕР
В следующем примере объявляется число переменных, помещаемых в
список, выполняется их инициализация и затем запись на экран.
INTEGER
LOGICAL
REAL
COMPLEX
CHARACTER
int1*1, int2*2, int4*4, array(3)
log1*1, log2*2, log4*4
real4*4, real8*8
z8*8, z16*16
char1*1, char10*10
NAMELIST /example/ int1*1, int2*2, int4*4, array(3),
+
log1*1, log2*2, log4*4, real4*4, real8*8 z8*8,
+
z16*16, char1*1, char10*10, array
int1
int2
int4
log1
log2
log4
real4
real8
z8
z16
char1
char10
array(1)
array(2)
array(3)
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
11
12
14
.TRUE.
.TRUE.
.TRUE.
24.0
28.0d0
(38.0,0.0)
(316.0d0.0,0)
'A'
'0123456789'
41
42
43
WRITE (*, example)
Результат будет следующим:
&EXAMPLE
INT1 =
11
INT2 =
12
INT3 =
14
LOG1 = T
LOG2 = T
LOG4 = T
REAL4 =
24.000000
REAL8 =
28.000000000000000
Z8 =
(38.000000,0.000000E+00)
Z16 =
(316.0000000000000000,0.000000000000000E+000)
CHAR1 = 'A'
CHAR10 = '0123456789'
ARRAY =
41
42
43
/
Выполнение оператора READ противоположно выполнению оператора
WRITE. Сначала оператор выполняет просмотр файла с текущей позиции до
нахождения символа амперсанда, за которым сразу следует имя группы,
либо до тех пор, пока не будет найден конец файла. Для отделения имени
группы от следующего за ним списка значений необходимо указать по
крайней мере один пробел или символ возврата каретки.
Присваивающая значение пара (необязательная!) состоит из имени
переменной, элемента массива или подстроки, за которыми следует знак
равенства или одно или более значений и разделителей значений. Знаку
равенства должен предшествовать или за ним должно следовать любое
число пробелов. Разделитель значений является единственной запятой или
одним или несколькими пробелами. Запятая, которой не предшествует
значение, обрабатывается как пустое (null) значение, а соответствующая
переменнаая или элемент массива не изменяется.
Переменные могут указываться в любой последовательности. Одна и
та же переменная может появляться более чем в одной присваивающей
паре.
Конечное
значение есть значение, получаемое в последнем
присваивании. Все переменные в списке не требуют присвоения им
значений; те из них, которые не появляются, или не ассоциированы с
пустыми значениями, сохраняют текущее значение. Имя переменной во
вводном файле, не указанное в списке, приводит к ошибке этапа
исполнения.
Если имя массива появляется без квалифицирующего индекса, то
первое значение в операторе присвоения задается для первого элемента
массива, второе - для второго элемента и т.д. Присвоение значений
массиву выполняется в последовательности возрастания строк.
Нельзя присваивать значений больше, чем указано элементов в
массиве. Любые потерянные значения обрабатываются как пустые (null)
значения, а соответствующие элементы массива не изменяются. Отдельные
значения могут быть также присвоены индексированным элементам массива.
Значение может быть повторено путем помещения фактора повторения
и звездочки в начало собственно значения. Например, 7 *'Hello'
присваивает 'Hello' следующим семи элементам в массиве или списке
переменных. Фактор повторения и звездочка без значения указывают на
многократные
пустые
значения.
Соответствующие
переменные
не
изменяются.
Задавая
массив
matrix(0:101),
следующие операторы
присваивают значение 10 элементу 0, значение 25 элементам с 1 до 50;
значения от 51 до 100 остаются без изменений; элементу 101 назначается
значение -101, затем изменяется значение matrix(42) на значение 62:
matrix = 10, 50*25, 50*, -101
matrix(42) = 63
Символьные строки должны разделяться апострофами.
Прерывание оператора READ выполняется символом слэша или при
достижении конца файла. Слэши не должны использоваться как разделители
значений,
если, однако, они заранее не определены как символы
прерывания операции чтения.
Предположим, что в следующей программе требуется прочитать новые
значения для некоторых переменных в списке example:
&example
z8 = (99.0,0.0)
INT1=99
array(1)=99
real4 = 99.0
CHAR1='Z'
char10(5:) = 'GrUMp'
log1=F
/
Затем следующий оператор READ будет
специфицированным переменным:
READ
(UNIT
=
присваивать
новые
значения
4, example)
Второй оператор WRITE (*,example) будет отображать их измененные
значения следующим образом:
&EXAMPLE
INT1 =
99
INT2 =
12
INT3 =
14
LOG1 = F
LOG2 = T
LOG4 = T
REAL4 =
99.000000
REAL8 =
28.000000000000000
Z8 =
(99.000000,0.000000E+00)
Z16 =
(316.0000000000000000,0.000000000000000E+000)
CHAR1 = 'Z'
CHAR10 = '0123GrUMP9'
ARRAY =
99
42
43
/
4.
ОПЕРАТОРЫ
В первой части данного раздела описываются типы операторов,
используемых в языке ФОРТРАН. Вторая часть раздела содержит каталог
операторов языка ФОРТРАН, перечисленных в алфавитном порядке.
Оператор в языке ФОРТРАН состоит из начальной строки, за которой
(необязательно!) следуют до 19 строк продолжения. В языке ФОРТРАН
фирмы Microsoft число строк продолжения ограничено только размером
области доступной памяти. Операторы записываются в позициях, начиная
от 7 до 72. Операторы выполняют различные действия,
например:
вычисление,
сохранение
результатов вычислений, изменение потока
управления, чтение и запись файлов, "предоставляют"
информацию,
требуемую компилятору.
4.1
Категории операторов
Различают
два
основных
типа операторов в языке ФОРТРАН:
исполнямые
и
неисполняемые
операторы.
Исполняемые
операторы
обуславливают некоторое действие, которое должно быть выполнено;
неисполняемые
операторы
действий,
подлежащих
выполнению,
не
обуславливают. Напротив, они предназначены для описания, классификации
или спецификации форматов элементов программы, например, точек входа,
данных или программных модулей.
Список операторов языка ФОРТРАН представлен в табл.4.1.
Таблица 4.1
Категории операторов языка ФОРТРАН
------------------------------------------------------------:
Категория
:
Тип
:
Описание
:
:------------------+----------------+-----------------------:
:Операторы
:Исполняемый
:Присваивание
значения:
:присваивания
:
:переменной или элементу:
:
:
:массива. См. подразд. :
:
:
:4.2 "Оператор ASSIGN" :
:BLOCK DATA, ENTRY,:Неисполняемый
:Описывают
начало:
:FUNCTION,
:
:программного модуля и:
:INTERFACE ТО,
:
:специфицируют
его:
:PROGRAM,
:
:формальные параметры
:
:SUBROJTINE
:
:
:
:Операторы
:Исполняемый
:Управление
последова-:
:управления
:
:тельностью
выполнения:
:
:
:операторов (см. таблицу:
:
:
:4.3)
:
:DATA
:Неисполняемый
:Присваивание переменным:
:
:
:начальных значений
:
:FORMAT
:Неисполняемый
:Спецификация информации:
:
:
:для форматирования
и:
:
:
:преобразования данных :
:Операторы
:Исполняемыe
:Передача данных и обра-:
:ввода/вывода
:
:ботка файлов и записей.:
:
:
:См. табл.4.4 и раздел :
:
:
:"Система ввода/вывода :
:Операторы
:Неисполняемыe
:Описание
атрибутов :
:описания
:
:переменных, массивов и :
:
:
:подпрограмм. См. табл. :
:
:
:4.2.
:
:Операторы
:Неисполняемые
:Определение простой, :
:операторной
:
:локально используемой :
:функции
:
:функции
:
------------------------------------------------------------В табл.4.2 перечислены операторы описания.
Таблица 4.2
Операторы описания
-------------------------------------------------------------------:
Оператор
:
Назначение
:
:----------------------+-------------------------------------------:
:AUTOMATIC
:Объявление
переменных в стэке, а не в :
:
:статической области памяти
:
:COMMON
:Предназначен для обеспечения совместного :
:
:использования области памяти двумя и более :
:
:программными модулями
:
:DIMENSION
:Идентификация
массива
и
определение :
:
:количества его элементов
:
:EQUIUALENCE
:Указывает, что две и более переменные или :
:
:массивы совместно используют одну и ту же :
:
:область памяти
:
:EXTERNAL
:Позволяет передавать определенную пользова-:
:
:телем процедуру или функцию как параметр
:
:IMPLICIT
:Изменение ввода по умолчанию для целых и :
:
:вещественных переменных и функций
:
:INTRINSIC
:позволяет
передавать
предопределенные :
:
:функции как параметры
:
:MAP...END MAP
:Внутри оператора UNION ограничивает группу :
:
:объявлений типов переменных,
размещенных :
:
:в памяти последовательно
:
:NAMELIST
:Объявление группового имени
для набора :
:
:переменных
для
чтения/записи в одном :
:
:операторе
:
:PARAMETR
:Устанавливает соответствие между констант- :
:
:ным выражением и именем
:
:RECORD
:Объявление
одной или
более переменных :
:
:определенного пользователем структурного :
:
:типа
:
:SAVE
:Предписывает переменным сохранить значения :
:
:между активизациями процедуры, в которой :
:
:они определены и описаны
:
:STRUCTURE...END
:Описание нового типа переменной, являющего-:
:STRUCTURE
:ся объединением других типов переменных
:
:Тип:
:Специфицирует
тип
имен,
заданных :
:
:пользователем
:
:CHARACTER[*n]
:
:
:COMPLEX[*bytes]
:
:
:DOUBLE COMPLEX
:
:
:DOUBLE PRECISION
:
:
:INTEGER[*bytes]
:
:
:LOGICAL[*bytes]
:
:
:REAL[*bytes]
:
:
:RECORD/struct-name/
:
:
:STRUCTURE/struct-name/:
:
:UNION...END UNION
:Внутри оператора STATEMENT предписывает :
:
:переменным в двух или более отображениях :
:
:занимать одну и ту же область памяти
:
-------------------------------------------------------------------В таблице 4.3 перечислены операторы управления.
Таблица 4.3
Операторы управления
-------------------------------------------------------------:
Оператор
:
Назначение
:
:----------------+-------------------------------------------:
:ALLOCATE
:Динамическое создание размещаемого массива :
:CALL
:Вызов и исполнение процедуры
:
:CASE
:Внутри структуры SELECT CASE маркирует блок:
:
:операторов, исполняемых если связанное зна-:
:
:чение соответствует выражению SELECT CASE :
:CONTINUE
:Не оказывает никакого воздействия: часто
:
:
:используется как обект оператора GOTO, или :
:
:как терминальный оператор в DO-цикле
:
:CYCLE
:Передача управления в последний оператор :
:
:DO-цикла; внутренние операторы DO-цикла не :
:
:выполняются
:
:DEALLOCATE
:Чистка области памяти, ранее
занятой по :
:
:оператору ALLOCATE
:
:DO
:Обуславливает
повторное
(многократное) :
:
:вычисление оператора в DO-цикле
:
:DO WHILE
:Вычисление операторов в цикле DO WHILE до :
:
:последнего
оператора,
когда логическое :
:
:условие не примет значение "ложь"
:
:ELSE
:Вводит блок ELSE
:
:ELSEIF
:Вводит блок ELSEIF
:
:END
:Завершает выполнение программного модуля
:
:END DO
:Маркировка конца группы операторов, которые:
:
:следуют за оператором DO или DO WHILE
:
:END IF
:Маркирует конец группы операторов, которые :
:
:следуют за оператором IF
:
:ЕND SELECT
:Маркировка конца оператора SELECT CASE
:
:ЕXIT
:Выход из DO-цикла; продолжение выполнения :
:
:с первого последующего оператора
:
:GOTO
:Обеспечивает передачу управления в любую
:
:
:точку программы
:
:INCLUDE
:Вставка
содержимого
заданного файла в :
:
:исходный файл
:
:IF
:Обеспечивает выполнение других операторов :
:
:по условию; зависит от результата вычисле- :
:
:ния
и типа используемого оператора IF :
:
:(арифметический, логический или блок)
:
:PAUSE
:Временно
приостанавливается
выполнение :
:
:программы
и,
необязательно, исполняет :
:
:команды операционной системы
:
:RETURN
:Возвращает управление в программный модуль,:
:
:который вызвал процедуру или функцию
:
:SELECT CASE
:Передача управления программы в выбранный :
:
:блок
операторов, основанная на значении :
:
:управляющего выражения
:
:STOP
:Прерывает выполнение программы
:
-------------------------------------------------------------В табл.4.4 перечислены операторы ввода/вывода.
Таблица 4.4
Операторы ввода/вывода
-------------------------------------------------------------:
Оператор
:
Назначение
:
:----------------+-------------------------------------------:
:BACKSPACE
:Позиционирует файл, присоединенный к задан-:
:
:ному устройству, в начало предыдущей записи:
:CLOSE
:"Отключает" указанное устройство; последую-:
:
:щие операции ввода/вывода на данное устрой-:
:
:ство запрещены
:
:ENDFILE
:Записывает запись "конец файла" в файл,:
:
:присоединенный
к
заданному устройству :
:INQUIRE
:Возвращает значение, указывая характеристи-:
:
:ки файла или устройства
:
:LOCKING
:Запрещает файлы и записи прямого доступа:
:OPEN
:Устанавливает соотвествие номера устройства:
:
:с внешним устройством или файлом
:
:PRINT
:Специфицирует вывод на экран
:
:REWIND
:Репозиционирует специфицированное устрой-:
:
:ство
в первую
запись ассоциированного:
:
:файла
:
:READ
:Передает данные из файла в элементы списка :
:
:ввода/вывода
:
:WRITE
:Передает данные из элементов списка ввода/ :
:
:вывода в файл
:
-------------------------------------------------------------4.2
Каталог операторов
Данный подраздел представляет собой алфавитный список операторов
языка ФОРТРАН. Каждый оператор описан с использованием следующего
формата:
Заголовок
---------------Действие
Синтаксис
Замечание
Пример
Информация
-------------------------------------------------Краткое описание выполняемой оператором функции.
Корректный
синтаксис
оператора
и
описание
параметров оператора.
Использование оператора.
Пример
программы
или
фрагмента
программы,
иллюстрирующий использование оператора.
Синтаксис оператора, который не умещается
показывается на нескольких строках, например:
на
одной
строке,
CLOSE([UNIT=]<unitspec>
[,ERR=<errlabel>]
[,IOSTAT=<iocheck>]
[,STATUS=<status>]
При использовании таких операторов, пользователь должен следовать
правилам форматирования, описанным в подразд.2.1, или, если указана
метакоманда $FREEFORM, правилам, описанным в подразд.2.3 Например,
следующий программный фрагмент является некорректным:
CLOSE (UNIT = 2,
ERR = 100,
IOSTAT = <errvar>)
Следующие два оператора будут корректными:
CLOSE (UNIT = 2, ERR = 100, IOSTAT = errvar)
CLOSE (UNIT = 2,
+
ERR = 100,
+
IOSTAT = <errvar>)
Оператор ALLOCATE
----------------ДЕЙСТВИЕ
Динамическое размещение массива, ранее объявленного
ALLOCATABLE
с
атрибутом
СИНТАКСИС
ALLOCATE(<array>([l:]u[.[l:]u...])[,STAT = <ierr>])...
Параметр
Описание
-------- -------------------------------------------------------array
Имя размещаемого массива.
ierr
Целочисленная
переменная,
возвращающая
состояние,
получаемое при выполнении попытки размещения.
l
Целочисленное выражение, устанавливающее нижнюю границу
массива.
u
Целочисленное выражение, устанавливающее верхнюю границу
массива.
ЗАМЕЧАНИЯ
Размещаемые массивы могут быть динамически размещены во время
этапа исполнения. Массив должен быть предварительно объявлен как
ALLOCATABLE; объявлено также должно быть и число измереной массива.
Оператор ALLOCATE создает верхнюю и нижнюю границы каждого измерения и
резервирует необходимую память.
В операторе ALLOCATE может быть задано более одного массива; они
разделяются запятыми. Последним должен указываться параметр STAT=.
Размещаемые массивы не могут иметь атрибут NEAR. Если массив
имеет
размер,
больший
65535
байтов,
то пользователь должен
специфицировать атрибут HUGE для корректной адресации
элементов
массива.
Размещаемые
массивы не могут появляться в операторах
AUTOMATIC, COMMON, DATA или EQUIVALENCE.
Попытка переразместить ранее размещенный массив приводит к ошибке
этапа исполнения.
Любая неудача при выполнении операции размещения приводит к
ошибке
этапа исполнения, если, однако, не задана опция STAT=.
Переменная <ierr> возвращает значение ноль, если операция размещения
была выполнена успешно; в противном случае возвращается номер ошибки
этапа исполнения.
ПРИМЕР
.
.
.
INTEGER dataset[ALLOCATABLE] (:,:),
+
results[ALLOCATABLE, HUGE] (:,:)
INTEGER reactor, level, calcs, error
DATA reactor, level, calcs / 10, 50, 100/
ALLOCATE (dataset(reactor,level),
+
results(reactor,level,calcs), STAT = error)
IF (error .NE. 0)
+
STOP 'Not enough storage for data; aborting...'
.
.
.
СМОТРИ ТАКЖЕ
Оператор DEALLOCATE.
Оператор ASSIGN
--------------ДЕЙСТВИЕ
Присваивание
переменной.
значения
формата или метки оператора целочисленной
СИНТАКСИС
ASSIGN <label> TO <variable>
Параметр
---------label
variable
Описание
---------------------------------------------------------Форматная метка или операторная метка. Метка <label>, на
которую ссылаются, должна присутствовать
в
том
же
программном модуле, что и оператор ASSIGN.
Целочисленное значение.
ЗАМЕЧАНИЯ
Оператор
ASSIGN используется
некоторой
переменной.
Переменные
использоваться в следующих случаях:
Ситуация
------------------------Присвоение оператора GOTO
Спецификатор формата
для
со
присвоения значения
значениями
меток
метки
могут
Использование
--------------------------------------Присваиваемый
оператор GOTO требует
указывать
переменную,
которая
должна
иметь
значение
метки
исполняемого оператора.
Оператоы
ввода/вывода предоставляют
пользователю возможность использования
переменной
для
указания
метки
оператора FORMAT.
Значение
метки
не
совпадает
с
номером
метки;
метка
идентифицируется номером, который назначается компилятором. Например,
значение IVBL в следующем операторе не равно 400:
ASSIGN 400 TO IVBL
Таким образом, переменные, используемые в операторах ASSIGN, не
определяются как целые числа. Если необходимо использовать переменную,
определнную с помощью оператора ASSIGN, в арифметическом выражении, то
пользователь должен прежде всего определить переменную при помощи
вычисляемого оператора присваивания или при помощи оператора READ.
Если для переменной <variable> используется тип INTEGER*1, то
следует помнить, что переменные типа INTEGER*1 могут использоваться
только для первых 128-и операторов ASSIGN, указываемых в подпрограмме.
ПРИМЕР
C Присвоение операторной метки 100 целочисленной переменной ivar
ASSIGN 100 TO ivar
C Использование ivar как метки оператора FORMAT
WRITE (*, ivar)
C Присвоение операторной метки 200 переменной ivar
ASSIGN 200 TO ivar
C Использование ivar как целевой метки присваиваемого
С оператора GOTO
GOTO ivar
WRITE (*, *) 'This is never written'
200 CONTINUE
WRITE (*, *) 'This is written'
100 FORMAT ('This is format 100')
END
Оператор присваивания (вычисляемый)
----------------------------------ДЕЙСТВИЕ
Вычисляет выражение и
присваивает
результирующее
специфицированной переменной или элементу массива.
значение
СИНТАКСИС
<variable>=<expression>
Параметр
-----------variable
expression
Описание
-------------------------------------------------------Переменная, массив, элемент массива или указатель на
структурный элемент.
Любое выражение.
ЗАМЕЧАНИЯ
Тип
переменной, массива, элемента массива или структурного
элемента должен быть совместим с типом выражения, а именно:
- если <expression> имеет числовой тип, тогда <variable> тоже
должна
иметь
числовой
тип;
оператор
при
этом
называется
"арифметическим оператором присваивания". Если типы данных выражения
<expression> и переменной <variable> не совпадают, то выражение
<expression> преобразуется к типу данных переменной <variable>;
- если выражение <expression> является логическим, тогда и
переменная <variable> должна иметь логический тип; оператор в этом
случае называется "логическим оператором присваивания". Логические
выражения любого размера могут присваиваться логическим переменным
любого размера, не оказывая при этом никакого воздействия на значение
выражения.
Следует отметить, что ни целочисленные и вещественные выражения
не могут быть присвоены логической переменной, ни логические выражения
не могут быть присвоены целочисленным или вещественным переменным;
- если выражение <expression> имеет тип CHARACTER, то оператор
называется "символьным оператором присваивания". Если действительна
(по умолчанию!) метакоманда $NOTSTRICT, тогда символьное выражение
может быть присвоено символьной переменной, а несимвольная переменная
или элемент массива (но не выражение!) могут быть также присвоены
символьной переменной. Если действительна метакоманда $STRICT, то и
выражение <expression> и переменная <variable> должны иметь тип
CHARACTER.
Для символьных операторов присваивания, если длина выражения
<expression>
не
соотвествует размеру переменной <variable>, то
выражение <expresion> выравнивается следующим образом:
- если переменная <variable> длиннее выражения <expression>,
тогда выражение <expression> дополняется пробелами справа;
- если переменная <variable> короче выражения <expression>, тогда
крайние символы справа в выражении игнорируются;
- если переменная <variable> есть массив, то выполняется операция
присвоения массива (см. подразд.1.7.5).
ПРИМЕРЫ
В следующей программе демонстрируются операторы присваивания:
REAL
LOGICAL
CHARACTER*5
a, b, c
abigger
assertion
c = .01
a = sqrt(c)
b = c**2
assertion = 'a > b'
abigger = (a .GT. b)
100
WRITE (*, 100) a, b
FORMAT (' a = ', F7.4, '
b =', F7.4)
IF (abigger) THEN
WRITE (*, *) assertion, 'is true.'
ELSE
WRITE (*, *) assertion, 'is false.'
END IF
END
Данная программа имеет следующие выходные результаты:
A = .1000
B = .0001
A > B is true.
В следующем примере показаны правильные и неправильные операторы
присваивания:
INTTEGER i,int
REAL rone(4), rtwo(4), x, y
COMPLEX z
CHARACTER char6*6, char8*8
i
x
= 4
= 2.0
z
rone(1)
rone(2)
rone(3)
rone(4)
char8
=
=
=
=
=
=
(3.0, 4.0)
4.0
3.0
2.0
1.0
'Hello'
C Следующие операторы правильные:
i
int
int
y
y
y
rtwo
rtwo
char6
=
=
=
=
=
=
=
=
=
rone(2)
rone(1)
x
x
z
rone(3)
rone
4.7
char8
C Следующие операторы являются ошибочными:
char6
= x + 1.0
int
= char8//'test'
y
= rone
Оператор AUTOMATIC
-----------------ДЕЙСТВИЕ
Объявление специфицируемых переменных как находящихся в стэке,
не как размещенных в статической области памяти.
а
СИНТАКСИС
AUTOMATIC[<names>]
Параметр
Описание
-------- -------------------------------------------------------names
Список переменных или имен массивов, которые определены
как "автоматические".
Если
указано
более
одной
переменной, то они разделяются запятыми.
ЗАМЕЧАНИЯ
В языке ФОРТРАН фирмы Microsoft все переменные определены по
умолчанию
как
статические.
Переменная,
объявленная
как
"автоматическая", занимает фиксированное место в памяти; раздел стэка
памяти выделяется для переменной при необходимости. Автоматические
переменные
внутри
процедуры
"отбрасываются" при завершении ее
выполнения. Поэтому, для таких переменных не гарантируется, что они
будут иметь то же самое значение, что и при следующей активизации
процедуры.
Если оператор AUTOMATIC не содержит ни одного имени переменной,
то все переменные внутри этого программного модуля (головной программы
или отдельной подпрограммы), которые могут быть автоматическими, будут
автоматическими неявно.
В операторе AUTOMATIC не разрешено использовать имена блоков
общего пользования и имена общих переменных. Переменная не может
указываться одновременно в операторах SAVE и AUTOMATIC.
Переменные с атрибутами ALLOCATABLE, EXTERNAL, FAR или HUGE не
могут быть автоматическими. Переменная, которая была явно описана как
автоматическая, не может появляться в операторе DATA. Переменные,
являющиеся автоматическими явно и появляющиеся в операторе DATA, будут
инициализироваться и помещаться в статическую память. Переменная может
появляться в операторе AUTOMATIC только один раз. Формальные параметры
и имена процедур не могут указываться в операторе AUTOMATIC.
Возможность объявления автоматических переменных реализована для
поддержки приложений, функционирующих в среде операционной системы
OS/2.
ПРИМЕР
C
С
С
С
В данном примере все переменные внутри программного модуля
являются автоматическими, за исключением "clark" и "lois";
они явно объявлены в операторе SAVE и поэтому размещаются
в статической памяти:
INTEGER FUNCTION Fibonacci (clark, lois)
AUTOMATIC
SAVE clark, lois
Оператор BACKSPACE
-----------------ДЕЙСТВИЕ
Позиционирование файла, присоединенного к указанному
в начало предыдущей записи.
устройству,
СИНТАКСИС
BACKSPACЕ{<unitspec>│
([UNIT=]<unitspec>
[,ERR=<errlabel>]
[,IOSTAT=<iocheck>])}
Если UNIT= опущено, то <unitspec> должен быть первым параметром.
В противном случае круглые скобки могут
указываться
в
любой
последовательности.
Параметр
----------unitspec
errlabel
iocheck
Описание
--------------------------------------------------------Целочисленное
выражение,
специфицирующее
внешнее
устройство.
Если
устройство
<unitspec>
не
является открытым,
то герируется ошибка этапа исполнения.
Метка исполняемого оператора в том же программном модуле.
Если метка <errlabel> указана, то при возникновении
ошибки
ввода/вывода
управление
передается
в оператор с меткой <errlabel>. Если метка <errlabel>
опущена,
то
при
возникновении ошибки ввода/вывода
генерируется
сообщение
об
ошибке.
Действия
при
возникновении ошибки ввода/вывода задаются параметром
<iocheck> .
Целочисленная
переменная, элемент массива или элемент
структуры, которые определяются со значением 0, если
ошибок
не
произошло, или опредляются со значением
положительного
целого
числа, если произошла ошибка
(см. также подразд.3.2.6).
ЗАМЕЧАНИЯ
По оператору BACKSPACE происходит возврат строго на одну запись,
за исключением следующих специальных случаев:
Если:
--------------------------нет ни одной предшествующей
записи
Тогда:
-------------------------------------позиция файла не изменяется.
предшествующая запись есть
запись "конец-файла"
файл
позиционируется
"конец-файла".
позиция файла находится
в середине записи
файл позиционируется в начало записи.
перед
записью
Если параметр оператора BACKSPACE является выражением, в котором
реализуется обращение к функции, то эта функция не должна вызывать
выполнения оператора ввода/вывода или
встроенной
функции
EOF,
поскольку результат в этом случае будет непредсказуем.
ПРИМЕР
C Примеры операторов BACKSPACE
BACKSPACE 5
BACKSPACE (5)
BACKSPACE lunit
BACKSPACE (UNIT = lunit, ERR = 30, IOSTAT = ios)
Оператор BLOCK DATA
------------------ДЕЙСТВИЕ
Идентифицирует модуль-блок данных,
в
котором
могут
быть
инициализированы
переменные
и элементы массивов, находящиеся в
поименованных блоках общего пользования.
СИНТАКСИС
BLOCK DATA[<blockdataname>]
Параметр
-------------blockdataname
ЗАМЕЧАНИЯ
Описание
-----------------------------------------------------Глобальное символическое имя подпрограммы.
Это имя должно быть одним и тем же для любых имен
локальных
переменных
или
элементов
массива,
определенных
в
подпрограмме,
отмеченной
именем
<blockdataname>,
и не должно совпадать с любыми
именами,
задаваемыми
для
глобальной
программы,
внешних
процедур,
общих
блоков
или
других модулей-блоков данных.
Оператор BLOCK DATA должен быть первым оператором модуля-блока
данных.
В исполняемой программе может
присутствовать
только
один
непоименованный модуль-блок данных. В противном случае, принимаемое по
умолчанию
имя
будет
определено
дважды; в этом случае будет
генерироваться ошибка.
При использовании модулей-блоков данных следует
помнить
о
следующих ограничениях:
- в модуле-блоке данных могут использоваться только следующие
операторы: BLOCK DATA, COMMON, DATA, DIMENSION, PARAMETER, IMPLICIT,
EQUIVALENCE, SAVE, END, MAP, RECORD, STRUCTURE, UNION и операторы
типа. Использование исполняемых операторов не разрешено;
- поименованные "общие" блоки, специфицируемые в модулях-блоках
данных, должны иметь уникальные имена. В модуле-блоке данных начально
может быть определен только объект, определенный в поименованном
"общем" блоке;
все
составляющие
поименованного
"общего"
блока,
специфицированные в модуле-блоке данных, должны быть специфицированы в
этом
модуле-блоке
данных,
даже
если
не
все
составляющие
инициализированы, как это показано в
следующих
примерах.
Это
происходит потому, что длина поименованного "общего" блока не может
изменяться при использовании его различными модулями.
ПРИМЕР
C Следующий модуль-блок данных инициализирует одну составляющую
C поименованного "общего" блока /greatlakes/:
C
BLOCK DATA Lakes
COMMON /greatlakes/ erie, huron, michigan, ontario, superior
DATA erie, huron, michigan, ontario, superior /1, 2, 3, 4, 5/
END
C
C Теперь, предполагая, что используется тот же "общий" блок,
C /greatlakes/, следующий модуль-блок данных недопустим, т.к.
C не все составляющие /greatlakes/ специфицированы.
C
BLOCK DATA GrLaks
COMMON /greatlakes/ erie, huron, ontario, superior
DATA erie, huron, ontario, superior /1, 2, 4, 5/
END
Оператор CALL
------------ДЕЙСТВИЕ
Вызов и исполнение процедуры из другого программного модуля.
СИНТАКСИС
CALL <sub>[([<actuals>])]
Параметр
Описание
-------------- ------------------------------------------------------subr
Имя вызываемой и исполняемой процедуры.
actuals
Один или более необязательных фактических параметров.
Если указано более одного параметра, то они должны
разделяться
запятыми.
Каждый фактический параметр
может быть спецификатором альтернативного
возврата
(*<label>);
константой, переменной или выражением;
массивом; именем процедуры или внешней функции; именем
встроенной
функции,
которая
может
передаваться
как
параметр;
текстовой
константой
(константой
Холлерита).
ЗАМЕЧАНИЯ
Оператор CALL выполняется следующим образом:
1. вычисляются параметры, являющиеся выражениями;
2.
фактические
параметры связываются с соотвествующими им
формальными параметрами;
3. выполняется тело специфицированной процедуры;
4. управление возвращается в вызывающую процедуру, либо
в
указанный (конкретно) оператор, либо в оператор, следующий сразу за
оператором CALL.
Процедура может быть вызвана из любого программного модуля.
Количество
фактических
параметров в операторе CALL должно
совпадать с количеством формальных параметров в
соответствующем
операторе SUBROUTINE, если, однако, при объявлении процедуры не были
использованы атрибуты C и VARYING.
Если оператор STATEMENT содержит формальные
параметры,
то
оператор CALL, "ссылающийся" на эту процедуру, не должен включать
любые фактические параметры. Однако, за параметром <sub> должна
следовать пара круглых скобок.
Формальные параметры и соотвествующие им фактические параметры
должны иметь одинаковые типы
данных,
за
исключением
случаев
использования текстовых констант. Когда фактический параметр является
константой Холлерита, то необязательно, чтобы формальный параметр имел
тот же тип; он может быть типа INTEGER, REAL или LOGICAL.
Для всех параметров, передаваемых по ссылке (см. подразд.1.6.11,
где описана передача параметров по значению), компилятор предполагает,
что тип формального параметра совпадает с типом соответствующего
фактического параметра. Если тип формального параметра известен, то он
используется только для проверки того, что параметры имеют тот же тип
данных.
Если вызов подпрограммы указывается более одного раза в модуле
программы, компилятор выполняет проверку соответствия числа и типов
фактических параметров их числу и типам в каждом вызове.
Компилятор проверяет также соответствие количества
и
типа
фактических параметров, используемых в различных обращениях к одной и
той же процедуре, числу и типам формальных параметров. Если оператор
SUBROUTINE или оператор INTERFACE, который определяет процедуру,
находится в том же исходном файле, что и любое обращение к ней, то
компилятор
обеспечивает,
чтобы
все
фактические
параметры
согласовывались с формальными параметрами процедуры. Если параметры не
согласованы, то результаты выполнения программы будут неопределены и
непредсказуемы.
ПРИМЕЧАНИЕ
При передаче логических и целочисленных параметров следует быть
особенно осторожным и убедиться в том, что параметры согласованы.
Установка метакоманды $STORAGE влияет на то, каким образом передаются
целочисленные и логические параметры. Когда действительно значение по
умолчанию
($STORAGE:4),
все
фактические
параметры, являющиеся
целочисленными
или
логическими
константами
или
выражениями,
присваиваются временным переменным типа INTEGER*4 или LOGICAL*4. Если
действительна метакоманда $STORAGE:2, все фактические
параметры,
являющиеся целочисленными или логическими константами или выражениями,
присваиваются временным переменным типа INTEGER*2 или LOGICAL*2.
Для
передачи 2-х байтовых
целочисленных
параметров, когда
установлена метакоманда $STORAGE:4, или для передачи 4-х байтовых
целочисленных параметров, когда установлена метакоманда $STORAGE:2,
следует использовать встроенные метакоманды INT2
и
INT4
(см.
подразд.5.1.1).
Свойство
"альтернативного
возврата"
позволяет пользователю
специфицировать оператор, в который процедура должна
передавать
управление.
Для
использования этого свойства следует выполнить
следующее:
Шаг 1. В вызывающей процедуре выбрать операторы, в которые
пользователь предполагает передавать управление. Ввести метки этих
операторов (им должны предшествовать звездочки) в список фактических
параметров оператора CALL, например:
CALL INVERT(row, column, *100, *200, *500)
Шаг 2. В соответствующий оператор SUBROUTINE ввести звездочки для
формальных параметров, соответствующих фактическим параметрам меток
*<label> в операторе CALL, как например в следующем
операторе
SUBROUTINE:
SUBROUTINE INVERT (r, c, *, *, *)
Шаг 3. В процедуре должен быть указан по крайней мере один
оператор RETURN для каждого альтернативного возврата управления. В
качестве параметров этих операторов RETURN необходимо указать 1 для
оператора RETURN, который будет возвращать управление в
первую
операторную метку в операторе CALL, 2 для оператора RETURN, который
возвращает управление во вторую операторную метку оператора CALL и
т.д.
Например, если в программе, содержащей два оператора в шагах 1 и
2 (они показаны выше), достигнут оператор RETURN1, то управление
передается в оператор с меткой 100 в вызывающей процедуре. Если
достигнут оператора RETURN2, управление будет передано в метку 200;
при RETURN3 - управление передается в оператор с меткой 500. Если
достигнут оператор RETURN, для которого не указано никакого номера
(т.е. просто RETURN), или оператор RETURN, для которого соотвествующей
метки возврата не указано (для данного примера это может быть оператор
RETURN4),
то
управление
возвращается в оператор, следующий в
вызывающей процедуре сразу за оператором CALL.
Следует отметить также, что в языке ФОРТРАН фирмы Microsoft не
поддерживается
возможность
организации
рекурсивных
вызовов
подпрограмм.
ПРИМЕРЫ
.
.
.
IF (ierr .NE. 0) CALL Error (ierr)
END
C
200
SUBROUTINE Error (ierrno)
WRITE (*, 200) ierrno
FORMAT (1X, 'error', I5, 'detected')
END
C
В данном примере иллюстрируется свойство альтернативного возврата:
1 CALL Boomerang (count, *10, j, *20, *30)
WRITE (*, *) 'normal return'
GOTO 40
10 WRITE (*, *) 'return to 10'
GOTO 40
20 WRITE (*, *) 'return to 20'
GOTO 40
30 WRITE (*, *) 'return to 30'
40 CONTINUE
.
.
.
SUBROUTINE Boomerang (i, *, j, *, *)
IF (i .EQ. 10) RETURN 1
IF (i .EQ. 20) RETURN2
IF (i .EQ. 30) RETURN3
RETURN
Оператор CASE
------------ДЕЙСТВИЕ
Выполняется маркировка начала блока исполняемых операторов,
элемент в списке выражений соответствует тестовому выражению.
если
СИНТАКСИС
CASE {DEFAULT│(<expressionlist>)}
<statementblock>
Параметр
-------------DEFAULT
expressionlist
statementblock
Описание
-----------------------------------------------------Ключевое слово, указывающее на то, что следующий блок
операторов исполняется, если ни одно из выражений ни в
одном из других операторов CASE не соответствует
тестовому выражению в операторе SELECT CASE.
Список значений и диапазонов значений, которые должны
быть
константными
и соответствовать типу данных
тестового выражения в операторе SELECT CASE. Значения
могут иметь тип INTEGER, LOGICAL или CHARACTER*1. Если
тестовое выражение соответствует одному из значений,
то исполняется следующий блок операторов.
Один или более исполняемых операторов. Блок может быть
также пустым.
ЗАМЕЧАНИЯ
Оператор CASE может присутствовать только внутри конструкции
SELECT CASE...END CASE.
Имеется два способа включения значений в список <expressionlist>.
Прежде всего задается список индивидуальных значений, разделенных
запятыми. Затем
специфицируется
включающий
диапазон
значений,
разделенных двоеточиями, например 5:10. Если опущена нижняя граница
(например, :10), то согласуются все значения, меньшие или равные
верхней границе. Если опущена верхняя граница (например 5:), то
согласуются все значения, большие или равные нижней границе. Диапазоны
печатаемых символов ASCII также могут быть включены. И индивидуальные
значения и диапазоны значений могут быть включены в один и тот же
список <expressionlist>. Пользователь не может задавать диапазон
значений,
когда тестовое выражение имеет тип LOGICAL. Заданное
значение может появляться только в одном списке <expressionlist>.
В
блоке
statementblock
не
является обязательным наличие
исполняемых операторов. Пустые блоки могут использоваться для задания
того, чтобы действия для некоторой группы значений выражения не
выполнялись.
Оператор CASE DEFAULT является необязательным. В блоке SELECT
CASE может указываться только один оператор CASE DEFAULT.
Если значение тестового выражения не соответствует ни одному
значению в любом списке <expressionlist>, то исполнение передается за
пределы конструкции SELECT CASE в следующий исполняемый оператор.
ПРИМЕР
CHARACTER*1 cmdchar
SELECT CASE (cmdchar)
CASE ('0')
WRITE (*, *) "Must retrieve one to nine files"
CASE ('1':'9')
CALL RetrieveNumFiles (cmdchar)
CASE ('A', 'd')
CALL AddEntry
CASE ('D', 'd')
CALL DeleteEntry
Case ('H', 'h')
CALL Help
CASE ('R':'T', 'r':'t')
WRITE (*, *) "REDUCE, SPREAD and TRANSFER commands ",
+
"not yet supported"
CASE DEFAULT
WRITE (*, *) "Command not recognized; please reenter"
END SELECT
СМОТРИ ТАКЖЕ
Конструкция SELECT CASE...END SELECT.
Оператор CHARACTER
-----------------ДЕЙСТВИЕ
Специфицирует, что имена, определенные
символьный тип данных, т.е. тип CHARACTER.
пользователями,
СИНТАКСИС
CHARACTER[*<chars>]<vname>[[<attrs>]][*<length>][(<dim>)]
имеют
[/<values>/][,<vname>[[<attrs>]][*<length>][(*<dim>)]]
[/<values>/]...
Последовательность
обратной.
Параметр
-----------chars
vname
attrs
dim
length
values
параметров
<dim>
и
<length>
может
быть
Описание
-------------------------------------------------------Целая константа без знака в диапазоне значений от 1 до
32.767; целочисленное константное выражение (вычисляемое
со значением от 1 до 32.767) в круглых скобках; либо
звездочка (*) в круглых скобках. Параметр chars задает
длину, в символах, элемента, задаваемого оператором
CHARACTER. Это значение может быть заменено параметром
<length>.
Символическое
имя
константы,
переменной, массива,
внешней функции, операторной функции или встроенной
функции; либо функциональная подпрограмма или описатель
массива.
Параметр <vname> не может быть именем процедуры или
головной программы.
Список атрибутов, разделенных запятыми. Параметр <attrs>
описывает
имя
<vname>.
Для
имени
<vname>
могут
использоваться
следующие
атрибуты:
АLIAS,
ALLOCATABLE,
C,
EXTERN, FAR, HUGE, NEAR, PASCAL,
REFERENCE, VALUE.
Необязательный
описатель
размерности.
Специфицируя
параметр
<dim>,
пользователь
тем самым объявляет
<vname> как имя массива.
Целочисленная константа без знака в диапазоне от 1
до
32.767,
выражение
целочисленной
константы
(результатом вычисления которого является целое число в
диапазоне от 1 до 32.767), заключенное в скобки, или
звездочка в скобках (*). Параметр <length> специфицирует
длину
имени <vname> в байтах, которое указывается
непосредственно перед ним. Это значение, если
оно
указано, заменяет значение длины, указанное в параметре
<bytes>;
Список констант и повторяющихся констант, разделенных
занятыми. Повторяющиеся константы записываются в виде
n*<constant>,
где
n
есть положительная ненулевая
целочисленная константа; она эквивалентна
константе
<constant>, повторенной n раз. Параметр /<values>/, если
он
специфицирован, устанавливает начальные значения
для <vname>. Следующий оператор, например, объявляет
word как переменную символьного типа и устанавливает для
нее значение, равное 'start':
CHARACTER*5
word
/'start'/
ЗАМЕЧАНИЯ
Оператор CHARACTER подтверждает или
заменяет
тип,
неявно
устанавливаемый для <vname>. Имя <vname> определяется для всего
программного модуля и не может быть определено любым другим оператором
типа в данном программном модуле.
Звездочка ( (*)), указанная как спецификатор длины, указывает,
что
значение длины специфицируется в любом месте (программного
модуля).
Применение спецификатора длины в виде звездочки допустимо в
следующих случаях:
- символьные константы, определяемые операторами
PARAMETER.
Фактическая длина определяется длиной символьной строки, присвоенной
параметру;
- формальные символьные параметры. Фактическая длина определяется
длиной фактического параметра;
- символьные функции, на которые есть ссылки в одной функции и
которые специфицированы с определенным значением длины в том же
программном модуле.
Если не заданы ни <chars> ни <length>, то
по
умолчанию
принимается значение длины, равное 1.
Операторы CHARACTER
должны
предшествовать всем исполняемым
операторам.
ПРИМЕРЫ
CHARACTER wt*10, city*80, ch
CHARACTER name (10)*20, eman*20(10)
CHARACTER*20 tom, dick, harry*12, tarzan, jane*34
Оператор CLOSE
-------------ДЕЙСТВИЕ
Используется для "отключения" специфицированного устройства
предотвращения выполнения на нем последующих операций ввода/вывода.
и
СИНТАКСИС
CLOSE([UNIT=]<unitspec>
[,ERR=<errlabel>]
[,IOSTAT=<iocheck>]
[,STATUS=<status>])
Если опущен параметр UNIT=, то <unitspec> должен быть первым
параметром. Параметры могут указываться в любой последовательности.
Параметр
-------------unitspec
errlabel
iocheck>
Описание
-----------------------------------------------------Целочисленное
выражение,
специфицирующее
внешнее
устройство. Ошибок не возникает, если устройство не
является открытым.
Метка исполняемого оператора в том же программном
модуле, где указан данный оператор. Если параметр
<errlabel> указан, то
при
возникновении
ошибки
ввода/вывода
управление
передается в оператор с
меткой <errlabel>. Если параметр <errlabel> опущен,
то при возникновении ошибки ввода/вывода генерируется
сообщение об ошибке этапа исполнения.
Результаты
возникновения
ошибок
ввода/вывода
определяются
спецификацией параметра <iocheck>.
Целочисленная
переменная
или
элемент
массива,
определяемые со значением 0, если ошибок не произошло,
либо со значением положительного целого числа, если
имеет место ошибка (см. также подразд.3.2.6).
Символьное
выражение,
которое
вычисляется
со
значением
либо 'KEEP', либо 'DELETE' для файлов,
открытых
как
рабочие
файлы; значение параметра
<status> по умолчанию принимается равным 'DELETE'.
При нормальном завершении программы рабочие файлы
обычно
удаляются;
спецификация
параметра
STATUS = 'KEEP' для рабочих файлов или временных
файлов обуславливает генерацию сообщений об ошибках
этапа
исполнения.
Для
всех
файлов
значение
параметра <status>, принимаемое по умолчанию, равно
'KEEP'.
status
ЗАМЕЧАНИЯ
Открытые файлы не обязательно
могут
быть
закрыты
явно.
ФОРТРАН-программы, при их нормальном завершении, будут закрывать
каждый файл (который они использовали во время исполнения)
со
значением состояния, принимаемым по умолчанию.
Закрытие нулевого устройства "отключает" нулевое устройство и
автоматически "переназначает" его на клавиатуру и экран. Закрытые
устройства с номерами 5 и 6 автоматически переназначает эти устройства
на
клавиатуру
или
экран, соответственно. Закрытие устройства,
идентифицированного звездочкой (*), приводит к генерации сообщения об
ошибке этапа компиляции.
Если параметром оператора CLOSE является выражение, в котором
реализуется обращение к функции,
то
эта
функция
не
должна
обуславливать
выполнения
операторов ввода/вывода или встроенной
функции EOF, поскольку результат в этом будет непредсказуем.
ПРИМЕР
С Закрытие и "отбрасывание" файла:
CLOSE (7, STATUS = 'DELETE')
Оператор COMMON
--------------ДЕЙСТВИЕ
Обеспечивает возможность совместного использования области памяти
двумя и более программными модулями. Данные программные модули могут
выполнять обработку одних и тех же данных без передачи их как
параметров.
СИНТАКСИС
COMMON[/[<cname>][[<attrs>]]/]<nlist>[[,]/[<cname>][[<attrs>]]
/<nlist>]...
Параметр
---------cname
Описание
---------------------------------------------------------Необязательное имя общего блока. Если имя не задано, то
блок называется "пустым общим блоком". Если параметр
<cname> опущен, то все элементы списка <nlist> находятся в
пустом общем блоке.
attrs
nlist
Список
атрибутов,
разделенных
запятыми.
Атрибуты
описывают
имя <cname>. Для имен общих блоков могут
использоваться только атрибуты ALIAS, C, FAR, NEAR и
PASCAL.
Обязательный
список
имен переменных, имен
массивов
и
описателей
массивов,
разделенных
запятыми.
В
операторе
COMMON
не
могут
быть указаны имена
формальных параметров, имена
функций,
автоматические
переменные и размещаемые массивы. В каждом операторе
COMMON все переменные и массивы, указываемые в каждом
списке
<nlist>,
следующим
за именем общего блока,
объявляюся как существующие в этом общем блоке.
ЗАМЕЧАНИЯ
В
операторах
COMMON, специфицированных в одном и том же
программном модуле, имя общего блока может указываться многократно.
Список
элементов
в
конкретном общем блоке обрабатывается как
континуация списка предыдущего общего блока с таким же именем.
Рассмотрим следующий оператор COMMON:
COMMON
COMMON
COMMON
COMMON
COMMON
/ralph/
/
/
/ralph/
/jerry/
ed, norton, trixie
fred, ethel, lucy
audrey, meadows
mortimer, tom, mickey
melvin, purvis
Ниже показаны эквиваленты этим операторам COMMON:
COMMON /ralph/ ed, norton, trixie, audrey, meadows
COMMON /
/ fred, ethel, lucy, melvin, purvis
COMMON /jerry/ mortimer, tom, mickey
Все элементы общего блока должны быть только символьными или
только несимвольными элементами. В языке ФОРТРАН фирмы Microsoft
допускается использование элементов обоих типов в одном и том же общем
блоке.
В языке ФОРТРАН фирмы Microsoft в общем случае все переменные и
массивы (включая символьные переменные и массивы) начинаются
с
адресов, выровненных до четного количества байтов. Если единственная
(несимвольная) переменная имеет
нечетную
длину,
то
следующая
переменная в памяти (независимо от типа) начинается в следующем
"четном" адресе.
В данном случае, однако, имеются два исключения. В массиве
символьных переменных каждый элемент сразу следует за предшествующим
элементом, без учета четности или нечетности адресов. Внутри "общего"
блока символьная переменная, которая следует за следующей символьной
переменной, всегда
начинается
в
следующем
доступном
байте.
(Несимвольные переменные по-прежнему начинаются в четном байте).
Это может вызвать ряд проблем при использовании "общего" блока,
содержащего символьные переменные нечетной длины, в последовательность
которых "вставлены" несимвольные переменные.
Длина общего блока равна количеству байтов памяти, требуемой для
хранения всех элементов общего блока. Если несколько (независимых!)
программных модулей обращаются к одному и тому же поименованному
"общему" блоку, то общий блок должен быть специфицирован как имеющий
одинаковую длину в каждом из этих программных модулей. Пустые общие
блоки, однако, могут иметь для различных программных модулей различную
длину. Длина пустого общего блока есть максимальная длина блока для
любого программного модуля.
Переменная в общем блоке не может быть инициализирована в
операторе
DATA, если, однако, оператор DATA не является частью
модуля-блока данных. В языке ФОРТРАН фирмы Microsoft переменные общего
блока могут быть инициализированы в оператором
DATA
в
любом
программном блоке.
Элемент,
присутствующий
в
списке <nlist>, не может быть
инициализирован в операторе типа. Следующий пример
приводит
к
возникновению ошибки:
INTEGER i /1/
COMMON i
ПРИМЕР
PROGRAM MyProg
COMMON i, j, x, k(10)
COMMON /mycom/ a(3)
.
.
.
END
SUBROUTINE MySub
COMMON pe, mn, z, idum(10)
COMMON /mycom/ a(3)
.
.
.
END
Оператор COMPLEX
---------------ДЕЙСТВИЕ
Указывает, что имена, специфицированные пользователем,
тип комплексный (COMPLEX).
имеют
СИНТАКСИС
COMPLEX[*<bytes>]<vname>[[<attrs>]][*<length>][(<dim>)]
[/<values>/][,<vname>[[<attrs>]][*<length>][(<dim>)]
[/<values>/]]...
(Последовательность указания параметров <length>
быть обратной).
Параметр
-----------bytes
vname
и
<dim>
может
Описание
-------------------------------------------------------Должен иметь значение, равное 8-и или 16-и. Параметр
<bytes> специфицрует длину элемента байтах, указываемого
в операторе COMPLEX. Это значение может быть заменено
значением параметра <length>.
Обязательное
символическое имя константы, переменной,
массива,
внешней
функции,
операторной
функции,
встроенной функции;
либо
функциональная
программа
или описатель массива; <vname> не может быть именем
attrs
length
dim
values
процедуры или головной программы.
Необязательный список атрибутов, разделенных запятыми.
Параметр <attrs> описывает <vname>. Для имени <vname>
могут использоваться следующие атрибуты: ALIAS,
C,
EXTERN, FAR, HUGE, NEAR, PASCAL, REFERENCE, VALUE.
Присваивает значение длины <length> имени
<vname>.
Значениями параметра <length> должны быть 8 или 16.
Если параметр <length>
указан,
то
его
значение
заменяет значение длины атрибута,
специфицированное
параметром <bytes>.
Описатель
размерности.
Параметр
<dim> указывается
только в том случае, если <vname> есть имя массива.
Если
параметр
<dim>
указан, то оператор COMPLEX
объявляет массив с именем <vname>.
Список констант и повторяющихся констант, разделенных
запятыми.
Повторяющиеся
константы
записываются
в
форме n*<constant>, где n есть положительная ненулевая
целочисленная
константа,
эквивалентная
константе
<constant>, повторенной n раз. Параметр /<values>/,
если он указан, инициализирует
<vname>.
Следующий
оператор, например,
объявляет,
что
vector
имеет
комплексный тип, и устанавливает vector в значение
(32.0,10.0):
COMPLEX vector / (32.0,10.0) /
ЗАМЕЧАНИЯ
Оператор COMPLEX подтверждает или заменяет неявно объявленный тип
для <vname>. Имя <vname> определяется для всего программного модуля и
не может быть определено любым другим оператором в том же программном
модуле.
Оператор
COMPLEX
должен
предшествовать
всем
исполняемым
операторам.
Параметры DOUBLE COMPLEX и COMPLEX*16 представляют один и тот же
тип данных.
ПРИМЕР
COMPLEX ch, adif*8, xdif*16
COMPLEX*8 zz
COMPLEX*16 ax, by
COMPLEX x*16, y(10)*8, z*16(10)
Оператор CONTINUE
----------------ДЕЙСТВИЕ
Никакого действия не выполняется.
СИНТАКСИС
CONTINUE
ЗАМЕЧАНИЯ
Оператор CONTINUE используется в основном как "удобная точка" для
указания операторной метки, в частности, как терминальный
оператор
DO-цикла или WHILE-цикл для того, чтобы избежать окончания цикла
операторами управления.
В этом случае он должен быть помечен. Оператор, следующий за
оператором CONTINUE, получает управление в том случае, если выход из
тела цикла происходит при анализе действий управляющих операторов и
текущего значения управляющей переменной.
ПРИМЕР
100
DEMENSION narray(1O)
DO 100, n = 1, 10
narray(n) = 120
CONTINUE
Оператор CYCLE
-------------ДЕЙСТВИЕ
Внутри цикла передает управление на терминальный оператор DO- или
WHILE-цикла.
СИНТАКСИС
CYCLE
ЗАМЕЧАНИЯ
Оператор CYCLE выполняет переход через оставшуюся часть циклов DO
или WHILE. Путем объединения оператора CYCLE с логическим оператором
IF пользователь может управлять исполнением программного кода.
ПРИМЕРЫ
Предположим необходимо напечатать таблицу релятивистских факторов
для каждого значения скорости от 0 до значения скорости света с шагом
100км/сек. В следующем примере вычисляемые факторы помещаются в массив
timedilation. Для печати используется оператор WRITE.
INTEGER sub
!subscript for timedilation array
REAL timedilation(0:300)
speedolight = 300000e3
;300000 km/sec.
speedstep = 100e3
;100 km/sec.
sub = speedolight / speedstep
DO velocity = 1, speedolight, speedstep
timedilation(sub) = 1.0
IF (velocity .LT. (0.1 = speedolight) CYCLE
timedilation(sub) = 1.0
+
1.0 / SQRT (1.0 - (velocity speedolight)**2)
END DO
Оператор DATA
------------ДЕЙСТВИЕ
Назначает переменным начальные значения.
СИНТАКСИС
DATA<nlist>/<clist>/[[,]<nlist> /<clist>/]...
Параметр
Описание
----------- ---------------------------------------------------------nlist
Список имен переменных, элементов массива, имен массивов,
имен подстрок и списков встроенных операторов DO. Каждое
индексное
выражение
в
списке
<nlist> должно быть
константным выражением, исключая
случай
использования
переменных встроенных DO-операторов. Каждое
выражение
подстроки в списке <nlist>
должно
быть
выражением
целочисленной константы;
clist
Список констант и/или повторяющихся констант
и/или
текстовых констант (констант
Холлерита),
разделенных
запятыми. Повторяющаяся константа записывается в
форме
n*e, где
фактор
повторения
n
есть
положительная
ненулевая целочисленная константа, а e - есть повторяемая
константа.
Например,
повторяющаяся
константа
3*10
эквивалентна следующему списку <clist>: 10, 10,
10.
Фактор
повторения,
за
которым
следует
константа,
эквивалентен
списку
всех
констант,
имеющих
специфицированное значение
и повторенных столько раз,
сколько указано в повторяющейся константе.
Константа Холлерита записывается в форме nH<data>, где n
есть
положительная ненулевая целочисленная константа,
а <data> есть строка из n символов.
Количество
значений
в
каждом
списке
<clist>
должно
совпадать
с
количеством
переменных
или
элементов
массива
в
соответствующем
списке <nlist>. Присутсвие в списке <nlist>
массива
эквивалентно
указанию
в этом списке всех элементов
массива.
Индексация
элементов массива осуществляется
только с помощью постоянных индексов.
ЗАМЕЧАНИЯ
Структурные
переменные
и переменные, явно объявленные как
автоматические, могут не присутствовать в операторах DATA. Однако,
структурные элементы могут появляться в операторах DATA.
Для каждого несимвольного элемента в списке <clist> выполняется
операция преобразования к типу данных соответствующего элемента в
списке <nlist>.
Если длина символьного элемента в списке <clist> меньше, чем
длина переменной или элемента массива, то он расширяется до длины
переменной путем добавления символов пробела справа. Если символьный
элемент длиннее переменной или элемента массива, то он усекается.
Единственная символьная константа определяет одну переменную или один
элемент массива. Фактор повторения не может быть использован.
Если не задана метакоманда $STRICT, то символьный элемент в
списке <clist> может инициализироваться переменной любого типа.
В операторе DATA могут указываться только локальные переменные и
элементы массивов (если оператор DATA не используется в модуле-блоке
данных). С помощью оператора DATA нельзя назначать начальные значения
формальным параметрам, переменным в пустых "общих" блоках и именам
функций. Элементам в поименованных общих блоках могут быть назначены
начальные
значения
с
помощью
оператора DATA, указываемого в
модуле-блоке данных.
Список встроенных DO-операторов имеет следующий формат:
(<dolist>,<dovar> = <start>,<stop>[,<inc>])
где <dolist> - список имен элементов массива и списков встроенных
операторов DO;
<dovar> - имя
целочисленной переменной, называемой "переменной
встроенного оператора DO";
<start>, <stop>, <inc> - целочисленные константы выражения.
Каждое выражение может содержать переменные встроенных
операторов
DO (<dovar>) другого списка встроенных
операторов DO, который "находится внутри диапазона
данного списка встроенных операторов DO".
Например, следующий фрагмент представляет собой списки встроенных
DO-операторов:
(count(i), i = 5, 15, 2)
((array(sub,low), low = 1, 12), sub = 1, 2)
((resul(first,second), first = 1, max), second = 1, upper)
Шаг итерации и значения переменной встроенного оператора DO
устанавливаются в зависимости от значений параметров <start>, <stop> и
<inc> как для обычного DO-цикла, за тем исключением, что шаг итерации
должен быть положительным. Когда список встроенных DO-операторов
указывается в операторах DATA, тогда элементы списка в <dlist>
инициализируются один раз для каждой итерации списка встроенных
операторов DO. Диапазон списка встроенных DO-операторов есть <dlist>.
Если программа содержит другую переменную с тем же именем, что и
<dovar>, то использование <dovar> в операторе DATA "не влияет" на эту
переменную.
ПРИМЕР
INTEGER n, order, alpha, list(100)
REAL coef(4), eps(2), pi(5), x(5,5)
CHARACTER*12 help
DATA n /0/, order /3/
DATA alpha /'A'/
DATA coef /1,0, 2*3.0, 1.0/, eps(1) /.00001/
C
С
В следующем примере инициализируется значение диагонали
в матрице размером 5*5
DATA ((x(j,i), i=1,j), j=1,5) /15*1.0/
DATA pi /5x3.14159/
DATA list /100*0/
DATA help (1:4), help (5:8), help (9:12)/3*'HELP'/
Оператор DEALLOCATE
------------------ДЕЙСТВИЕ
Освобождение области памяти, ранее зарезервированной
при
помощи
оператора ALLOCATE.
СИНТАКСИС
DEALLOCATE(<arraylist>[,STAT = <ierr>])
Параметр
Описание
----------- ---------------------------------------------------------arraylist Список имен размещаемых массивов; если
указано несколько
имен, то они разделяются запятыми.
ierr
Целочисленная
переменная,
возвращающая статус попытки
переразмещения.
ЗАМЕЧАНИЯ
Попытка переразместить массив, который не был ранее размещен,
приводит к возникновению ошибки этапа исполнения.
Любая ошибка при переразмещении вызывает ошибку этапа исполнения,
если, однако, не указан параметр STAT=. Переменная <ierr> возвращает
значение 0, если операция переразмещения была выполнена успешно; в
противном случае возвращается номер ошибки этапа исполнения.
Если на размещаемый массив задается ссылка в тот момент, когда он
не является размещенным, результаты могут оказаться непредсказуемыми.
ПРИМЕР
INTEGER dataset[ALLOCATABLE] (:,:,:)
INTEGER reactor, level, points, error
DATA reactor, level, points /10, 50, 10/
ALLOCATE (datase(1:reactor,1:level,1:points), STAT = error)
DEALLOCATE (datase, STAT = error)
Оператор DIMENSION
-----------------ДЕЙСТВИЕ
Специфицирует имя, которое является именем массива, и
количество измерений и границы массива.
определяет
СИНТАКСИС
DEMENSION <array>[[<attrs>│]({[<lower>:]<upper>│:}
[,{[<lower>:]<upper>│:}...])
Параметр
----------array
attrs
lower
Описание
--------------------------------------------------------Имя массива. В одном операторе DIMENSION может быть
объявлено
несколько
массивов.
При
этом их имена
разделяются запятыми.
Список атрибутов, разделенных запятыми. Атрибуты <attrs>
описывают массив <array>. Для массива <array> могут быть
заданы следующие атрибуты: ALIAS, C, EXTERN, FAR, HUGE,
NEAR, RASCAL, REFERENCE, VALUE, ALLOCATABLE.
Нижняя
граница
размерности
массива;
может
быть
положительной,
отрицательной
или 0.
По
умолчанию
upper
принимается значение 1.
Верхняя граница размерности массива, которая может быть
положительной, отрицательной, 0 или звездочка. Верхняя
граница может быть больше или равна
нижней границе.
ЗАМЕЧАНИЯ
Спецификатор <array> ([<lower>:]<upper>│:│) также
называется
"спецификатором массива" (или "описателем размерности"). Спецификатор
[<lower>:]<upper>
или спецификатор : называется
"спецификатором
размерности".
Количество
измерений
в массиве равно количеству
специфицированных
описателей
размерности.
Пользователь
может
специфицировать не более семи измерений массива. В языке ФОРТРАН фирмы
Microsoft число измерений массива и их размер ограничены только
доступной областью памяти.
Когда массив специфицируется как размещаемый, то спецификатор
размерности состоит только из двоеточия для каждой размерности.
Единственный спецификатор в виде двоеточия может использоваться только
тогда, когда массив специфицирован как размещаемый.
Целесообразным представляется спецификация и верхней и нижней
границ размерности. Если, например, один массив содержит данные из
диапазона от 28 до 112, то массив "может быть измерен" следующим
образом:
DIMENSION exprmt (28:112)
Затем, для получения данного под номером 72, достаточно указать:
exprmt (72)
Пользователь
размерности:
может
использовать
любые
из
следующих
границ
Границы
------------------Арифметическая
константа
Описание
------------------------------------------------Если все измерения массива специфицированы при
помощи арифметических констант, то массив будет
иметь постоянный размер. Арифметическое выражение
"преобразуется" к целочисленному значению.
Целочисленный
формальный параметр,
не являющийся массивом, или целочисленная переменная,
не являющаяся массивом, в том же
программном модуле,
что и оператор
DIMENSION
Размерность определяется как начальное значение
переменной
при вводе в программу во
время
исполнения (на этапе исполнения). Если границей
размерности массива <array> является целочисленный формальный параметр или целочисленная переменная в общем блоке, то массив является "массивом настраиваемого размера". Переменной должно быть задано значение до того, как будет вызвана подпрограмма, содержащая "массив настраиваемого размера".
Звездочка
Звездочкой может быть идентифицирована только
верхняя граница размерности; звездочка
может
использоваться для идентификации верхней границы
размерности только для последней
размерности
массива <array>. Если <upper> есть звездочка,
тогда
массив
<array>
является
"массивом
предполагаемого
размера".
Для
"массива
предполагаемого
размера"
массив подпрограммы
определяется на этапе исполнения, для того, чтобы
его размер совпадал с
размером
массива
в
вызывающей
программе.
Следующий
оператор
DIMENSION определяет в
подпрограмме
"массив
предполагаемого размера":
DIMENSION data (19,*)
Арифметическое
выражение
На этапе исполнения массив data "получит размер",
соответствующий массиву в вызывающей программе.
Выражения не могут содержать ссылок (указателей)
на функции или элементы массивов.
Выражения
могут содержать переменные только в массивах
настраиваемого
размера.
Результат
выражения
"преобразуется" к виду целочисленного значения.
ЗАМЕЧАНИЯ
Внутри несимвольных массивов все элементы начинаются с адреса
(слова), выровненного по четной границе байтов. Внутри символьных
массивов (и массивов переменных типа INTEGER*1 или LOGICAL*1) элементы
всегда начинаются в следующем доступном байте (четном или нечетном).
Все массивы "настраиваемого" и "предполагаемого" размера должны
быть также формальными параметрами программного модуля, в котором они
указаны. Размещаемые массивы не должны быть формальными массивами.
Элементы массива сохраняются в "последовательности возрастания
столбцов",
т.е.
вначале
увеличивается самый левый индекс при
отображении массива на непрерывную последовательность адресов памяти.
Рассмотрим, например, следующие операторы:
INTEGER*2 a (2, 0:2)
DATA a /1, 2, 3, 4, 5, 6/
Если a помещается в ячейку памяти
обуславливают следующее отображение:
Элемент массива
--------------a (1, 0)
a (2, 0)
a (1, 1)
a (2, 1)
a (1, 2)
a (2, 2)
Адрес
----1000
1002
1006
1008
100A
1000, то данные операторы
Значение
-------1
2
4
5
6
ПРИМЕР
В следующем примере определены два массива:
DIMENSION a(2, 3), v(10)
CALL Subr (a, 2, v)
.
.
.
SUBROUTINE Subr (matrix, rows, vector)
REAL MATRIX, VECTOR
INTEGER ROWS
+
DIMENSION MATRIX (ROWS, *), VECTOR (10),
LOCAL (2, 4, 8)
MATRIX (1,1) = VECTOR (5)
.
.
.
END
Оператор DO
----------ДЕЙСТВИЕ
Предназначен для многократного выполнения операторов,
за оператором DO, до оператора с меткой <label>.
следующих
СИНТАКСИС
DO [<label>[,]]<dovar>=<start>,<stop>[,<inc>]
Параметр
Описание
------------- -------------------------------------------------------label
Операторная метка исполняемого оператора.
dovar
Переменная типа
целый, вещественный или с двойной
точностью, называемая "DO-переменная".
start, stop Выражения
типа
целый, вещественный или с двойной
точностью.
inc
Необязательное выражение типа целый, вещественный или
с двойной точностью. Параметр <inc> не может быть равен
0; по умолчанию значение параметра <inc> равно 1.
ЗАМЕЧАНИЯ
Метка <label> является необязательной. Если она используется, то
цикл завершается помеченным оператором. Если метка не используется, то
цикл завершается оператором END DO.
Метка <label> должна
указываться
после
оператора
DO
и
присутствовать в том же программном модуле. Оператор, отмеченный
меткой <label>, называется "терминальным" оператором (или закрывающим
оператором) DO-цикла и не должен быть безусловным оператором GOTO,
"присваиваемым" оператором GOTO (иначе: оператором
перехода
по
предписанию), арифметическим или блочным оператором IF, CASE, CYCLE,
DO, ELSE, ELSE IF, END, ENDIF, END SELECT CASE, EXIT, RETURN, SELECT
CASE или STOP.
Терминальным оператором может быть логический оператор IF.
Тело
DO-цикла начинается с оператора, следующего сразу за
оператором DO, и заканчивается (включительно!) терминальным оператором
DO-цикла.
Выполнение оператора CALL, находящегося в теле DO-цикла, не
приводит к его прерыванию, за исключением случая, когда возврат
осуществляется при помощи спецификатора возврата в операторе CALL к
оператору, находящемуся вне тела DO-цикла.
На выполнение оператора DO влияют следующие ограничения:
- если оператор DO указан в теле другого DO-цикла, его тело может
полностью содержаться внутри тела включающего DO-цикла, хотя циклы
"могут использовать" один терминальный оператор;
- если оператор DO указан внутри блоков IF, ELSEIF или ELSE, то
тело DO-цикла должно полностью содержаться в блоке;
- если блочный оператор IF указывается внутри тела DO-цикла, то
связанный с ним оператор ENDIF должен указываться внутри тела этого
цикла DO;
- DO-переменная <dovar> не может быть модифицирована операторами,
находящимися внутри тела DO-цикла, ассоциированного с ней;
- переход в тело DO-цикла из-вне тела цикла не разрешен. Однако,
специальное свойство, добавленное для обеспечения совместимости с
ранними версиями компилятора языка ФОРТРАН, позволяет использовать
DO-циклы с "расширениями" (см. подразд.6.2, где описана метакоманда
$DO66);
- два или более циклов DO или DO WHILE могут
совместно
использовать один помеченный терминальный оператор. Оператор END DO
может прерывать выполнение только одного цикла DO или DO WHILE;
- если оператор SELECT CASE появляется внутри DO-цикла, то
ассоциированный
с
ним
оператор END SELECT CASE должен также
присутствовать внутри этого DO-цикла.
Следует отметить, что число
итераций
DO-цикла
ограничено
точностью арифметики, используемый для его вычисления. Например,
DO-циклы, которые используют переменные типа INTEGER*2 в качестве
DO-переменных и границ массива не могут быть вычислены более чем
32.767 раз. Если установлена метакоманда $DEBUG, то при переполнении
DO-переменной,
будет
сгенерировано
сообщение
об ошибке. Если
метакоманда $DEBUG не установлена, то результаты могут оказаться
непредсказуемыми.
Например,
в
следующем
программном фрагменте
количество итераций составляет 64.001, а DO-переменная i может быть
вычислена только 32.767 раз:
$DEBUG
С Этот фрагмент обуславливает возникновение ошибки:
INTEGER*2 i
DO 10 i = - 32000, 32000, 1
10 CONTINUE
При
выполнении
оператора
DO
выполняется
следующая
последовательность шагов:
Шаг
1.
Вычисляются выражения <start>, <stop>, <inc>. При
необходимости выполняется операция преобразования типов. DO-переменная
<dovar> устанавливается в значение <start>.
Шаг 2. Проверяется счетчик итераций цикла. Он
вычисляется
следующим образом:
MAX (INT((<stop> - <start> + <inc>) /<inc>), 0)
Счетчик повторений равен нулю всякий раз, когда:
start > stop и inc > 0
или
start > stop и inc < 0
Шаг 3. Если счетчик повторений больше нуля, то операторы в теле
DO-цикла
начинают
выполняться;
если
нет,
то
выполнение
продолжается с первого оператора, следующего после DО-цикла.
Следует отметить, что если действительна метакоманда $DO66, то
операторы в теле DO-цикла исполняются по крайней мере один раз,
независимо от значения счетчика повторений.
Шаг 4. После выполнения оператора завершения DO-цикла, значение
переменной <dovar>
увеличивается
на
значение
вычисляется при выполнении оператора DO.
Шаг 5. Счетчик повторений увеличивается на 1.
Шаг 6. Проверяется счетчик повторений. Если его
0, то операторы в теле цикла выполняются повторно.
<inc>,
значение
которое
больше
ПРИМЕЧАНИЕ
Счетчик повторений вычисляется с использованием двухбайтовой
точности (по умолчанию). Если счетчик "переполняет" эту точность, то
результаты становятся непредсказуемыми. Следующий пример генерирует
ошибку этого типа:
IMPLICIT INTEGER*2 (A-2)
stop = 32000
step = 12000
DO 100 n = 0, stop, step
WRITE (*, *) 'N = ', n
100 CONTINUE
ПРИМЕРЫ
Следующие два программных фрагмента являются примерами операторов
DO:
С Инициализация четных элементов 20-и элементного
С массива вещественных чисел
DIMENSION array(20)
DO 100 j = 2, 20, 2
100 array(j) = 12.0
С Выполнение функции 11 раз
DO 200, k =-30, -60, -3
int = j / 3
isb = -9 -J
array(isb) = MyFunc (int)
200 CONTINUE
Ниже показано конечное значение DO-переменной:
С Отображение на экране чисел от 1 до 11:
DO 200 j = 1, 10
200 WRITE (*, '(I5)') j
WRITE (*, '(I5)') j
Оператор DO WHILE
----------------ДЕЙСТВИЕ
Исполнение блока операторов при истинности логического условия.
СИНТАКСИС
DO [<label>[,] WHILE (<logicalexpr>)
Параметр
Описание
----------label
logicalexpr
--------------------------------------------------------Метка исполнительного оператора или оператора CONTINUE.
Тестовое выражение, вычисляемое со значением "истина" или
"ложь".
ЗАМЕЧАНИЯ
Метка <label> является необязательной. Если <label> используется,
то цикл завершается
помеченным
оператором.
Если
<label>
не
используется, то цикл завершается оператором END DO.
Терминальный оператор должен следовать за оператором DO WHILE и
находиться в том же самом программном модуле. Этот оператор не должен
быть безусловным или присваиваемым оператором GOTO, блочным или
арифметическим оператором IF, CASE, CYCLE, DO, ELSE, ELSE IF, END, END
IF, END SELECT CASE, EXIT, RETURN, SELECT CASE или STOP.
Терминальный оператор может быть логическим оператором IF.
Тело цикла DO WHILE начинается с оператора, следующего сразу за
оператором DO WHILE и заканчивается (включительно!) терминальным
оператором цикла DO WHILE.
Выполнение оператора CALL, находящегося в теле цикла DO WHILE, не
прерывает
его выполнение, за исключением случая, когда возврат
осуществляется при помощи спецификатора возврата в операторе CALL к
оператору, находящемуся вне тела цикла DO WHILE.
При
выполнении
оператора
DO
WHILE выполняется следующая
последовательность шагов:
Шаг 1. Вычисляется логическое выражение.
Шаг 2. Если выражение вычисляется со значением "ложь", то ни один
оператор внутри тела цикла не исполняется. Исполнение передается в
оператор, следующий за терминальным оператором.
Шаг 3. Если выражение "истинно", то операторы внутри цикла
исполняются, начиная с первого оператора, следующего за оператором DO
WHILE.
Шаг
4.
По
достижении
терминального оператора исполнение
возвращается в оператор DO WHILE. Вычисляется логическое выражение и
цикл повторяется.
На выполнение оператора DO WHILE влияют следующие ограничения:
- если цикл DO WHILE указан в теле другого цикла DO или DO WHILE,
его тело может полностью содержаться внутри тела включающего цикла;
два или более циклов DO или DO WHILE могут совместно
использовать один помеченный терминальный оператор. Оператор END DO
может прерывать выполнение только одного цикла DO или DO WHILE;
- если оператор DO WHILE указан внутри блоков IF, ELSEIF или
ELSE, то тело цикла DO WHILE должно полностью содержаться в блоке;
- если блочный оператор IF указывается внутри цикла DO WHILE, то
связанный с ним оператор END IF должен указываться внутри тела этого
цикла DO WHILE;
- если оператор SELECT CASE появляется внутри цикла DO WHILE, то
ассоциированный
с
ним
оператор END SELECT CASE должен также
присутствовать внутри этого цикла DO WHILE.
- переход в тело цикла DO WHILE из-вне тела цикла не разрешен.
Однако,
специальное
свойство,
добавленное
для
обеспечения
совместимости с ранними версиями компилятора языка ФОРТРАН, позволяет
использовать DO-циклы с "расширениями" (см. подразд.6.2, где описана
метакоманда $DO66).
ПРИМЕР
CHARACTER*1 input
input = ' '
DO WHILE ((input .NE. 'n') .AND. (input .NE. 'y'))
WRITE (*, '(A)') 'Enter y or n: '
READ (*, '(A)') input
END DO
Оператор DOUBLE COMPLEX
----------------------ДЕЙСТВИЕ
Спецификация
пользователем.
типа
DOUBLE
COMPLEX
для
имен,
определенных
СИНТАКСИС
DOUBLE COMPLEX <vname>[[<attrs>]][)<dim>)][/<values>/]
[,<vname>[[<attrs>]][(<dim>)][/<values>/]]...
Параметр
----------vname
attrs
dim
values
Описание
--------------------------------------------------------Символическое
имя
константы,
переменной,
массива,
внешней функции, операторной функции, встроенной функции,
подпрограммы FUNCTION или описатель массива. Параметр
<vname> не может быть
именем процедуры или головной
программы.
Список атрибутов, разделенных запятыми. Атрибуты <attrs>
описывают имя <vname>. Могут использоваться следующие
атрибуты: ALIAS, ALLOCATABLE, C, EXTERN, FAR, HUGE, NEAR,
PASCAL, REFERENCE, VALUE.
Спецификатор размерности. При задании параметра <dim>
имя <vname> специфицируется как имя массива.
Список констант и повторяющихся констант, разделенных
запятыми. Повторяющаяся константа записывается в формате
n*<constant>, где n есть положительная целая константа,
эквивалентная константе <constant>, повторенной n раз.
Опция /<values>/, если
она
задана,
инициализирует
параметр <vname>. В следующем примере оператор объявляет
vector с типом DOUBLE COMPLEX и устанавливает vector в
значение, равное (32.0,10.0):
DOUBLE COMPLEX vector / (32.798d2,
+10.985d3) /
ЗАМЕЧАНИЯ
Оператор DOUBLE COMPLEX устанавливает или заменяет неявный тип
переменной <vname>. Имя <vname> определяется для всего программного
модуля и не может быть описано любым другим оператором в заданном
программном модуле.
Операторы
DOUBLE
COMPLEX
должны
предшествовать
всем
исполнительным операторам.
Типы DOUBLE COMPLEX и COMPLEX*16 являются тождественными.
ПРИМЕР
DOUBLE COMPLEX vector, arrays(7,29)
DOUBLE COMPLEX
pi, 2pi
/3.141592654,6.283185318/
Оператор DOUBLE PRECISION
------------------------ДЕЙСТВИЕ
Специфицирует
DOUBLE PRECISION.
определенные
пользователем
имена как имеющие тип
СИНТАКСИС
DOUBLE PRECISION <vname> [[<attrs>]][<dim>][/<values>/]
[,<vname>[[<attrs>]][(<dim>)][/<values>/]]...
Параметр
----------vname
attrs
dim
values
Описание
--------------------------------------------------------Символическое
имя
константы,
переменной,
массива,
внешней функции, операторной функции, встроенной функции,
подпрограммы FUNCTION или описатель массива. Параметр
<vname> не может быть
именем процедуры или головной
программы.
Список атрибутов, разделенных запятыми. Атрибуты <attrs>
описывают имя <vname>. Могут использоваться следующие
атрибуты: ALIAS, ALLOCATABLE, C, EXTERN, FAR, HUGE, NEAR,
PASCAL, REFERENCE, VALUE.
Спецификатор размерности. При задании параметра <dim>
имя <vname> специфицируется как имя массива.
Список констант и повторяющихся констант, разделенных
запятыми. Повторяющаяся константа записывается в формате
n*<constant>, где n есть положительная целая константа,
эквивалентная константе <constant>, повторенной n раз.
Опция /<values>/, если
она
задана,
инициализирует
параметр <vname>. В следующем примере оператор объявляет
pi с типом DOUBLE PRECISION и устанавливает pi
в
значение, равное 3.141592654:
DOUBLE PRECISION pi / 3.141592654 /
ЗАМЕЧАНИЯ
Оператор DOUBLE PRECISION подтверждает или заменяет тип, неявно
определенный для имени vname. Имя vname определяется для всего
программного модуля и не может быть переопределено любым другим
оператором в том же программном модуле.
Операторы DOUBLE PRECISION должны предшествовать в программном
модуле всем исполняемым операторам.
Длина переменной типа DOUBLE PRECISION составляет 14 или 15
десятичных цифр.
Типы данных DOUBLE PRECISION и REAL*8 являются тождественными.
ПРИМЕР
С Пример оператора DOUBLE PRECISION
DOUBLE PRECISION varname
Оператор ELSE
------------ДЕЙСТВИЕ
Отмечает начало блока ELSE.
СИНТАКСИС
ELSE
ЗАМЕЧАНИЯ
Блок ELSE состоит из любых исполняемых операторов, указываемых
между оператором ELSE и последующим оператором END IF "на том же
уровне оператора IF", что и данный оператор ELSE. Соответствующий
оператор ENDIF должен указываться перед любыми операторами ELSE или
ELSEIF в том же операторе IF.
Передача управления в блок ELSE из-вне данного
блока
не
допускается.
ПРИМЕР
CHARACTER c
.
.
.
READ (*, '(A')C
IF (c .EQ. 'A') THEN
CALL Asub
ELSE
CALL Other
END IF
.
.
.
СМОТРИ ТАКЖЕ
Операторы ELSE IF, END IF, IF THEN ELSE (блок IF).
Оператор ELSE IF
---------------ДЕЙСТВИЕ
Вызывает выполнение блока операторов, если выражение <expression>
имеет значение "истина".
СИНТАКСИС
ELSE IF (<expression>) THEN
где <expression> - есть логичесоке выражение.
ЗАМЕЧАНИЯ
Ассоциированный
блок ELSE IF состоит из любых исполняемых
операторов, указываемых между оператором ELSE IF и
последующим
оператором ELSE IF, ELSE или END IF, на том же уровне вложенности
оператора IF.
При
исполнении
оператора
ELSEIF
вычисляется
выражение
<expression> и выполняются следующие шаги:
Если:
-------------------Выражение expression
имеет значение "истина", а в блоке ELSEIF
указан
по
крайней
мере один исполняемый
оператор
Тогда:
----------------------------------------------Следующий в блоке ELSEIF оператор исполняется
как первый оператор блока ELSEIF.
Выражение expression
имеет значение "истина", а в блоке ELSEIF
не указано исполняемых
операторов
Следующий
исполняемый
оператор
является
следующим
оператором
ELSEIF,
находящимся
на том же уровне в операторе IF, что и оператор
ELSE IF.
Выражение expression
имеет значение "лoжь"
Следующий
исполняемый
оператор
является
следующим оператором ELSE IF, ELSE или END IF,
указанным
на том же уровне оператора IF,
что и оператор ELSE IF.
После исполнения последнего оператора в блоке ELSE IF следующим
исполняемым оператором является следующий оператор END IF, указанный
на том же уровне оператора IF, что и данный оператор ELSE IF.
Передача управления в блоке ELSEIF из-вне данного блока не
допустима.
ПРИМЕР
CHARACTER char
READ (*, '(A)') char
IF (char .EQ. 'L') THEN
CALL Lsub
ELSE IF (char .EQ. 'X') THEN
CALL Xsub
ELSE
CALL Other
END IF
СМОТРИ ТАКЖЕ
Операторы ELSE, END IF, IF THEN ELSE (блок IF).
Оператор END
-----------ДЕЙСТВИЕ
Завершает выполнение головной программы. В подпрограмме действие
оператора END аналогично действию оператора RETURN, т.е. выполняется
возврат управления.
Оператор END всегда отмечает конец программного модуля в том
месте, где он указан.
СИНТАКСИС
END
ЗАМЕЧАНИЕ
Оператор END должен указываться как последний оператор каждого
программного модуля. За оператором END могут
следовать
строки
комментария.
Оператор END должен указываться в непомеченной начальной строке
(т.е. строке, не являющейся строкой продолжения) как единственный
оператор. После оператора
END
не
должны
указываться
строки
продолжения. Ни один оператор языка ФОРТРАН не может иметь начальную
строку, появляющуюся как оператор END.
ПРИМЕР
С Пример оператора END
С Оператор END должен быть последним оператором
С в программном модуле:
PROGRAMM MyProg
WRITE (*, "Hello, world!)")
END
Оператор END DO
--------------ДЕЙСТВИЕ
Прерывание циклов DO или DO WHILE.
СИНТАКСИС
END DO
ЗАМЕЧАНИЕ
Для каждого оператора DO или DO WHILE, не содержащего ссылку на
метку, должно выполняться соответствие оператора END DO.
Оператор END DO должен прерывать только один оператор DO или DO
WHILE.
ПРИМЕР
Результаты следующих двух примеров будут одинаковыми:
DO ivar = 1, 10
PRINT ivar
END DO
ivar = 0
DO WHILE (ivar .LT. 10)
ivar = ivar + 1
PRINT , ivar
END DO
Оператор END IF
--------------Прерывание блочного оператора IF.
СИНТАКСИС
END IF
ЗАМЕЧАНИЯ
Для каждого блочного оператора IF в программном модуле должно
выполняться соответствие оператора END IF. Исполнение оператора END IF
в программе "не имеет эффекта".
ПРИМЕР
IF (n .LT. 0) THEN
x = -n
y = -n
END IF
Оператор ENDFILE
----------------ДЕЙСТВИЕ
Выводит запись "конец-файла" как
присоединенного к указанному устройству.
следующую
запись
файла,
СИНТАКСИС
ENDFILE {<unitspec>│
([UNIT=]<unitspec>
[,ERR=<errlabel>]
[,IOSTAT=<iocheck>])}
Если параметр UNIT= опущен, то <unitspec> должен быть первым
параметром. Параметры могут указываться в любой последовательности.
Параметр
-----------unitspec
errlabel
iocheck
Описание
-------------------------------------------------------Целочисленное выражение, задающее внешнее устройство.
Если <unitspec> не является
открытым
устройством,
то генерируется ошибка этапа исполнения.
Метка исполняемого оператора в том же
программном
модуле, что и текущий оператор ENDFILE. Если параметр
<errlabel>
указан,
то
при
возникновении
ошибок
ввода/вывода управление
передается
в
оператор
с
меткой <errlabel>. Если параметр <errlabel> опущен, то
при возникновении ошибок
ввода/вывода
генерируется
сообщение об ошибке этапа исполнения. Действия, которые
необходимо
выполнить
при
возникновении
ошибок
ввода/вывода,
определяются
значением
параметра
<iocheck>.
Целочисленная
переменная
или
элемент
массива,
принимающий значение 0, если ошибка не произошла,
или
значение положительного целого, если ошибка произошла.
(Дополнительные данные об управлении ошибками приведены
в подразд.3.2.6).
ЗАМЕЧАНИЯ
После вывода записи "конец-файла", оператор ENDFILE устанавливает
файл в позицию после записи "конец-файла".
Так как запись конца файла является последней записью в файле, то
непосредственно после оператора ENDFILE нельзя выполнять какие-либо
операторы передачи данных, не
переустановив
позицию
в
файле
операторами BACKSPACE или REWIND.
Если к устройству <unitspec> присоединен файл прямого доступа, то
оператор ENDFILE удаляет все записи, выводимые после новой записи
"конец-файла".
Если параметром оператора ENDFILE является выражение, в котором
реализуется обращение к функции, то эта функция не должна вызывать
выполнения оператора ввода/вывода или встроенной функции EOF.
ПРИМЕР
WRITE (6, *) x
ENDFILE 6
REWINDE 6
READ (6, *) y
Оператор ENTRY
-------------ДЕЙСТВИЕ
Специфицирует точку входа процедуры или внешней функции.
СИНТАКСИС
ENTRY <ename>[[<eattrs>]][([<formal>[[<attrs>]]
[,<formal>[[<attrs>]]]...])]
Параметр
----------ename
eattrs
formal
attrs
Описание
--------------------------------------------------------Обязательное имя точки входа. Если <ename> является
точкой входа для функции, определенной пользователем, то
<ename> должно задавать тип данных при помощи:
- правил, принимаемых по умолчанию, используемых
в
определяющем типе; либо
- типа, задаваемого оператором IMPLICIT; либо
- объявления в разделе
объявлений
типов
функции,
определяемой пользователелем.
Необязательный список атрибутов, разделенных запятыми.
Для имени
<ename>
допустимо
применение
следующих
атрибутов: ALIAS, C, LOADDS, PASCAL, VARYING.
Необязательное
имя
переменной,
имя
массива,
имя
структурной переменной или формальное имя процедуры. Если
оператор ENTRY указывается в процедуре, то параметр
<formal> должен иметь значение "звездочка".
Список атрибутов, разделенных занятыми. Параметр <attrs>
описывает
имя
<formal>.
Допустимо
использование
следующих атрибутов для параметра <formal>: FAR, HUGE,
NEAR, REFERENCE, VALUE.
ЗАМЕЧАНИЯ
Для
исполнения
процедуры
или
функции начиная с
исполняемого оператора, указанного сразу после оператора
следует заменить имя подпрограммы на имя точки входа:
Тип вызова:
----------------процедура
функция
первого
ENTRY,
Формат вызова:
-----------------------------------------CALL <ename>[(<actual1>[,<actual2>]...])]
<ename> ([<actual1>[,<actual2>]...])
Следует отметить, что при вызове функции, даже если отсутствуют
формальные аргументы, необходимо указывать круглые скобки.
Точки входа не могут вызываться рекурсивно. Другими словами,
подпрограмма не может непосредственно или косвенно вызывать точку
входа внутри самой этой подпрограммы.
Ограничений на количество операторов ENTRY, используемых
в
процедуре, не накладывается.
На
использование
оператора
ENTRY
накладываются следующие
ограничения:
- внутри процедуры имя <ename> не может использоваться в качестве
имени формального
параметра
<formal>
в
операторах
FUNCTION,
SUBROUTINE, ENTRY или EXTERNAL;
- внутри функции имя <ename> не может быть указано в любом другом
операторе,
не
являющемся
оператором
типа, до тех пор, пока
действительно имя <ename>, определеное в операторе ENTRY;
- если одно имя <ename> в функции имеет тип символьный, то и все
имена <ename> в этой функции должны иметь тип символьный и, кроме
того, все имена <ename> должны быть одинаковой длины;
- параметр <formal> не может быть указан в исполняемом операторе,
который появляется в программе прежде оператора ENTRY, в котором
указан параметр <formal>, если параметр <formal>, однако, также не
указывается в операторах FUNCTION, SUBROUTINE или ENTRY, которые
предшествуют исполняемому оператору;
- оператор ENTRY не может быть использован между
блочным
оператором IF и соответствующим ему оператором END IF, или между
оператором DO и оператором завершения этого DO-цикла.
ПРИМЕР
С Данный программный фрагмент выводит сообщение,
С указывающее в каком случае переменная num имеет
С положительное значение, а в каком отрицательное.
IF (num .GE. 0) THEN
CALL Positive
ELSE
CALL Negative
END IF
.
.
.
END
SUBROOTINE Sign
ENTRY Positive
WRITE (*, *) 'It''s positive.'
RETURN
ENTRY Negative
WRITE (*, *) 'It''s negative.'
RETURN
END
Оператор EQUIVALENCE
-------------------ДЕЙСТВИЕ
Указывает, что две или более переменных
одну область памяти.
или
массива
используют
СИНТАКСИС
EQUIVALENCE (<nlist>)[,(<nlist>)]...
где <nlist> - список по крайней мере двух переменных, массивов или
элементов массива, разделенных запятыми; список <nlist> может не
содержать
имен
параметров.
Индексы должны быть целочисленными
константами и должны "находится в границах" массива, который они
индексируют.
Имя неиндексированного массива относится к первому
элементу массива.
ЗАМЕЧАНИЯ
Оператор EQUIVALENCE указывает, что элементы списка <nlist>
должны иметь одно и то же размещение в памяти. Говорят, что переменные
"ассоциированы", если они относятся с одной и той же фактической
области памяти.
Операции
автоматического преобразования типов для элементов
списка <nlist> не выполняются; они просто занимают одну и ту же
область памяти.
Ассоциированные символьные объекты могут перекрываться, наример:
CHARACTER a*4, b*4, c(2)*3
EQUIUALENCE (a, c(1)), (b, c(2))
Графически этот пример
образом:
: : : : : : : :
:01:02:03:04:05:06:07:
может
быть
проиллюстрирован
следующим
:-----a-----:
:-----b-----:
:--c(1)--:--c(2)--:
При ассоциировании элементов действуют следующие ограничения:
- переменная не может занимать более одной отдельной "ячейки"
памяти; также два или более элемента одного массива не могут занимать
одну и ту же "ячейку"
памяти.
Например,
следующий
оператор
предписывает переменной R занять две различные "ячейки" памяти, или
элементам S (1) и S (2) массива занять одну и ту же "ячейку" памяти:
С Выполнения данного программного фрагмента вызывает ошибку:
REAL r, s(10)
EQUIUALENCE (r, s(1)
EQUIVALENCE (r, s(2)
- последовательные элементы массива должны сохраняться в памяти в
последовательном
(непрерывном)
порядке.
Например,
выполнение
следующего программного фрагмента приводит к ошибке:
С Выполнения данного программного фрагмента вызывает ошибку:
REAL r(10), s(10)
EQUIVALENCE (r(1), s(1)
EQUIVALENCE (r(5), s(7)
Компилятор всегда выравнивает несимвольные объекты по четным
границам байтов (слов). В следующем примере генерируется ошибка этапа
компиляции, поскольку переменные a и b не могут быть одновременно
выровнены по границе слова:
CHARACTER*1 c1(10)
REAL a, b
EQUIVALENCE (a, c1(1))
EQUIVALENCE (b, c1(2))
- символьные и несимвольные объекты не могут быть ассоциированы.
В языке ФОРТРАН фирмы Microsoft разрешается ассоциация символьных и
несимвольных объектов; при этом несимвольные объекты не
должны
начинаться с нечетной границы байтов. При необходимости компилятор
будет выравнивать область хранения символьного объекта таким образом,
чтобы несимвольный объект начинался с четного байта. В следующем
примере генерируется ошибка этапа
компиляции,
т.к.
невозможно
репозиционировать
символьный
массив
таким
образом, чтобы оба
несимвольных объекта начинались в адресе четного байта:
CHARACTER*1
REAL reala,
EQUIVALENCE
EQUIVALENCE
char1(10)
realb
(reala, char1(1))
(realb, char1(2))
- элемент, указываемый в списке <nlist>,
не
может
быть
инициализирован в операторе типа. Выполнение, например, следующего
программного фрагмента, вызовет ошибку:
INTEGER i /1/
EQUIVALENCE (i, j)
- оператор EQUIVALENCE не может распределять одну и ту же область
памяти между двумя общими блоками;
- оператор EQUIVALENCE может расширить "общий" блок
путем
добавления
элементов
памяти, следующих за общим блоком. Длина
поименованного общего блока, используемого в различных программных
модулях, должна быть одной и той же;
- оператор EQUIVALENCE не может расширять общий блок путем
добавления элементов памяти, предшествующих общему блоку, например:
С Выполнение данного программного фрагмента вызовет ошибку:
COMMON /abcdef/ r(10)
REAL s(10)
EQUIVALENCE (r(1), s(7))
Если не указана метакоманда $STRICT, то в операторах EQUIVALENCE
требуется указание только первого индекса многомерного массива (этим
обеспечивается
упрощение
процедуры
помещения в порт программ,
написанных на языке ФОРТРАН-66).
ПРИМЕР
CHARACTER name, first, middle, last
DIMENSION name(60), first(20), middle(20), last(20)
EQUIVALENCE (name(1), first(1)), (name(21), middle(1))
EQUIVALENCE (name(41), last(1))
Оператор EXIT
------------ДЕЙСТВИЕ
Передача управления из цикла DO или DO WHILE в первый исполняемый
оператор, следующий за концом цикла.
СИНТАКСИС
EXIT
ЗАМЕЧАНИЯ
В общем случае, цикл DO исполняется фиксированное число раз.
Оператор EXIT позволяет пользователю прерывать цикл раньше, если
некоторое заданное условие будет выполнено (или не выполнено).
ПРИМЕР
C Цикл прерывается преждевременно, если одно из данных
С установится в значение 0:
INTEGER numpoints, point
REAL datarray(1000), sum
sum = 0.0
DO point = 1, 1000
numpoints = point
sum = sum + datarray(point)
IF (datarray(point+1) .EQ. 0.0) EXIT
END DO
Оператор EXTERNAL
----------------ДЕЙСТВИЕ
Идентификация определенного пользователем имени как имени внешней
процедуры или функции.
СИНТАКСИС
EXTERNAL <name> [[<attrs>]][,<name>[[<attrs>]]]...
Параметр
-----------name
attrs
Описание
-------------------------------------------------------Обязательное имя внешней процедуры или функции. Имена
операторных функций недопустимы.
Необязательный список атрибутов, разделенных запятыми.
Параметр
<attrs>
описывает
имя
<name>.
Допустимы атрибуты ALIAS, C, FAR, LOADDS, NEAR, PASCAL,
VARYING.
ЗАМЕЧАНИЯ
Оператор EXTERNAL в общем случае используется для спецификации
того, что процедура или функция используется как процедурный параметр.
Оператор EXTERNAL может также заменять встроенную функцию на функцию,
определенную пользователем с тем же именем.
Если в операторе EXTERNAL указывается имя встроенной функции, то
это имя становится именем внешней процедуры
и
соответствующая
встроенная функция не может в дальнейшем быть вызвана из программного
модуля. В любом заданном программном модуле имя, специфицируемое
пользователем, может указываться в операторе EXTERNAL только однажды.
В языке ФОРТРАН предполагается, что имя любой процедуры или
функции, относящееся к компилируемому модулю,
определяется
как
внешнее.
ПРИМЕР
С Пример оператора EXTERNAL:
EXTERNAL MyFunc, MySub
С MuFunc и MySub являются параметрами для Calc:
CALL Calc (MyFunc, MySub)
С Пример пользовательской функции, заменяющей встроенную
С функцию EXTERNAL SIN
intrinsic EXTERNAL SIN
x = SIN (a, 4.2, 37)
Оператор FORMAT
--------------ДЕЙСТВИЕ
Используется для описания и установки
читаются (или пишутся) в (из) файл(а).
формата
данных,
которые
СИНТАКСИС
FORMAT ([<editlist>])
где <editlist> - есть список дескрипторов преобразования.
ЗАМЕЧАНИЯ
Оператор FORMAT должен быть помечен.
В случаях ошибок в строках списка <editlist>
генерируются
предупреждающие сообщения: некоторые во время этапа компиляции, а
некоторые - во время этапа исполнения.
В
табл.3.6
перечислены
неповторяющиеся
дескрипторы
преобразования. В табл.4.5 перечислены повторяющиеся
дескрипторы
преобразования (см. также подразд.3.7 "Форматированный ввод/вывод").
Таблица 4.5
Повторяющиеся дескрипторы преобразования
------------------------------------------------------------------:
Дескриптор
:
Преобразование
:
:-----------------+-----------------------------------------------:
: Iw[,m]
: Преобразование целых
:
: Zw
: Преобразование шестнадцатеричных
:
: Fw.d
: Преобразование вещественных
:
: Ew.d[Eе]
: Преобразование вещественных с показателем
:
:
: степени
:
: Gw.d[Eе]
: Преобразование вещественных
:
: Dw.d
: Преобразование вещественных с двойной
:
:
: точностью
:
: Lw
: Преобразование логических
:
: A[w]
: Преобразование символьных
:
------------------------------------------------------------------В
данной
таблице w представляет значение ширины поля, m
представляет число ведущих нулей, d представляет
число
цифр,
следующих за десятичной точкой, e представляет показатель степени.
Оператор FUNCTION (внешний)
--------------------------ДЕЙСТВИЕ
Идентифицирует программный модуль как функцию и специфицирует ее
имя, тип данных и необязательные формальные параметры.
СИНТАКСИС
[<type>] FUNCTION <func>[[<fattrs>]]([<formal>[[<attrs>]]]
[,<formal>[[<attrs>]]]...)
Параметр
Описание
----------- ---------------------------------------------------------type
Определяет тип данных значения, возвращаемого функцией.
Параметр <type> должен быть одним из следующих:
CHARACTER
CHARACTER*n
COMPLEX
COMPLEX*8
COMPLEX*16
DOUBLE COMPLEX
DOUBLE PRECISION
INTEGER
INTEGER*1
INTEGER*2
INTEGER*4
INTEGER[C]
LOGICAL
LOGICAL*1
LOGICAC*2
LOGICAC*4
REAL
fname
REAL*4
REAL*8
Если параметр <type> опущен, то тип функции определяется
любым оператором IMPLICIT или оператором типа, который
позволяет описывать тип обычной переменной.
Если параметр <type> указан, тогда имя функции не
может
указываться в любом операторе типа.
Имя функции. Имя <fname>
не
может
указываться
в
операторах AUTOMATIC, COMMON, DATA, EQUIVALENCE,
INTRINSIC,
fattrs
formal
attrs
NAMELIST или SAVE.
Список
атрибутов,
разделенных
запятыми.
Допустимы
(для имени <fname>) следующие атрибуты: ALIAS, C, FAR,
NEAR, PASCAL, VARYING.
Одно или более имен формальных параметров. Если указано
более одного имени, то они должны быть разделены запятыми.
Спецификаторы альтернативного
возврата
недопустимы в
операторах FUNCTION.
Список
атрибутов,
разделенных запятыми.
Для
имени
<formal> допустимы следующие атрибуты: FAR, HUGE, NEAR,
REFERENCE, VALUE.
ЗАМЕЧАНИЯ
Функция начинается с оператора FUNCTION и завершается оператором
END. Функция может содержать любой оператор, за исключением операторов
BLOCK DATA, FUNCTION, INTERFACE TO, PROGRAM или SUВROUTINE.
Спецификатор длины для типа функции может следовать за именем
функции. Например, следующие два объявления являются эквивалентными:
INTEGER*4 FUNCTION FuncX
(var)
INTEGER
FUNCTION FuncX*4 (var)
Внутри вызывающей программы имя <func> является глобальным и не
может быть использовано для любой другой переменной или подпрограммы.
Список формальных параметров устанавливает число аргументов для
функции. Типы аргументов устанавливаются любым из операторов IMPLICIT,
EXTERNAL,
DIMENSION
или операторами типа внутри функции. Типы
аргументов не устанавливаются вызывающей программой, даже если функция
указывается в исходном файле вызывающей программы. Имена формальных
аргументов не могут появляться в операторах AUTOMATIC, COMMON, DATA,
EQUIVALENCE, INTRINSIC или SAVE.
При ссылке на функцию передаваемые фактические параметры должны
согласовываться с соответствующими формальными параметрами в операторе
FUNCTION по последовательности, числу и типу.
Компилятор будет проверять соответствие, если известны формальные
параметры.
Имя функции <func> действует так, как если бы оно было переменной
внутри описания функции. В некоторой точке выполнения функции значение
должно быть присвоено имени функции. Это будет то значение, которое
возвращается в вызывающую программу через посредство имени функции.
Это значение обычно присваивается в конце функции, с операторами
RETURN, прерывающими выполнение функции в соответствующих точках.
В дополнение к возвращаемому значению внешняя функция может
возвратить значения при помощи назначения их формальным параметрам,
чьи соответствующие фактические параметры передавались по ссылке.
Спецификаторы альтернативного возврата в операторах FUNCTION
недопустимы.
Функция может быть вызвана из любого программного модуля.
Однако, язык ФОРТРАН не предоставляет возможности рекурсивного
вызова функции, что означает, что функция не может непосредственно
вызвать сама себя. Рекурсивные вызовы компилятором не обрабатываются.
ПРИМЕР
С Пример указателя функции
C GetNo является функцией, которая считывает номер из
C файла, открытого на устройстве I
i = 2
10 IF (GetNo(i) .EQ. 0.0) GOTO 10
END
C
FUNCTION GetNo (nounit)
READ (nounit, '(F10.5)') r
GetNo = r
END
Оператор GOTO (переход по предписанию)
-------------------------------------ДЕЙСТВИЕ
Передает исполнение в оператор,
переменной <variable>.
помеченный
меткой,
присвоенной
СИНТСКСИС
GOTO <variable> [[,](<labels>)]
Параметр
----------variable
labels
Описание
--------------------------------------------------------Имя целочисленной переменной. При исполнении оператора
GOTO данного типа переменной <variable> должно быть
назначено значение метки исполняемого оператора в том же
программном модуле, где указан и оператор GOTO.
Список из одной или более операторных меток исполняемых
операторов, указанных в том же программном модуле, где
указан и оператор GOTO. Если в списке указано несколько
меток, то они разделяются запятыми. В списке меток одна
и та же метка <label> может повторяться.
ЗАМЕЧАНИЯ
Если специфицирована метакоманда $DEBUG, то в случае, если метка,
назначенная некоторому имени <name>, не является меткой из списка
меток операторов, будет генерироваться ошибка этапа исполнения.
Переход в блоки DO, IF, ELSE IF или ELSE из-вне самого блока в
общем случае не разрешен. Такую возможность обеспечивают специальные
"расширенные DО-циклы" (см. также подразд.6.2).
ПРИМЕРЫ
С Пример оператора GOTO по предписанию
10
ASSIGN 10 TO n
GOTO n
CONTINUE
Следующий пример
переменной clearance:
использует оператор GOTO для проверки значения
$DEBUG
INTEGER
view, clearance
С Данные операторы назначают переменной view подходящую метку
IF (clearance .EQ. 1) THEN
ASSIGN 200 TO view
ELSE IF (clearance .EQ. 2) THEN
ASSIGN 400 TO view
ELSE
ASSIGN 100 TO view
END IF
С Переход в соответствующий оператор
GOTO view (100, 200, 400)
С Если, в вышеприведенном операторе GOTO, переменной view
C не было назначено одно
С из корректных значений метки - 100, 200 или 400,
С то в этом случае генерируется сообщение об ошибке.
100
CONTINUE
.
.
.
200
CONTINUE
.
.
.
400
CONTINUE
.
.
.
END
Оператор GOTO (вычисляемый)
--------------------------ДЕЙСТВИЕ
Передает управление в оператор, помеченный n-ой меткой из
меток.
списка
СИНТАКСИС
GOTO (<labels>) [,]n
Параметр
----------labels
Описание
--------------------------------------------------------Одна или несколько
обязательных
операторных
меток
исполнительных
операторов,
указанных
в
том
же
программном модуле, что и оператор GOTO. Если в списке
указано несколько меток, то они разделяются запятыми.
В списке меток одна метка может быть указана многократно.
n
Целочисленное выражение.
метку списка меток.
Управление
передается
в n-ю
ЗАМЕЧАНИЯ
Если в списке меток указано j меток, а значение n "не включено" в
диапазон значений и (т.е. если i > n или i < n), то вычисляемый
оператор GOTO выполняется как оператор CONTINUE.
В противном случае, следующим выполняемым оператором является
оператор, помеченный n-ой меткой из списка меток.
Переход в блоки DO, IF, ELSE IF или ELSE из-вне блока в общем
случае не разрешен. Такую возможность
обеспечивают
специальные
"расширяемые DO-циклы", позволяющие выполнять переход в блок DO (см.
подразд.6.2).
ПРИМЕР
С Пример вычисляемого оператора GOTO
next = 1
С Следующий оператор передает управление в
С оператор с меткой 10:
GOTO (10, 20) next
.
.
.
10 CONTINUE
.
.
.
20 CONTINUE
Оператор GOTO (безусловный переход)
----------------------------------ДЕЙСТВИЕ
Передает управление в оператор, помеченный меткой <label>.
СИНТАКСИС
GOTO <label>
Параметр
----------label
Описание
--------------------------------------------------------Операторная метка исполнительного оператора, указанного
в том же программном модуле, что и оператор GOTO.
ЗАМЕЧАНИЯ
Если программный модуль не
содержит
оператор
с
меткой,
специфицированной в операторе GOTO, то генерируется ошибка этапа
исполнения.
Переход в блоки DO, IF, ELSEIF или ELSE из-вне блока в общем
случае
не
разрешен. Такую возможность обеспечивают специальные
"расширяемые DO-циклы", позволяющие выполнять переход в блок DO (см.
также подразд.6.2).
ПРИМЕР
С Пример безусловного оператора GOTO
GOTO 4077
.
.
.
4077 CONTINUE
Оператор IF (арифметический)
---------------------------ДЕЙСТВИЕ
Передает управление в оператор, специфицированный одной из трех
меток, в зависимости от результата вычисления выражения <expression>.
СИНТАКСИС
IF (<expression>) <label1>, <label2>, <label3>
Параметр
-----------expression
label1
label2
label3
Описание
-------------------------------------------------------Либо
целочисленное
выражение,
либо
выражение
вещественного числа с одинарной или двойной точностью.
Операторные метки исполнительных операторов, указанных
в том же программном модуле, что и арифметический
оператор IF. Среди указываемых трех меток одна и та же
метка может быть указана более одного раза.
ЗАМЕЧАНИЯ
Арифметический оператор IF передает управление одним из следующих
способов:
Если:
Тогда:
---------------- ----------------------------------------------------expression < 0
Следующий
выполняемый
оператор есть оператор с
меткой <label1>.
expression = 0
Следующий
выполняемый
оператор есть оператор с
меткой <label2>.
expression > 0
Следующий
выполняемый
оператор есть оператор с
меткой <label3>.
Переход в боки DO, IF, ELSE IF или ELSE из-вне данного блока в
общем случае не разрешен. Такую возможность обеспечивают специальные
"расширяемые DO-циклы", позволяющие выполнять переход в блок DO (см.
также подразд.6.2).
ПРИМЕР
С Пример арифметического оператора IF
DO 40
n = j
j = -1, 1
С Следующий оператор передает управление в оператор с меткой
С 10 в первый раз, затем в оператор с меткой 20, затем в
С оператор с меткой 30.
10
20
30
40
IF (n) 10, 20, 30
CONTINUE
.
.
.
CONTINUE
.
.
.
CONTINUE
.
.
.
CONTINUE
Оператор IF (логический)
-----------------------ДЕЙСТВИЕ
Выполняет
оператор <statement>, если выражение <expression>
вычисляется со значением "истина"; в противном случае, если выражение
<expession> вычисляется со значением "ложь", оператор игнорируется и
выполняется оператор,
непосредственно
следующий
за
логическим
оператором IF.
СИСНТАКСИС
IF (<expression>) <statement>
Параметр
----------expression
statement
Описание
--------------------------------------------------------Логическое выражение.
Любой исполняемый оператор, за исключением операторов DO,
ELSE IF, ELSE, CASE, END IF, END, ЕND SELECT CASE, SELECT
CASE, блочного оператора IF, либо другого логического
оператора IF.
Следует отметить, что оператор может быть арифметическим
оператором IF.
ПРИМЕРЫ
С Примеры логического оператора IF
100
IF (i .EQ. 0) j = 2
IF (x .GT. 2.3) GOTO 100
.
.
.
CONTINUE
Оператор IF THEN ELSE (блочный оператор IF)
------------------------------------------ДЕЙСТВИЕ
Начинает выполнение операторов в блоке IF, если
выражение
<expression> вычисляется со значением "истина"; передает управление в
следующий ELSE, ELSE IF или END IF оператор, находящийся на том же
уровне оператора IF, если выражение <expression> вычисляется со
значением "ложь".
СИНТАКСИС
IF (<expression>) THEN
Параметр
-----------expression
Описание
-------------------------------Логическое выражение
ЗАМЕЧАНИЕ
Ассоциированный
блочный
оператор
IF
состоит
из
всех
исполнительных операторов (возможно, что ни один оператор указан не
будет), "заключенных" между оператором IF и следующим оператором ELSE,
ЕLSE IF или END IF, находящимся на том же уровне оператора IF, что и
блочный оператор IF.
Блок IF передает управление следующим образом:
Если:
-----------------------Выражение <expression>
имеет значение "истина",
а блок IF не содержит
исполнимых операторов
Тогда:
------------------------------------------Следующим выполняемым оператором является
следующий
оператор
END IF, находящийся
на том же уровне, что и блочный оператор IF
Выражение <expression>
имеет значение "истина",
и в блоке IF указан по
крайней
мере
один
исполнимый оператор
Следующим выполняемым оператором является
первый исполнимый оператор в блоке IF
Выражение <expression>
вычисляется со
значением "ложь"
Следующим выполняемым оператором является
следующий
оператор
ELSE IF, ELSE или
END IF,
находящейся на том же уровне,
что и блочный оператор IF
После выполнения последнего оператора в блоке IF
следующим
исполняемым оператором будет следующий оператор END IF, находящийся на
том же уровне, что и блочный оператор IF.
Передача управления в блок IF из-вне данного блока не разрешена.
Уровни оператора IF определяются как "if минус endif", где if
есть количество блочных операторов IF, начиная с начала программного
модуля, в котором оператор указан, до (и включая) данного оператора, а
endif - есть количество операторов END IF, начиная
с
начала
программного модуля, до (но не включая!) данного оператора.
Элемент
----------------блок IF, ELSE IF,
ELSE
и
END IF
оператор END
Требуемое значение уровня оператора IF
-------------------------------------------------больше 0 и меньше 50 (примерно!)
0
другие операторы
больше или равно 0 и меньше 50 (примерно)
ПРИМЕР
С Простой блок IF, который пропускает группу операторов, если
С выражение вычисляется со значением "ложь":
IF (i .LT. 10) THEN
С Следующие два оператора вычисляются только в том случае,
C если
С
i < 10
j = i
slice = TAN (angle)
END IF
С Блок IF с операторами ELSE IF:
IF (j .GT. 1000) THEN
С Данные операторы вычисляются,
ELSE IF (j .GT. 100) THEN
С Данные операторы вычисляются,
ELSE IF (j .GT. 10) THEN
С Данные операторы вычисляются,
ELSE
С Данные операторы вычисляются,
END IF
если J > 1000
если j > 100 и j <= 1000
если j > 10 и j <= 100
если j <= 10
С Встраивание конструкций и использование оператора ELSE,
С следующего за блоком IF, без выполнения операторов ELSE IF:
С
С
C
С
С
С
С
С
IF (i .LT. 100) THEN
Данные операторы выполняются,
IF (j .LT. 10) THEN
Данные операторы выполняются,
i < 100 и j < 10
END IF
Данные операторы выполняются,
ELSE
Данные операторы выполняются,
IF (j .LT. 10) THEN
Данные операторы выполняются,
и j < 10
END IF
Данные операторы выполняются,
END IF
только если i < 100
только если
только если i < 100
только если i >= 100
только если i >= 100
только если i >= 100
СМОТРИ ТАКЖЕ
Операторы ELSE, ELSE IF, END IF.
Оператор IMPLICIT
----------------ДЕЙСТВИЕ
Задает
умолчанию.
для
объявленного пользователем имени тип, принимаемый по
СИНТАКСИС
IMPLICIT {<type>(<letters>)[,<type>(<letters>)]...│NONE}
Параметр
----------type
letters
Описание
--------------------------------------------------------Один из следующих типов:
CHARACTER,
CHARACTER*n
COMPLEX
COMPLEX*8
COMPLEX*16
DOUBLE COMPLEX
DOUBLE PRECISION
INTEGER
INTEGER*1
INTEGER*2
INTEGER*4
INTEGER[C]
LOGICAL
LOGICAL*1
LOGICAL*2
LOGICAL*4
REAL
REAL*4
REAL*8
Список одинарных букв и диапазонов букв. Если указываются
несколько букв или диапазонов, то они должны разделяться
запятыми. Диапазон букв указывается первой и последней
буквами в диапазоне,
разделенными
знаком
"минус".
Последовательность
букв, заданная в виде диапазона,
должна быть расположена в алфавитном порядке. Следует
отметить, что в языке ФОРТРАН допускается
использование
знака доллара ($) как буквенно символа, который следует
за буквой Z.
ЗАМЕЧАНИЯ
Оператор IMPLICIT определяет тип и размер для всех, определенных
пользователем, имен, которые начинаются с одной из специфицированных
букв. Оператор IMPLICIT применим только для программного модуля, в
котором он непосредственно указан, и не изменяет типа любой встроенной
функции.
Если
специфицировано
IMPLICIT
NONE,
то все определенные
пользователем имена должны быть введены явно. Невведенные имена
приводят к возникновению ошибки этапа компиляции.
Типы, определенные при помощи оператора IMPLICIT для любого,
специфицированного пользователем имени, могут быть либо заменены, либо
наоборот подтверждены, если это имя задано в соответствующем операторе
типа. Явное задание типа в операторе FUNCTION также имеет "более
высокий приоритет", чем тип, указываемый оператором IMPLICIT.
В программном модуле может быть указано несколько операторов
IMPLICIT. Однако, все операторы IMPLICIT должны предшествовать всем
другим операторам, описанным в данном программном модуле.
Программный модуль может иметь только один оператор IMPLICIT
NONE. Никакие другие операторы IMPLICIT не могут указываться в
программном модуле, содержащем оператор IMPLICIT NONE.
ПРИМЕР
С Пример оператора IMPLICIT
IMPLICIT INTEGER (a - b)
IMPLICIT CHARACTER*10 (n)
С следующий оператор заменяет для переменной anyname
С неявно объявляемый тип INTEGER
CHARACTER*20
anyname
age = 10
name = 'PAUL'
Оператор INCLUDE
---------------ДЕЙСТВИЕ
Выполняется вставка содержимого
файла в позиции оператора INCLUDE.
специфицированного
текстового
СИНТАКСИС
INCLUDE '<filename>'
Параметр
Описание
----------- ---------------------------------------------------------filename
Имя
текстового файла на языке ФОРТРАН, включаемого в
программу (заключается в апострофы).
ЗАМЕЧАНИЯ
Параметр '<filename>' должен быть спецификацией
корректного
текстового файла для операционной системы пользователя.
Компилятор рассматривает содержимое включаемого файла как часть
программного файла и выполняет его компиляцию немедленно. В конце
включаемого файла компилятор
завершает
обработку
оригинального
исходного файла в строке, следующей за оператором INCLUDE.
Включаемые файлы используются в основном для модулей данных или
программных модулей, которые появляются более чем в одной программе.
Включаемые файлы зачастую содержат процедуры и функции, объявления
"общих" блоков и операторы EXTERN, INTERFACE и INTRINSIC.
Включаемые файлы также могут содержать другие операторы INCLUDE и
метакоманды $INCLUDE; это называется "встраиванием" включаемых файлов.
Компилятор предоставляет пользователю возможность встраивать любую
комбинацию
до
10
операторов INCLUDE или метакоманд $INCLUDE.
Операционная система, используемая
пользователем,
может
однако
накладывать на встраивание файлов дополнительные ограничения.
ПРИМЕР
Данная программа реализует стэк путем объявления стэковых данных
общего пользования во включаемом файле. Содержимое файла STKVARS.FOR
вставляется в исходный код в позицию каждого оператора INCLUDE. Это
гарантирует, что все ссылки на область общего пользования
для
переменных стэка будут корректными.
INTEGER i
REAL x
INCLUDE 'stkvars.for'
C
чтение первых пяти вещественных чисел:
DO 100 i = 1, 5
READ (*, '(F10.5)') x
CALL Push (x)
100 CONTINUE
C
запись чисел в обратной последовательности:
WRITE (*, *) ' '
DO 200 i = 1, 5
CALL, Pop (x)
WRITE (*, *) x
200 CONTINUE
END
SUBROUTINE Push (x)
С вталкивание элемента x в вершину стэка
REAL x
INCLUDE 'stkvars.for;
top = top + 1
IF (top .GT. stacksize) STOP 'Stack overflow'
stack(top) = x
END
SUBROUTINE pop(x)
С выталкивание элемента из вершины стэка в x
REAL x
INCLUDE 'stkvars.for'
IF (top .LE. 0) STOP 'Stack underflow'
x = stack(top)
top = top - 1
END
Ниже показан текстовый файл STKVARS.FOR:
C
С
С
С
Этот файл содержит объявление общего блока
для реализации стэка. Поскольку этот файл содержит
оператор присваивания, он должен быть включен только после
всех других операторов описания в каждом программном модуле.
REAL
stack(500)
INTEGER top, stacksize
COMMON /stackbl/ stack, top
stacksize = 500
Оператор INQUIRE
---------------ДЕЙСТВИЕ
Предназначен для получения информации о характеристиках и текущем
состоянии указанного внешнего файла или устройства. Внешний файл (или
устройство) может быть как присоединенным, так и неприсоединенным.
СИНТАКСИС
INQUIRE ({[UNIT=]<unitspec>│FILE =<file>}
[,ACCESS=<access>]
[,BINARY=<binary>]
[,BLANK=<blank>]
[,BLOCKSIZE=<blocksize>]
[,DIRECT=<direct>]
[,ERR=<errlabel>]
[,EXIST=<exist>]
[,FORM=<form>]
[,FORMATTED=<formatted>]
[,IOSTAT=<iocheck>]
[,MODE=<mode>]
[,NAME=<name>]
[,NAMED=<named>]
[,NEXTREC=<nextrec>]
[,NUMBER=<num>]
[,OPENED=<opened>]
[,RECL=<rec>]
[,SEQUENTIAL=<seq>]
[,SHARE=<share>]
[,UNFORMATTED=<unformatted>])
Если параметр UNIT= опущен, то первым должен быть параметр
<unitspec>. Параметры могут указываться в любой последовательности.
Параметр
------------unitspec
file
access
binary
Описание
------------------------------------------------------Если опущено UNIT=, то
параметр <unitspec> должен
указываться первым. В качестве значения
<unitspec>
можно использовать либо целочисленное выражение, либо
звездочку (*). Если указано UNIT=*, то параметр NUMBER=
в
список параметров включать нельзя, иначе будет
генерироваться сообщение об ошибке.
В
описании
должен быть специфицирован либо один
параметр <unitspec>, либо один параметр <file>; оба
описания одновременно не допускаются. Если
указан
<unitspec>, то операция запроса называется операцией
"запроса об устройстве".
Символьное выражение, вычисляемое со значением имени
файла,
о
котором
поступил
запрос.
В описании
допускается спецификация либо <unitspec>, либо <file>;
оба описания одновременно не допускаются. Если указан
файл <file>, то операция запроса называется операцией
"запроса о файле".
Символьная переменная или элемент символьного массива.
Установка
параметра
в
значение
'SEQUENTIAL'
выполняется в том случае, если устройство или файл
присоединены для
последовательного
доступа;
если
устройство или файл присоединены для прямого доступа,
то
для
параметра
устанавливается
значение
'DIRECT'. Для случая оператора "запроса об устройстве",
если
файл
присоединен
к
устройству <unitspec>,
параметр <access> неопределен.
Символьная переменная, элемент символьного массива или
blank
blocksize
direct
errlabel
exist
form
formatted
iocheck
mode
структурный элемент. Возвращается
значение
'YES',
если среди допустимых, для специфицированного файла
<file> или присоединенного
устройства
<unitspec>,
форматов указан двоичный формат. В противном случае
параметр устанавливается в значение 'NO' или 'UNKNОWN'.
Символьная переменная, элемент символьного массива или
структурный элемент. Устанавливается в значение 'NULL',
если действителен дескриптор преобразования BN; если
действителен дескриптор BZ, параметр устанавливается в
значение 'ZERO'.
Целочисленная
переменная,
элемент
массива
или
структурный элемент. Если устройство <unitspec> или
файл
<file>
присоединены,
параметр
<blocksize>
устанавливается в значение размера буфера ввода/вывода,
используемого <unitspec> или <file>. Если устройство
или файл не присоединены, параметр <blocksize> является
неопределенным.
Символьная переменная, элемент символьного массива или
структурный элемент. Устанавливается в значение 'YES',
если среди методов доступа, указанных для файла <file>
или устройства <unitspec>, специфицирован метод прямого
доступа. В противном случае параметр устанавливается в
значение 'NO' или 'UNKNOWN'.
Метка исполняемого оператора в том же программном
модуле, где указан и текущий оператор INQUIRE. Если
специфицирован
параметр
<errlabel>,
то
при
возникновении ошибок ввода/вывода управление передается
в
оператор
с
меткой
<errlabel>. Если параметр
<errlabel> опущен,
то
при
возникновении
ошибок
ввода/вывода будут генерироваться сообщения об ошибках.
Действия, которые следует предпринять по устранению
ошибок ввода/вывода, определяются по значению параметра
<iocheck>.
Логическая переменная, элемент массива или структурный
элемент.
Устанавливается
в значение .TRUE., если
специфицированное устройство <unitspec> или файл <file>
существует; в противном случае параметр устанавливается
в значение .FALSE..
Символьная переменная или элемент символьного массива.
Устанавливается
в
значение
'FORMATTED',
если
специфицированное устройство
<unitspec>
или
файл
<file> присоединены к форматному вводу/выводу; для
двоичного
ввода/вывода
значение
параметра
есть
'BINARY'; для неформатного ввода/вывода - 'UNFORMATED'.
Символьная переменная, элемент символьного массива или
структурный элемент. Устанавливается в значение 'YES',
если среди допустимых форматов, специфицированных для
файла
<file>
или
присоединенных
к
устройству
<unitspec>, указан форматный формат;
в
противном
случае для параметра устанавливается значение 'NO' или
'UNKNOWN'.
Целочисленная
переменная, элемент
массива
или
структурный
элемент,
которые
определяются
со
значением ноль, если ошибок не произошло, либо со
значением
положительного целого числа в противном
случае (см. также подразд.3.2.6).
Символьная переменная, элемент символьного массива или
структурный
элемент.
Устанавливается
в
значение
состояния текущего режима специфицированного
устройства.
name
named
nextrec
num
opened
recl
seq
Значения
параметра
совпадают
со
значениями,
указываемыми
в операторе OPEN: 'READ', 'WRITE' и
'READWRITE'. В операторе "запроса об
устройстве",
параметр <mode> является
неопределенным,
если
к
устройству <unitspec> не присоединен ни один файл.
Символьная переменная, элемент символьного массива или
структурный элемент. В операторе "запроса об устройстве"
параметр устанавливается в значение
имени
файла,
присоединенного к устройству
<unitspec>.
Если
к
устройству <unitspec> не присоединен ни один файл, или
если файл, присоединенный к устройству <unitspec> не
имеет имени, то имя <name> является неопределенным. В
операторе "запроса о файле" параметр устанавливается в
значение имени, указанного для файла <file>.
Логическая
переменная
или
элемент
массива.
Устанавливается
в
значение
.FALSE.,
если файл,
специфицированный как <file> или присоединенный
к
устройству
<unitspec>, не является открытым,
или
является рабочим файлом; в противном случае параметр
устанавливается в значение .TRUE..
Целочисленная переменная, элемент массива или элемент
структуры, которые назначают номер следующей записи в
файле прямого доступа. Первая запись в файле прямого
доступа имеет номер 1.
Целочисленная переменная, элемент массива или элемент
структуры. В операторе "запроса о файле", параметр
устанавливается
в
значение
номера
устройства,
присоединенного к файлу <file>. Если к файлу <file>
устройство не присоединено, то параметр <num> является
неопределенным. В операторе "запроса об устройстве",
параметр
устанавливается
в
значение
номера,
указанного
в
<unitspec>.
Если
пользователь
специфицировал UNIT=*, то параметр NUMBER= в описание
включать нельзя, иначе будет сгенерировано сообщение об
ошибке.
Логическая переменная, элемент массива или элемент
структуры. В операторе "запроса об устройстве" параметр
устанавливается в значение .TRUE., если к устройству
<unitspec> присоединен любой файл; в противном случае
параметр
устанавливается
в
значение
.FALSE.
В
операторе "запроса о файле" параметр устанавливается
в значение .TRUE., если файл <file> присоединен к
любому устройству;
в
противном
случае
параметр
устанавливается в значение .FALSE..
Целочисленная переменная, имя элемента
массива или
структурный элемент, специфицирующие длину (в байтах)
каждой записи в файле прямого доступа; если файл не
присоединен к устройству или присоединен, но не для
прямого
доступа,
значение
параметра
будет
неопределенным.
Символьная переменная, элемент массива или структурный
элемент. Устанавливается в значение 'YES', если среди
методов
доступа,
допустимых
для
файла,
специфицированного
ванного
как
<file>,
или
присоединенного
к
устройству
<unitspec>,
указан
последовательный метод доступа; в противном случае
share
unformatted
параметр устанавливается в значение 'NO' или 'UNKNOWN'.
Символьная переменная, элемент символьного массива или
элемент структуры. Устанавливается значение текущего
состояния
совместного
использования
файла,
специфицированного как <file> или присоединенного к
устройству <unitspec>. Значение параметра совпадают со
значениями,
специфицируемыми
в
операторе
OPEN:
'COMPACT', 'DENYRW', 'DENYWR', 'DENYRD', 'DENYNONE'.
В операторе "запроса об устройстве", если файл не
присоединен к устройству <unitspec>, параметр <share>
неопределен.
Символьная переменная, элемент символьного массива или
элемент структуры. Устанавливается в значение 'YES',
если
среди
форматов,
допустимых
для
файла,
специфицированного как <file> или присоединенного к
устройству <unitspec>, указан бесформатный формат; в
противном случае параметр устанавливается в значение
'NO' или 'UNKNOWN'.
ЗАМЕЧАНИЯ
Оператор INQUIRE возвращает значения различных атрибутов, с
которыми был открыт файл. Следует отметить, что оператор INQUIRE не
может определять свойства и характеристики неоткрытых файлов; он также
не
устанавливает
различий
между атрибутами, специфицированными
пользователем, и атрибутами, принимаемыми по умолчанию.
Оператор INQUIRE может быть выполнен в любое время. Значения,
которые он возвращает, являются текущими значениями, "действующими"
("установленными") в момент обращения ("вызова") к оператору.
Если параметром оператора INQUIRE является выражение, которое
вызывает функцию, то эта функция не должна активизировать выполнение
оператора ввода/вывода или встроенной функции EOF, поскольку в этих
случаях результаты могут оказаться непредсказуемыми.
ПРИМЕР
С
C
С
С
С
Данная программа запрашивает имя файла данных.
Затем оператор
INQUIRE используется для определения того, существует или
не существует файл. Если он не существует, программа
запрашивает другое имя файла.
CHARACTER*12
LOGICAC
fname
exists
С Имя файла получается от пользователя:
100 WRITE (*, '(1X,A)') 'Введите имя файла данных: '
READ (*, '(A)') fname
C Получение информации о специфицированном файле.
INQUIRE (FILE = fname, EXIT = exists)
С Проверка существования файла.
IF (.NOT. exists) THEN
WRITE (*, '(2A/)') ' > Файле не найден', fname
GOTO 100
END IF
.
.
.
END
Оператор INTEGER
---------------ДЕЙСТВИЕ
Спецификация типа INTEGER для имен, определенных пользователем.
СИНТАКСИС
INTEGER [[*<bytes>]][[C]]<vname>[[<attrs>]][*<length>]
[(<dim>)][/<values>/][,<vname>[[<attrs>]][*<length>]
[(<dim>)][/<values>/]]...
Порядок указания параметров <length> и <dim> может быть обратным.
Параметр
-----------bytes
vname
attrs
length
dim
values
Описание
-------------------------------------------------------Должен иметь значение 1, 2 или 4. Параметр <bytes>
указывает длину (в байтах) элемента, специфицированного
в операторе INTEGER. Значение данного параметра может
быть заменено значением параметра <length>.
Символическое
имя константы,
переменной,
массива,
внешней функции, операторной функции или встроенной
функции; либо это может быть процедура-функция или
описатель массива. Параметр vname не может быть именем
процедуры или головной программы.
Список
атрибутов, разделенных занятыми. Для <vname>
допустимы следующие атрибуты: ALIAS, C, EXTERN, FAR,
HUGE, NEAR, PASCAL, REFERENCE, VALUE, ALLOCATABLE.
Должен иметь значения 1, 2 или 4. Параметр <length>
назначает
специфицированное значение длины <length>
имени <vname>. Если параметр <length> указан, то его
значение
заменяет
значение
атрибута
длины,
специфицированное в параметре <bytes>.
Описатель размерности. Данный параметр специфицируется
только в том случае, если <vname> определяется как
массив. Если специфицирован параметр <dim>, оператор
INTEGER объявляет массив <vname>.
Список констант и повторяющихся констант, разделенных
запятыми. Повторяющаяся константа записывается в виде
n*<constant>,
где
n
положительная
ненулевая
целочисленная
константа
(коэффициент
повторения).
Параметр /<values>/, если он специфицирован, определяет
начальные значения для <vname>. Например, следующий
оператор объявляет переменную num как имеющую
тип
INTEGER, устанавливаемую со значением 10:
INTEGER num /10/
ЗАМЕЧАНИЯ
Оператор
INTEGER либо подтверждает, либо заменяет тип для
<vname>, определенный неявно. Имя <vname>
задается
для
всего
программного модуля и не может быть определено любым другим оператором
типа в данном программном модуле.
Если
оба
параметра <bytes> и <length> опущены, то длина
переменной принимается по умолчанию равной значению, задаваемому в
метакоманде $STORAGE.
Операторы INTEGER должны предшествовать в программном модуле всем
исполнительным операторам.
ПРИМЕРЫ
С Примеры операторов INTEGER
INTEGER count, matrix(4, 4), sum*2
INTEGER*2 q, m12*24, ivec(10)*24, z*24(10)
Оператор INTERFACE ТО
--------------------ДЕЙСТВИЕ
Объявляет
параметров.
имя процедуры (функции), ее атрибуты и типы формальных
СИНТАКСИС
INTERFACE TO {<function-statement>│<subroutine-statement>}
(<formal-parameter-declaration(s))
END
Параметр
----------------------function-statement
subroutine-statement
Описание
--------------------------------------------Оператор объявления функции.
Оператор объявления процедуры.
ЗАМЕЧАНИЯ
Оператор определяет процедуру или функцию, специфицированную
после ключевых слов INTERFACE TO.
Спецификация состоит из двух частей: оператора INTERFACE, за
которым следуют операторы объявления процедуры или функции - FUNCTION
или SUBROUTINE. Вторая часть представляет собой список объявлений для
всех формальных параметров процедуры. В интерфейсе могут указываться
только операторы EXTERNAL, INTRINSIC, DIMENSION, END.
Оператор INTERFACE используется для обеспечения корректности
вызывов подпрограмм. Компилятор выполняет проверку числа и типов
параметров
в
вызове
подпрограммы с параметрами, указанными в
интерфейсе. Следует отметить, что интерфейс должен быть указан прежде,
чем будет указана ссылка на подпрограмму.
Атрибуты, используемые в интерфейсе, заменяют
в
процедуре
(функции) описание (определение), принимаемое по умолчанию. Однако,
если пользователь использует атрибут в объявлении процедуры (функции)
или ее параметры, то такой же атрибут должен присутствовать и в
операторе INTERFACE ТО.
ПРИМЕР
INTERFACE TO INTEGER FUNCTION Func (p, d, q)
INTEGER*2 p
REAL d(C)
!required; appears in function definition
REAL*8 q[FAR]
!overrides default in function definition
END
Приведенный выше интерфейс определяет следующую функцию:
INTEGER FUNCTION Func (r, s, t)
INTEGER*2 r
REAL s[C]
REAL*8 t
.
.
.
END
Оператор INTRINSIC
-----------------ДЕЙСТВИЕ
Объявляет, что указанное имя есть имя встроенной функции.
СИНТАКСИС
INTRINSIC <names>
где <names> - одно или более имен встроенных функций.
несколько имен, то они должны разделяться запятыми.
Если
указано
ЗАМЕЧАНИЯ
Пользователь должен задавать имя встроенной функции в операторе
INTRINSIC, если необходимо передать эту встроенную функцию в качестве
параметра.
Каждое
определенное пользователем имя должно указываться в
операторе INTRINSIC только один раз. Имя, указанное в операторе
INTRINSIC, не может быть указано в операторе EXTERNAL. Все имена,
используемые в операторе INTRINSIC, должны быть именами встроенных
функций, "известных системе". Список этих функций приведен в разделе
5.
ПРИМЕР
С Пример оператора INTRINSIC
INTRINSIC SIN, COS
С SIN и COS являются параметрами Calc2:
rezult = Calc2 (SIN, COS)
Оператор LOCKING
---------------ДЕЙСТВИЕ
Позволяет защитить
файлы
и
записи
прямого
доступа
от
несанкционированного доступа других пользователей при работе в сети.
СИНТАКСИС
LOCKING ([UNIT=]<unitspec>
[,ERR=<errlabel>]
[,IOSTAT=<iockeck>]
[,LOCKMODE=<lockmode>]
[,REC=<rec>]
[,RECORDS=<recnum>])
Если параметр UNIT= опущен, то параметр <unitspec> должен быть
первыми параметром. Параметры, за исключением специфицируемых для
устройства <unitspec>, могут указываться в любой последовательности.
Параметр
-----------unitspec
errlabel
iocheck
lockmode
rec
recnum
Описание
-------------------------------------------------------Целочисленное выражение, являющееся номером устройства,
которое "запирается".
Файл, присоединяемый к <unitspec>, должен быть открыт
для прямого доступа.
Метка исполняемого оператора в том же
программном
модуле, где задан данный оператор.
Если
параметр
<errlabel>
указан,
то
при
возникновении
ошибок
ввода/вывода управление передается в оператор с меткой
<errlabel>. Если параметр <errlabel> опущен, то при
возникновении ошибок ввода/вывода будет
генерироваться
сообщение об ошибке. Действие по ошибке ввода/вывода
определяются согласно значения параметра <iocheck>.
Целочисленная переменная, элемент массива или элемент
структуры, которые принимают значение 0, если ошибок не
произошло, и значение положительного целого числа в
противном случае (см. также подразд.3.2.6).
Символьное
выражение,
имеющее
одно
из следующих
значений:
'UNLCK' - "освобождение" заданной области;
'LOCK' - защита заданной области от чтения и записи;
переход в состояние ожидания до тех пор, пока часть
"запертой" области не освободится и не станет доступной
для другого процесса;
'NBLCK' - защита заданной области. Если некоторые записи
уже защищены (другими процессами), то
возвращается
ошибка. Данная "неблочная" защита устанавливается по
умолчанию;
'RLCK' - защита заданной области только для записи.
Для
операции
чтения
действие
данного
параметра
совпадает с действием параметра, имеющего
значение
'LOCK';
'NBRLCK' - защита заданной области только для записи.
Данная "неблочная" защита чтения совпадает с действием
параметра,
имеющего
значение
'NBLCK',
за
тем
исключением, что в данном случае заданная
область
защищена только для операции записи.
В случае, когда пользователь работает с операционной
системой MS-DOS версии меньше 3.0, значения 'LOCK',
'RLCK' и 'NBRLCK' идентичны значению 'NBLCK'.
Целочисленное выражение, значением которого является
номер первой
записи
в
группе
записей,
которые
предполагается защитить или "освободить". Если параметр
опущен, то защищаться будет следующая запись (т.е.
запись,
которая
будет
считана
следующей
при
последовательном считывании).
Целочисленное выражение, значение которого представляет
собой
количество
защищаемых записей. По умолчанию
значение параметра принимается равным 1.
ЗАМЕЧАНИЯ
Оператор
LOCKING
"не
имеет
никакого
результата",
если
пользователь работает с операционной системой MS-DOS версии меньше
3.0.
Если параметром оператора LOCKING является выражение, которое
"вызывает" функцию, то эта функция не должна вызывать выполнение
операторов ввода/вывода или встроенной функции EOF, поскольку в этих
случаях результат будет непредсказуем.
Оператор LOGICAL
---------------ДЕЙСТВИЕ
Спецификация типа LOGICAL для имен, определенных пользователем.
СИНТАКСИС
LOGICAL[*<bytes>]<vname>[[<attrs>]][*<length>][(<dim>)][/<values>/]
[,<vname>[[<attrs>]][*<length>][(<dim>)][/<values>/]]...
Параметр
Описание
------------ --------------------------------------------------------bytes
Должен
иметь
значение
1, 2, 4. Параметр <bytes>
специфицирует длину (в байтах)
элементов,
заданных
оператором LOGICAL. Данное значение может быть заменено
значением параметра <length>.
vname
Символическое
имя
константы,
переменной,
массива,
внешней функции, операторной функции или
встроенной
функции; либо это может быть процедура-функция
или
описатель массива. Параметр <vname> не
может
быть
именем процедуры или головной программы;
attrs
Список
атрибутов, разделенных запятыми.
Для
имени
<vname> допустимы следующие атрибуты: ALIAS, C, EXTERN,
FAR HUGE, NEAR, PASCAL, REFERENCE, VALUE, ALLOCATABLE.
length
Должен иметь значение 1, 2 или 4. Параметр <length>
назначает значение длины <length> имени <vname>. Если
параметр <length>
указан, то его значение заменяет
значение длины атрибута, указанное в параметре <bytes>.
Значение длины <length> устанавливается
метакомандой
$STORAGE.
dim
Описатель размерности. Если параметр <dim> задан, то
оператор LOGICAL объявляет имя <vname> как имя массива.
values
Список констант и повторяющихся констант, разделенных
запятыми. Повторяющиеся константы записываются в виде
n*<constant>, где
n
есть
положительная
ненулевая
целочисленная
константа
(коэффициент
повторения).
Параметр
/<values>/,
если
он
специфицирован,
инициализирует имя <vname>. Следующий оператор, например,
объявляет, что переменная switch имеет тип LOGICAL,
и устанавливает ее в значение .TRUE.:
LOGICAL switch /.TRUE./
ЗАМЕЧАНИЯ
Оператор LOGICAL "подтверждает" или заменяет значение типа имени
<vname>, устанавливаемого неявно. Имя <vname> определено для всего
программного модуля и не может быть определено любым другим оператором
типа, указываемым в данном программном модуле.
Если параметры <bytes> и <length> опущены, то длина переменной по
умолчанию принимается равной значению,
задаваемому
метакомандой
$STORAGE.
Операторы LOGICAL
должны
предшествовать
всем
исполняемым
оператором.
ПРИМЕР
С Примером оператора LOGICAL
LOGICAL switch
LOGICAL*1 flag
Oператор MAP...END MAP
---------------------ДЕЙСТВИЕ
Удаление
STRUCTURE.
группы
объявлений
типов
переменных
внутри оператора
СИНТАКСИС
MAP
<type-declaration(s)>
.
.
.
END MAP
Параметр
Описание
------------------ --------------------------------------------------type-declaration
Объявление переменной; может быть любого типа
(INTEGER,
REAL*8,
CHARACTER
и
т.д.)
или
объявлением RECORD структурного типа.
ЗАМЕЧАНИЯ
Блок MAP...END MAP
должен
появляться
внутри
конструкции
UNION...END UNION.
Внутри отображения может появляться любое число переменных и они
могут быть любой комбинации типов. Переменные сохраняются в памяти
последовательно, в той же последовательности, как они появляются в
операторе МАР.
Также внутри объединения должно быть по крайней мере
два
отображения. Назначение объединения состоит в присвоении двух или
более отображений одной и той же области (ячейке) памяти. В отличие от
оператора EQUIVALENCE языка ФОРТРАН, который "перекрывает" одинарные
переменные или массивы, оператор МАР позволяет в одном и том же
объединении перекрывать группы переменных.
Например, каждое из двух отображений в следующем объединении
содержит три переменных типа REAL*8. Переменная manny распределяет
одну и ту же область памяти для meg, moe и jo.
UNION
MAP
REAL*8 meg, jo, amy
END MAP
MAP
REAL*8 manny, moe, jack
END MAP
END UNION
ПРИМЕРЫ
Внутри
структуры
встроенного типа:
отображения
могут
содержать
переменные
UNION
MAP
CHARACTER*20 string
END MAP
MAP
INTEGER*2 number(10)
END MAP
END UNION
Они
могут
содержать переменные
предыдущих операторах STRUСTURE:
с
типами,
определенными
в
UNION
MAP
RECORD /Cartesian/ xcoord, ycoord
END MAP
MAP
RECORD /Polar/ length, angle
END MAP
END UNION
СМОТРИ ТАКЖЕ
Операторы STRUCTURE...END STRUCTURE, UNION...END UNION
Оператор NAMELIST
----------------ДЕЙСТВИЕ
Объявляет имя группы для множества переменных таким образом, что
они могут читаться или записываться с помощью единственного оператора
READ или WRITE, управляемого именованным списком.
СИНТАКСИС
NAMELIST /<namelst>/ <varlist> [/<namelst>/ <varlist>]
Параметр
Описание
------------ --------------------------------------------------------namlst
Имя для группы переменных.
varlist
Список имен переменных и имен массивов; может не включать
переменных структуры и формальных параметров.
ЗАМЕЧАНИЯ
В именном списке одна переменная может указываться несколько раз.
Любой именной список может появляться в одном программном модуле
более одного раза. Список элементов в конкретном именованном списке
обрабатывается как континуация списка в предыдущем именованном списке
с таким же именем.
Если именованный список используется в операторе WRITE, то список
имен переменных, за которыми следуют их значения, записывается в файл
или отображается на экране.
Если именной список используется в операторе READ, то файл,
присоединяемый
к
устройству
<unit>
или
вводу
пользователя,
просматривается на предмет определения имен в именованном списке и
соответствующих им значений. Последовательность, в которой имена
появляются, не является значимой.
Считываемый файл может включать имена индивидуальных элементов
массивов и символьных переменных подстрок, хотя именованный список и
ограничен одинарными переменными и полными массивами.
Следует отметить, что когда пользователь использует именованный
список в операторе READ
программа
"предполагает",
что
имена
переменных,
вводимых
пользователем, точно соответствуют именам,
задаваемым в
операторе
NAMELIST.
Однако,
когда
используется
метакоманда $TRUNCATE, компилятор усекает все имена переменных до
шести символов. В этих условиях программа может не
разпознать
оригинальное,
не
усеченное
имя;
пользователь должен ввводить
сокращенные варианты имен.
Например, если переменная NAMELIST есть impedance и пользователь
использует метакоманду $TRUNCATE, то оператор READ, использующий
именованный список, будет рассматривать ее как impeda, а не как
impedance.
ПРИМЕР
INTEGER
LOGICAL
REAL
COMPLEX
CHARACTER
i1*1,
l1*1,
r4*4,
z8*8,
c1*1,
i2*2, i4*4, iarray(3)
l2*2, l4*4,
r8*8
z16*16
c10*10
NAMELIST /example/ i1*1, i2*2, i4*4, l1, l2, l4, r4, r8,
+
z8, z16, c1, c10, iarray
i1 = 11
i2 = 12
i4 = 14
l1 = .TRUE.
l2 = .TRUE.
l4 = .TRUE.
r4 = 24.0
r8 = 28.0d0
z8 = (38.0, 0.0)
z16 = (316.0d0, 0d0)
c1 = 'A'
c10 = '0123456789'
iarray(1) = 41
iarray(2) = 42
iarray(3) = 43
WRITE (*, example)
Результат будет следующий:
&EXAMPLE
I1
=
11
I2
=
12
I4
=
14
L1 = T
L2 = T
L4 = T
R4 =
24.000000
R8 =
28.000000000000000
Z8 =
(38.000000, 0.000000E+00)
Z16 =
(316.000000000000000, 0.000000000000000E+000)
C1 = 'A'
C10 = '0123456789'
IARRAY =
41
42
43
Если
операция
чтения,
управляемая
именованным
списком,
выполняется с использованием оператора READ (*, example) со следующими
вводными данными:
&example
I1=99
L1=F
R4=99.0
Z8=(99.0, 0.0)
C1='Z'
IARRAY(1)=99
/
то второй оператор WRITE (*,example) будет генерировать следующий
результат:
&EXAMPLE
I1
=
99
I2
=
12
I4
=
14
L1 = F
L2 = T
L4 = T
R4 =
99.000000
R8 =
28.000000000000000
Z8 =
(99.000000, 0.000000E+00)
Z16 =
(316.000000000000000, 0.000000000000000E+000)
C1 = 'Z'
C10 = '0123456789'
IARRAY =
99
42
43
/
Оператор OPEN
------------ДЕЙСТВИЕ
Связывает номер устройства с внешним устройством
внешнем устройстве.
или
файлом
на
СИНТАКСИС
OPEN ([UNIT=]<unitspec>
[,ACCESS=<access>]
[,BLANK=<blanks>]
[,BLOCKSIZE=<blocksize>]
[,ERR=<errlabel>]
[,FILE=<file>]
[,FORM=<form>]
[,IOSTAT=<iocheck>]
[,MODE=<mode>]
[,REAL=<recl>]
[,SHARE=<share>]
[,STATUS=<status>])
Если
опущена
необязательная
строка UNIT=, тогда параметр
<unitspec> должен быть первым параметром. Остальные параметры могут
указываться в любом порядке.
Параметр
----------unitspec
access
blanks
blocksize
errlabel
file
Описание
--------------------------------------------------------Целочисленное выражение, задающее внешнее устройство.
Символьное выражение; вычисляется со значением 'АPPEND',
'DIRECT', 'SEQUENTIAL' (принимается по умолчанию).
Символьное выражение, вычисляемое со значением 'NULL' или
'ZERO'. Параметр устанавливается в значение 'NULL' (для
использования с дескриптором преобразования BN); пробелы
игнорируются. Если параметр установлен в значение 'ZERO'
(для использования с дискриптором преобразования BZ), то
пробелы будут обрабатываться как нули.
Целочисленное
выражение,
специфицирующее
размер
внутреннего буфера при выполнении операции ввода/вывода
на устройство, специфицируемое как <unitspec> (см. также
подразд.3.2.4.).
Метка исполнительного оператора в том же программном
модуле, где указан оператор. Если параметр <errlabel>
задан,
то
при
возникновении
ошибки
ввода/вывода
управление передается в оператор, помеченный
меткой
<errlabel>.
Если
<errlabel>
опущен,
то
при
возникновении
ошибки
ввода/вывода
генерируется
сообщение об ошибке.
Причины
возникновения
ошибки
ввода/вывода и действия, которые следует предпринять
в
этом
случае,
определяются
значением
параметра
<iocheck>.
Символьное выражение. Если параметр
<file>
опущен,
компилятор создает временный рабочий файл с именем,
уникальным для устройства. Рабочий файл удаляется, если
он явно закрывается, либо если происходит нормальное
завершение
выполнения программы. Если указанное имя
файла есть пустое имя (FILE= ' '), то выполняются
следующие шаги:
Шаг 1. Программа пытается считать имя файла из списка
имен, указанных в командной строке (если
они
там
есть), используемой для активизации программы.
Если
пользователь специфицировал пустой (null) параметр в
командной строке (" "), то ему будет выдана подсказка
о
вводе
соответствующего
имени
файла.
При
исполнении
последовательных
операторов
OPEN
выполняется считывание последовательных параметров из
командной строки.
ШАг 2. Если
таких
операторов
OPEN
больше,
чем
параметров
в командной строке, то программа выдает
подсказки
для
требуемых
имен
файлов.
Подсказка
выводится на устройство, ассоциированное со звездочкой *.
Например, предположим, что следующая команда используется
для активизации программы MYPROG:
myprog first.fil " " third.txt
Программа MYPROG содержит четыре оператора
пустыми именами файлов в следующем порядке:
OPEN
OPEN
OPEN
OPEN
(2,
(4,
(5,
(10,
FILE=
FILE=
FILE=
FILE=
'
'
'
'
OPEN
с
')
')
')
')
Устройств
2
связано с файлом FIRST.FIL. Поскольку
фиктивный (null) параметр был специфицирован в командной
строке для второго имени файла, то оператор OPEN для
устройства 4 будет выдавать следующее сообщение:
File name missing or blank Please enter name UNIT 4?
Устройство 5 связано с файлом THIRD.TXT. Поскольку
других файлов в командной строке специфицировано не
было, оператор OPEN для устройства 10 выдает следующее
сообщение:
File name missing or blank Please enter name UNIT 10?
form
значением
iocheck
mode
Символьное выражение, которое
вычисляется
со
'FORMATTED', 'UNFORMATTED' или 'BINARY'.
Если доступ последовательный, то по умолчанию для <form>
принимается значение 'FORMATTED'; при прямом доступе
принимается значение 'UNFORMATTED'.
Целочисленная переменная, элемент массива или элемент
структуры,
которые
определяются
со
значением
отрицательного целого числа, если встретилась запись
"конец - файла"; со значением "ноль", если ошибок при
выполнении
не
было;
со
значением положительного
целого числа, если возникли некоторые ошибки (см. также
подразд.3.2.6).
Символьное выражение, которое вычисляется со
значением
'READ' (процесс может читать файл), 'WRITE' (процесс
может писать в файл), или 'READWRITE' (процесс может
читать и писать в файл), когда "хвостовые" пробелы
удаляются. Параметр <mode> указывает тип доступа к
файлу, который
выполняется
оригинальным
процессом
(процесс,
который
начально
открыл
файл).
Если
пользователь открывает файл без спецификации параметра
<mode>, то исполняющая система ФОРТРАНа всегда пытается
real
share
status
(в
данном
случае!)
открыть
файл
со
значением
'READWRITE'
параметра
<mode>.
Если
операция
открытия
файла
"оканчивается
неудачей",
то
исполняющая система пытается открыть файл повторно,
сначала
используя
значение
'READ'
для параметра
<mode>, а затем значение 'WRITE'. Следует отметить, что
данное действие не совпадает с
простым
указанием
режима в виде MODE='READWRITE'.
Если
пользователь специфицирует MODE='READWRITE', и
файл не может быть открыт ни для записи ни для чтения,
то попытка открыть файл будет безуспешной. Действие,
принимаемое
(выполняемое)
по
умолчанию
(т.е.
сначала
использование
значения
'READWRITE', затем
'READ', затем 'WRITE'), оказывается
более
гибким.
Следует отметить, что значение параметра STATUS= на
режим <mode> воздействия не оказывает.
Целочисленное
выражение, которое специфицирует длину
каждой записи в байтах. Данный параметр требуется в
случае файлов прямого доступа и игнорируется для файлов
последовательного доступа.
Символьное
выражение.
Допустимыми
для
параметра
<share> являются следующие значения:
Значение
Описание
-------- ----------------------------------------------'COMPAT' Режим совместимости (в DOS принимается по
умолчанию).
Если
файл
открыт
в
данном режиме, то
оригинальный процесс" (т.е. процесс, который
открыл
файл)
может
открывать
файл
любое число раз. Никакой другой "процесс"
открыть этот файл не может. Файл, который
уже открыт в каком-либо другом режиме, не
может быть открыт в режиме совместимости.
'DENYRW' Режим, "закрытый для чтения/записи". Когда
файл открыт в данном режиме, никакой другой
процесс не может открыть данный файл.
'DENYWR' Режим,
"закрытый для записи". Когда файл
открыт в данном режиме, никакой файл не может
открыть этот файл для записи.
'DENYRD' Режим,
"закрытый для чтения". Когда файл
открыт в данном режиме, никакой процесс не
может открыть этот файл для чтения.
'DENYNONE' "Незакрытый режим". Когда файл открывается в
данном
режиме,
то любой процесс может
открыть файл в любом режиме (за исключением
режима совместимости). (См. подразд.3.2.11).
Символьное выражение, вычисляемое со значением 'OLD',
'NEW',
'UNKNOWN'
(принимается
по
умолчанию) или
'SCRATCH'.
Ниже приведен список значений параметра <status>:
Значение
Описание
----------- -------------------------------------------'OLD'
При спецификации значения 'OLD', файл должен
уже существовать. Если файл открывается
со
значением 'OLD' параметра <status>, а файл
еще
не
существует,
то
генерируется
сообщение
об
ошибке.
Если
пользователь
открывает
уже
существующий ('OLD') последовательный файл и
выполняет
операцию
записи
в
файл,
предварительно "не переместившись" в конец
файла, то этот файл переписывается.
(Открытие файла с параметром ACCESS='APPEND'
автоматически выполняет позиционирование в
конец файла).
'NEW'
При спецификации значения 'NEW', файл должен
уже
существовать.
Если
пользователь
открывает файл со значением 'NEW' параметра
<status>, а файл не существует, то
файл
создается.
Если
файл
открывается
со
значением 'NEW' параметра <status> и файл
уже
существует,
то
в
этом
случае
генерируется
сообщение
об ошибке. Если
пользователь открывает файл с параметром
STATUS='NEW' и затем
закрывает
его
с
параметром
STATUS
= 'KEEP', либо если
программа
завершается
без
выполнения
операции
закрытия
нового
файла,
то
создается постоянный файл.
'SCRATCH' Если при открытии файла не указано никакого
имени,
то
параметр
<status> принимает
значение
'SCRATCH'.
Рабочие
файлы
являются временными. Они удаляются при явном
закрытии
файла,
либо
по
завершении
выполнения
программы. Пользователь также
может явно открыть поименованный файл с
параметром
STATUS='SCRATCH'.
Он
будет
удаляться (в данном случае!) при завершении
выполнения программы.
'UNKNOWN' Если
файл
открывается
с
параметром
STATUS='UNKNOWN', то компилятор прежде всего
пытается открыть файл со значением 'OLD'
параметра <status>, а затем со значением
'NEW'. Поэтому, если файл существует, то он
открыт; если он не существует,
то
он
создается.
По
умолчанию принимается параметр STATUS='UNKNOWN'.
Использование
состояния
'UNKNOWN'
позволяет
пользователю избегать
ошибок
исполняющей
системы,
возможных
при
открытии
существующего
файла
с
параметром
STATUS='NEW'
или
возможных
при
открытии несуществующего файла с параметром
STATUS='OLD'.
Следует отметить, что значение
состояния
"влияет"
только на дисковые файлы. Если устройство, например
клавиатура или принтер, открыто, то значение параметра
STATUS= игнорируется.
ЗАМЕЧАНИЯ
Открытие файла для устройства, помеченного как звездочка (*), не
имеет смысла, поскольку это устройство постоянно "присоединено" к
клавиатуре и экрану. Пользователь, однако, может использовать оператор
OPEN для присоединения других "предопределенных" устройств (с номерами
0, 5 и 6).
Если пользователь открывает файл, используя номер устройства уже
присоединеного к другому файлу, то уже открытый файл автоматически
закрывается, затем файл с новым именем присоединяется к устройству;
ошибок
при
этом
не возникает. Однако, пользователь не может
присоединить один и тот же файл к более чем одному устройству
одновременно.
Если пользователь использует неявно открытый файл и первой
является операция READ или
WRITE,
то
исполнительная
система
предпринимает попытку открыть файл как если бы было специфицировано
пустое имя, описанное для параметра <file>.
Если параметром в операторе OPEN является выражение, которое
вызывает функцию, то эта функция не должна вызывать выполнения
операторов ввода/вывода или встроенной функции EOF, поскольку в этих
случаях результаты могут оказаться непредсказуемыми.
ПРИМЕР
В следующем примере выполняется операция открытия файла:
C Выдача пользователю подсказки об имени файла и его чтение
CHARACTER*64 filename
WRITE (*, '(A\)') 'enter file name'
READ (*, '(A)') filename
C Открытие файла для форматного последовательного доступа
C как устройства с номером 7.
C Заметьте, что спецификация указанного метода доступа была не
C ненужна, т.е. он принимается по умолчанию.
OPEN (7, FILE = filename, ACCESS = 'SEQUENTIAL',
+
STATUS='NEW')
В
файла:
следующем
примере выполняется операция открытия существующего
C Открытие существующего файла, созданого редактором,
C с именем DATA3.TXT как устройства 3.
OPEN (3, FILE = 'DATA3.TXT')
Оператор PARAMETR
----------------ДЕЙСТВИЕ
Задает константе символическое имя.
СИНТАКСИС
PARAMETER (<name>=<expression>[,<name>=<expression>]...)
Параметр
Описание
----------- ---------------------------------------------------------name
Символическое имя.
expression Выражение. Выражение <expression> может включать только
символические имена, если они ранее определены в операторе
PARAMETER в том же программном модуле.
Если выражение есть символьная константа, она
может
содержать не более 1957 байтов.
ЗАМЕЧАНИЯ
Если тип выражения <expression> отличается от типа имени <name>,
то любые операции преобразования типов выполняются автоматически.
В отличие от оператора DATA (объявляет начальное значение для
переменной) оператор PARAMETER устанавливает фиксированные значения
для символических констант. Любая попытка изменить символическую
константу
при помощи оператора присваивания или оператора READ
приведет к ошибке этапа компиляции.
Символическое имя не может иметь структурный тип и может не
указываться в спецификации формата.
ПРИМЕРЫ
C Пример 1
PARAMETER (nblocks = 10)
C Пример 2
REAL mass
PARAMETER (mass = 47.3, pi = 3.14159)
C Пример 3
IMPLICIT REAL (L-M)
PARAMETER (loads = 10.0, mass = 32.2)
C Пример 4
CHARACTER*(*) bigone
PARAMETER (bigone = 'This constant is larger than 40
+characters')
Оператор PAUSE
-------------ДЕЙСТВИЕ
Временно
прерывает
выполнение
программы
возможность выполнить команды операционной системы.
и
представляет
СИНТАКСИС
PAUSE[<prompt>]
где <prompt> - либо символьная константа, либо число от 0 до 99.999.
ЗАМЕЧАНИЯ
По
умолчанию
значение:
для
параметра
<prompt>
принимается
следующее
'Please enter a blank line (to continue) or a system command.'
Если в качестве параметра <prompt> задано число, то на экране,
при достижении в программе оператора PAUSE, будет отображено это
число. Если в качестве параметра <prompt> задана строка, то на экране
будет отображена эта строка.
Ниже указаны возможные отклики (ответы) на подсказку и получаемые
при этом результаты:
Если:
--------------------------пользователь вводит команду
пользователь вводит пустую
строку
пользователь вводит слово
COMMAND (в любом регистре)
Тогда:
----------------------------------------команда
исполняется
и
управление
возвращается в программу
управление возвращается в программу
пользователь
может
выполнить
последовательность
команд.
Для
возврата
управления
в
программу
необходимо
набрать
строку
EXIT.
ПРИМЕР
C Пример оператора PAUSE
SUBROUTINE SetDrive ( )
PAUSE 'Please select default drive'.
Генерируется один из следующих результатов:
Please select default drive.
.
.
.
PAUSE 999.
.
.
.
PAUSE- 999
Оператор PRINT
-------------ДЕЙСТВИЕ
Отображение выходных результатов на экран.
СИНТАКСИС
PRINT (*,│<formatspec>│ <namelist>)[,<iolist>]
Параметр
-----------formatspec
namelist
iolist
Описание
--------------------------------------------------------Спецификатор формата.
Спецификатор именованного списка.
Список ввода/вывода, специфицирующий передаваемые данные.
ЗАМЕЧАНИЯ
Если параметр <formatspec> замещается звездочкой (*), то вывод
будет управляемым списком.
Если используется спецификатор именованного списка, то <iolist>
может не указываться.
Оператор PRINT выполняет операцию вывода данных на устройство,
отмечаемое звездочкой (*).
Список ввода/вывода не может содержать структурных переменных, а
только элементы структуры.
Если параметр в операторе PRINT есть выражение, которое вызывает
функцию, то эта функция не должна активизировать выполнение операторов
ввода/вывода или встроенной функции EOF, поскольку в этих случаях
результаты могут быть непредсказуемыми.
ПРИМЕР
C Следующие два оператора эквивалентны:
PRINT
'(A11)', 'Abbottsford'
WRITE (*,'(A11)') 'Abbottsford'
Оператор PROGRAM
---------------ДЕЙСТВИЕ
Идентифицирует программный модуль как головную программу и задает
ей имя.
СИНТАКСИС
PROGRAM <program-name>
где <programname> - имя, задавамое пользователем головной программе.
Имя программы является глобальным именем. Поэтому, оно не может
совпадать с именем другой внешней процедуры или общего блока. (Оно
также рассматривается как локальное имя для головной программы и "не
должно вступать в конфликт" с любым другим локальным именем в головной
программе). Оператор PROGRAM должен указываться исключительно как
первый оператор головной программы.
ЗАМЕЧАНИЯ
Оператор PROGRAM может указываться в качестве первого оператора
головной программы.
Головной программе всегда по умолчанию назначается имя _main,
дополнительно к любому имени, указываемому в операторе PROGRAM.
ПРИМЕР
PROGRAM Gauss
.
.
.
END
Оператор READ
------------ДЕЙСТВИЕ
Передает данные из файла,
ассоциированного
с
устройством
<unitspec>, в элементы из списка <iolist>, если, однако, при этом не
будет встречена запись "конец-файла" или не произойдет ошибка.
СИНТАКСИС
READ {<formatspec>,│<nmlspec}│
([UNIT=] <unitspec>
[,[{[FMT=] <formatspec>]│[NML=]<nmlspec}]
[,END = <endlabel>]
[,ERR = <errlabel>]
[,IOSTAT = <iocheck>]
[,REC = <rec>])}
<iolist>
Если параметр UNIT= опущен, то <unitspec> должен быть первым
параметром. Если параметры FMT= и NML= опущены, тогда параметр
<nmlspec> или <fmtspec> должен быть вторым параметром. Остальные
параметры могут указываться в любой последовательности.
Параметры
-----------formatspec
unitspec
namlspec
endlabel
Описание
-------------------------------------------------------Спецификатор формата.
Он может быть меткой оператора FORMAT, либо собственно
спецификатором формата.
Параметр <formatspec> требуется для форматной операции
чтения и не должен указываться для бесформатного ввода.
Если в операторе READ опущены параметры UNIT=, END=,
ERR=,
REC=
и
специфицированы
только
параметры
<formatspec> и <iolist>, то такой оператор выполняет
операцию чтения с устройства * (клавиатура).
Спецификатор устройства.
При считывании из внутреннего файла параметр <unitspec>
есть
символьная
подстрока,
символьная переменная,
элемент символьного массива, символьный массив
или
элемент структуры. При считывании из внешнего файла
параметр <unitspec>
есть
целочисленное
выражение,
специфицирующее устройство.
Для внешних операций чтения, спецификатор <unitspec>
задает внешнее устройство; если файл на устройстве
<unitspec> не был открыт оператором OPEN, то выполняется
операция
"неявного
открытия
файла", эквивалентная
оператору со следующим синтаксисом:
OPEN (unitspec ,FILE=' ',
STATUS = 'OLD'
ACCESS = 'SEQUENTIAL',
FORM = form)
где <form> есть 'FORMATTED' для операции четния или
'UNFORMATTED' для операции неформатного чтения.
Если имя файла включается в командную строку исполнения
программы, то это имя будет использоваться для файла.
Если имя файла не включается, то пользователю выдается
соответствующая подсказка (см.
раздел
3
"Система
ввода/вывода").
Спецификатор группы именованного списка. Если параметр
задан, то параметр <iolist>
должен
быть
опущен.
Ввод/вывод, управляемый именованным списком, может быть
разрешен
только
для
файлов,
открытых
для
последовательного доступа.
Метка оператора в том же программном модуле, где указан
и оператор READ.
Если <endlabel> опущен, то считывание данных после
записи
"конец-файла"
приведет
к
ошибке, если,
однако, не специфицированы параметры <errlabel>
или
<iocheck>.
Если <endlabel> указан, то при встрече
errlabel
iocheck
rec
iolist
записи "конец-файла" управление передается в исполнимый
оператор с меткой <endlabel>.
Mетка исполнительного оператора в том же программном
модуле, где указан и сам оператор.
Если <errlabel> указан, то при возникновении ошибки
ввода/вывода
управление
передается
в
оператор с
меткой <errlabel>. Если <errlabel> опущен, то
при
возникновении ошибки ввода/вывода будет генерироваться
сообщение об ошибке. Причины возникновения ошибки и
действия,
которые
следует
выполнить
для
ее
устранения,
определяются в зависимости от значения
параметра <iocheck>.
Целочисленная переменная, элемент целочисленного массива
или элемент структуры, которые принимают значение 0 в
случае отсутствия ошибок, значение -1 в случае, если
встречен
"конец-файла", или значение положительного
целого
числа,
если
ошибки
имели
место.
(см.
подразд.3.2.6).
Выражение
положительного
целого
числа, называемого
номером записи. Параметр указывается только для файлов
прямого
доступа; если параметр <rec> задается для
внутреннего файла или файла последовательного доступа,
то будет генерироваться ошибка (т.е. будут получены
некорректные
результаты);
перед
началом
передачи
данных файл позиционируется в запись с номером <rec>
(первая запись файла имеет номер 1). По умолчанию в
качестве значения параметра <rec> принимается текущая
позиция файла.
Список объектов, в которые передаются значения из файла.
Список
<iolist>
может
не
содержать
структурных
переменных, но может содержать элементы структуры.
ЗАМЕЧАНИЯ
Если файл был открыт с параметром MODE='READWRITE' (принимается
по умолчанию), то пользователю предоставляется возможность попеременно
читать и записывать один и тот же файл, не выполняя при этом каждый
раз операцию его повторного открытия. В случае последовательного
файла, после каждой операции записи необходимо будет выполнять возврат
к началу файла. Операция чтения данных после записи "конец-файла"
может привести к возникновению ошибки. Следует отметить, что данные,
выводимые из двоичного файла, по своим размерам должны соответствовать
данным, записанным в двоичный файл.
При попытке прочитать незаписанную запись результаты
будут
непредсказуемы.
Если параметром оператора READ является выражение,
которое
вызывает функцию, то эта функция не должна активизировать выполнение
операторов ввода/вывода или встроенной функции EOF, поскольку при этом
результаты выполнения будут непредсказуемы.
ПРИМЕР
C Описание двумерного массива
DIMENSION ia(10,20)
C Считывание значений границ массива.
C Эти границы должны быть меньше или равны 10 и 20,
C соответственно.
C Затем выполняется считывание в массив.
C Формат ввода следующий: столбцов - 8; ширина столбца - 5.
READ (3, 990) i1, j1, ((ia(i,j), j = 1, j1),
+ i = 1, i1)
990
FORMAT (2I5, /, (8I5))
Оператор REAL
------------ДЕЙСТВИЕ
Специфицирует тип REAL для имени, определяемого пользователем.
СИНЛАКСИС
REAL[*<bytes>]<vname>[[<attrs>]][*<length>][ (<dim>)[/<values>/]
[,<vname>[[<attrs>]][*<length>][ (<dim>)][/<values>/]]...
Последовательность
обратной.
параметров
<length>
и
<dim>
может
быть
Параметр
Описание
----------- ---------------------------------------------------------bytes
Должен иметь значение 4 или 8. Параметр <bytes> указывает
длину (в байтах) элементов, специфицируемых оператором
REAL. Значение данного параметра может быть заменено
значением параметра <length>.
vname
Символическое
имя
константы,
переменной,
массива,
внешней
внешней
функции,
операторной
функции
или
встроенной
функции;
либо
имя
процедуры-функции
FUNCTION или описатель массива; имя <vname> не может быть
именем процедуры или головной программы.
attrs
Список
атрибутов,
разделенных
запятыми.
Для имени
<vname>
допустимы
следующие
атрибуты:
ALIAS,
C,
EXTERN,
FAR,
HUGE, NEAR, PASCAL, REFERENCE, VALUE,
ALLOCATABLE.
length
Должен иметь значение 4 или 8. Параметр <length> назначает
специфицированное значение длины имени <vname>.
Если
параметр <length> указан, то его
значение
заменяет
значение атрибута, специфицированного параметром <bytes>.
dim
Описатель размерности. Параметр <dim> указывается только в
том случае, если <vname> есть имя массива. Если параметр
<dim> указан, то оператор REAL объявляет массив с именем
<vname>.
values
Список констант и повторяющихся констант, разделенных
запятыми. Повторяющаяся константа записывается в форме
n*constant,
где
n
есть
положительная
ненулевая
целочисленная константа (коэффициент повторения). Параметр
/<values>/, если он указан,
инициализирует
<vname>.
Следующий оператор, например, объявляет переменную num с
типом REAL и устанавливает ей значение 0.0:
REAL num /0.0/
ЗАМЕЧАНИЯ
Оператор REAL либо подтверждает, либо заменяет тип имени <vname>,
принимаемый неявно. Имя <vname> определяется для всего программного
модуля и не может быть определен в любом другом операторе типа в
данном программном модуле.
Если опущены параметры <bytes> и <length>, то по умолчанию
значение длины принимается равным четырем байтам.
Операторы REAL должны предшествовать всем исполняемым операторам.
Типы REAL*8 и DOUBLE PRECISION совпадают.
ПРИМЕРЫ
C Примеры операторов REAL
REAL goof, abs
REAL*4 wx1, wx3*8, wx5, wx6*4
Оператор RECORD
--------------ДЕЙСТВИЕ
Специфицирует тип структуры,
имен, определяемых пользователем.
определяемый
пользователем,
для
СИНТАКСИС
RECORD /<type_name>/<vname>[[<attrs>]][(<dim>)]
[,<vname>[[<attrs>]][(<dim>)]]...
Параметр
Описание
------------ --------------------------------------------------------type_name
Имя структурного типа, определяемого пользователем.
vname
Переменная, массив
или описатель массива
заданного
структурного типа.
attrs
Список атрибутов, разделенных запятыми. Параметр <attrs>
описывает имя <vname>.
dim
Описатель размерности. Специфицируя <dim> имя <vname>
определяется как имя массива.
ЗАМЕЧАНИЯ
Оператор STRUCTURE определяет новый тип данных. Оператор RECORD
присваивает этот новый тип данных переменной. Параметр <type_name>
должен быть определен перед любым появлением оператора RECORD.
Операторы
RECORD
должны
предшествовать
всем
исполняемым
операторам.
ПРИМЕР
STRUCTURE /address/
LOGICAL*2
house_or_apt
INTEGER*2
apt
INTEGER*2
housenumber
CHARACTER*30 street
CHARACTER*20 city
CHARACTER*2
state
INTEGER*4
zip
END STRUCTURE
RECORD /address/ mailing_addr(NEAR)(20), shipping_addr(20)
СМОТРИ ТАКЖЕ
Оператор STRUCTURE.
Оператор RETURN
--------------ДЕЙСТВИЕ
Возвращает управление в вызывающий программный модуль.
СИНТАКСИС
RETURN [<ordinal>]
где <ordinal> - целочисленная константа; определяет позицию для метки
альтернативного возврата в списке формальных параметров процедуры.
ЗАМЕЧАНИЯ
Оператор RETURN указывается только в процедуре или функции.
Выполнение
оператора
RETURN
завершает
выполнение "включенной"
(встроенной) процедуры или функции. Если оператор RETURN указан в
функции,
то значение функции является равным текущему значению
переменной, возвращаемой функцией. Выполнение оператора END в функции
или процедуре эквивалентно выполнению оператора RETURN.
Если фактические параметры оператора CALL содержат спецификатор
альтернативного
возврата,
то
оператор RETURN может возвращать
управление в конкретный оператор, заданный при помощи <ordinal>.
Оператор RETURN в головной программе обрабатывается как оператор
STOP без параметра <message>.
ПРИМЕРЫ
C Пример оператора RETURN
C Данная процедура будет выполняться в цикле до тех пор, пока
C пользователь не введет "Y"
SUBROUTINE Loop
CHARACTER in
10
READ (*, '(A)') in
IF (in .EQ. 'Y') RETURN
GOTO 10
END
Следующий программный
альтернативного возврата:
01
10
20
30
40
фрагмент
представляет
CALL AltRet (i, *10, j, *20, *30)
WRITE (*, *) 'normal return'
GOTO 40
WRITE (*, *) 'I = 10'
GOTO 40
WRITE (*, *) 'I = 20'
GOTO 40
WRITE (*, *) 'I = 30'
CONTINUE
собой
пример
.
.
.
SUBROUTINE
IF (i .EQ.
IF (i .EQ.
IF (i .EQ.
RETURN
AltRet (i, *, j, *, *)
10) RETURN1
20) RETURN2
30) RETURN3
В данном примере подпрограммы с метками альтернативного возврата,
после которых указан оператор RETURN, оператор RETURN1 указывает на
возврат в первую метку альтернативного возврата в списке; RETURN2
специфицирует возврат во вторую метку альтернативного возврата, а
RETURN3 - специфицирует третью метку альтернативного возврата.
Оператор REWIND
--------------ДЕЙСТВИЕ
Репозиционирование файла в его первую запись.
СИНТАКСИС
REWIND {<unitspec>│
([UNIT=]<unitspec>
[,ERR = <errlabel>]
[,IOLIST=<iocheck>])}
Если параметр UNIT= опущен, то параметр <unitspec> должен быть
первым параметром. В противном случае параметры могут указываться в
любой последовательности.
Параметр
Описание
------------ --------------------------------------------------------unitspec
Целочисленное
выражение,
специфицирующее
внешнее
устройство. Если устройство
<unitspec>
не
открыто,
оператор REWIND "не выполняет никакого действия";
errlabel
Метка исполняемого оператора в том же программном модуле,
что и текущий оператор. Если указан параметр <errlabel>,
то при возникновении ошибок ввода/вывода
управление
передается в оператор с меткой <errlabel>. Если параметр
<errlabel>
опущен,
то
при
возникновении
ошибки
ввода/вывода генерируется сообщение об ошибке. Причина
возникновения
ошибок
и
действия,
которые следует
предпринять для их устранения, определяются согласно
значению параметра <iocheck>.
iocheck
Целочисленная
переменная, элемент массива или элемент
структуры, который
принимает
значение 0, если при
выполнении
операций
ввода/вывода
ошибок
не
произошло, и значение положительного целого числа, в
противном случае (см. также подразд.3.2.6).
ЗАМЕЧАНИЯ
Если параметром оператора REWIND является выражение, в котором
выполняется вызов функции, то эта функция не должна активизировать
выполнение операторов ввода/вывода или встроенной
функции
EOF,
поскольку в этих случаях результат будет непредсказуемым.
ПРИМЕР
INTEGER int(80)
.
.
.
WRITE (7, '(80I1)') int
.
.
.
REWIND 7
.
.
.
READ (7,'(80I1)') int
Оператор SAVE
------------ДЕЙСТВИЕ
Обуславливает возможность сохранения переменными своих значений в
промежутках времени между активизациями процедуры, в которой эти
переменные определены.
СИНТАКСИС
SAVE [<names>]
где <names> - одно или более имен общих блоков (заключены в слэши),
переменных или массивов. Если указывается несколько имен, то они
должны быть разделены запятыми. После
сохранения
поименованные
переменные и все переменные в поименованном общем блоке имеют заданные
значения, если текущая процедура активизируется повторно. По умолчанию
в
качестве
значений <names> принимаются имена всех элементов,
используемых в текущем программном модуле.
ЗАМЕЧАНИЯ
Оператор SAVE не позволяет многократно указывать:
- элементы;
- имена формальных параметров;
- имена процедур;
- имена объектов в общем блоке.
- имена, указываемые в операторе AUTOMATIC.
Общий блок, сохраняемый в одной процедуре (функции) исполняемой
программы,
должен
сохраняться
в
каждой
процедуре (функции),
"содержащей" данный общий блок в исполняемой программе.
ПРИМЕЧАНИЕ
В языке ФОРТРАН все переменные сохраняются по умолчанию. Оператор
SAVE обеспечивает возможность сделать программу переносимой.
ПРИМЕР
C Пример оператора SAVE
SAVE /mycom/, myvar
СМОТРИ ТАКЖЕ
Оператор AUTOMATIC.
Оператор SELECT CASE...END SELECT
--------------------------------ДЕЙСТВИЕ
Управление программой передается в выбранный
определяемых по значению управляющего выражения.
блок
операторов,
СИНТАКСИС
SELECT CASE (<testexpr>)
CASE(<expressionlist>)
[<statementblock>]
[CASE(<expressionlist>)
[<statementblock>]]
.
.
.
[CASE DEFAULT
[<statementblock>]]
END SELECT
Параметр
Описание
--------------- -----------------------------------------------------testepr
Выражение типа INTEGER, LOGICAL или CHARACTER*1.
expressionlist Список значений, которые могут быть константными и
должны
соответствовать
типу
данных
<testexpr>.
Значения должны быть типа INTEGER,
LOGICAL
или
CHARACTER*1. Если <testexpr> соответствует одному из
значений,
то
исполняется
следующий
блок
<statementblock>.
statementblock Один или более исполняемых операторов.
ЗАМЕЧАНИЯ
Существуют два способа включения значений в <expressionlist>.
Первый - задать список отдельных значений, разделенных запятыми.
Второй - специфицировать диапазон значений, разделенных двоеточием,
например 5:10 или 'I':'N'. Нижняя граница должна быть меньше верхней
границы. Если значения символьные, то первый символ должен появляться
перед вторым в последовательности ASCII-кодов.
Если нижняя граница опущена (например,: 10), то все значения,
меньшие или равные верхней границе, будут совпадать. Если опущена
верхняя граница (например, 5:), то все значения, большие или равные
нижней границе, должны совпадать. Оба способа могут быть реалисованы в
одном списке <expressionlist>. Пользователь не может специфицировать
диапазон значений, когда <testexpr> имеет тип LOGICAL. Значение (даже
когда оно неявно специфицировано как часть диапазона значений) может
появляться только в одном списке.
В блоке <statementblock> не требуется содержать исполняемых
операторов. Могут использоваться также и пустые блоки (при этом для
группы значений выражения действия не выполняются).
Оператор CASE DEFAULT является необязательным. Пользователь может
включить в блок SELECT CASE только один оператор CASE DEFAULT.
Если значение <testexpr> не соответствует любому значению в любом
<expressionlist>, то исполнение передается за пределы конструкции
SELECT CASE в следующий исполнительный оператор.
Блоки SELECT CASE могут быть встроенными. Каждый блок должен
иметь "свой собственный" оператор END SELECT; один оператор END SELECT
может прервать выполнение только одного блока.
Если оператор SELECT CASE появляется внутри циклов DO или DO
WHILE, либо внутри конструкций IF, ELSE или ELSE IF; прерывающий
оператор END SELECT должен указываться внутри диапазона значений этого
цикла или структуры.
ПРИМЕР
CHARACTER*1
cmdchar
.
.
.
SELECT CASE (cmdchar)
CASE ('0')
WRITE (*, *) "Must retrieve one to nine files"
CASE ('1':'9')
CALL RetrieveFiles (cmdchar)
CASE ('A', 'd')
CALL AddEntry
CASE ('D', 'd')
CALL DeleteEntry
CASE ('H', 'h')
CALL Help
CASE ('R':'T', 'r':'t')
WRITE (*, *) "REDUCE, SPREAD and TRANSFER commands ",
+
"not yet supported"
CASE DEFAULT
WRITE (*, *) "Command not recognized; please
+re-enter"
END SELECT
Оператор операторной функции
---------------------------ДЕЙСТВИЕ
Определяет функцию как один оператор.
СИНТАКСИС
<fname>([<formals>])=<expression>
Параметр
Описание
------------ --------------------------------------------------------fname
Имя операторной функции.
Имя
<fname>
является
локальным
по
отношению
к
"закрытому" программному модулю
и
не
может
быть
formals
expression
использовано иначе, за исключением случаев, когда оно
используется
как
имя
общего
блока
или как имя
формального параметра другой операторной функции. Если
имя <fname> используется как имя формального параметра
для другой операторной функции, то <fname> должно иметь
один и тот же тип данного при каждом его использовании.
Список имен формальных
параметров. Если указывается
несколько имен, то они разделяются запятыми. Список имен
формальных параметров определяет количество
и
типы
параметров операторной функции.
Областью действия имен формальных параметров является
операторная
функция.
Поэтому,
имена
формальных
параметров
могут повторно использоваться как другие
имена, определенные пользователем, "в оставшейся части
программного модуля", в который
входит
операторная
функция. Если имя <formal> совпадает с другим локальным
именем, тогда <formal>
внутри
операторной
функции
всегда
относится
к формальному параметру, а не к
другому локальному имени. Локальная переменная должна
иметь такой же тип, что и <formal>.
Любое корректное выражение.
Внутри
выражения
<expression>,
разрешено указывать
указатели
переменных,
формальные
параметры, другие
функции,
элементы
массивов
и константы. Указатели
операторных
функций,
однако,
должны
относится
к
операторным
функциям,
определенным
ранее
для
операторной
функции,
в
которой
они
указываются.
Операторные функции не могут
вызываться
рекурсивно
(ни непосредственно, ни косвенным путем).
ЗАМЕЧАНИЯ
Аналогично обычному выражению операторная функция исполняется по
ссылке на нее в выражении.
Типы выражения <expression> и <fname> должны быть совместимы (тип
совместимости совпадает с тем, что используется для ее выражения
expression и переменной <variable> в операторе присвоения). Выражение
<expression> преобразуется к типу <fname>. Фактические параметры
операторной функции преобразуются к типу формальных параметров.
На операторную функцию можно ссылаться только в том программном
модуле, в котором она определена. Имя операторной функции не может
указываться в любом операторе описания, за исключением оператора типа
(который не должен определять это имя как имя массива) и оператора
COMMON (как имя "общего" блока).
ПРИМЕР
DEMENSION x(10)
ADD (a, b) = a + b
DO 100, n = 1, 10
x(n) = Add (y, z)
100 CONTINUE
Оператор STOP
------------ДЕЙСТВИЕ
Завершает выполнение программы.
СИНТАКСИС
STOP[<message>]
где <message> - либо символьная константа, либо целое число,
которого лежат в диапазоне от 0 до 99.999.
значения
ЗАМЕЧАНИЯ
Если не специфицировано ни одного параметра <message>, то на
экране, при завершении выполнения
программы,
будет
отображено
следующее сообщение:
STOP - Program terminated.
Если в качестве сообщения <message> указана символьная константа,
то эта константа, при завершении выполнения программы, отображается на
экране и программа возвращает в операционную систему значение 0 (для
использования
программными
модулями,
принимающими информацию о
состоянии).
Если в качестве значения параметра <message> указано число,
тогда:
- при завершении выполнения программы на экране
печатаются:
строка Return code; затем число, например:
STOP 0400
При
выполнении
следующим:
данного
оператора
выходной
результат
будет
Return code 0400
- программа возвращает младший значащий байт целочисленного
значения (значения от 0 до 255) в операционную систему.
ПРИМЕР
200
IF (ierror .EQ. 0) GOTO 200
STOP 'ERROR DETECTED!'
CONTINUE
STRUCTURE...END STRUCTURE
------------------------ДЕЙСТВИЕ
Определяется новый, составной тип переменной, созданный из других
типов переменных.
СИНТАКСИС
STRUCTURE /<type_name>/
<element_declaration(s)>
.
.
.
END STRUCTURE
Параметр
Описание
-------------------- ------------------------------------------------type_name
Имя
нового
типа
данных,
удовлетворяющего
стандартным соглашениям об именовании. Оно не
должно дублировать имя другой переменной или
встроенной функции и не может
быть
именем
встроенного типа данных, например COMPLEX. Это
имя локальное.
element_declaration Любая комбинация одного или нескольких операторов
ввода переменных или конструкций UNION. Может
включать
оператор RECORD, ранее определяющий
структурные типы.
ЗАМЕЧАНИЯ
Оператор STRUCTURE определяет новый тип переменной, называемый
"структура"; это не является собственно объявлением специфической
переменной
программы.
Для
объявления
переменной
конкретного
структурного типа следует использовать оператор STATEMENT.
Структура образуется из элементов. Простейшим элементом является
простой тип переменной языка ФОРТРАН с фиктивным именем, например:
STRUCTURE /full_name/
CHARACTER*15 first_name
CHARACTER*20 last_name
END STRUCTURE
Элементы не могут быть объявлены без атрибутов. Например, запись
вида INTEGER var[FAR] не разрешена.
Элемент может также быть оператором RECORD, в котором есть ссылка
на ранее описанный тип:
STRUCTURE /full_address/
RECORD /full_name/ personsname
RECORD /address/
ship_to
INTEGER*1
age
INTEGER*4
phone
END STRUCTURE
Элемент также может быть объединением нескольких отображений
переменных.
Имена переменных являются локальными для структуры, в которой они
указаны. Конфликта не возникает, если одно и то же имя элемента
появляется в нескольких структурах. Встроенные структуры могут иметь
элементы с одинаковыми именами.
Конкретный
элемент
специфицируется
путем
перечисления
последовательности элементов, требуемых для "достижения" заданного
элемента; последовательность разделяется точками. Предположим, что
структурная переменная, shippingaddress, была объявлена со структурой
full_address, объявленной в предыдущем примере:
RECORD /full_address/ shippingaddress
Элемент
возраста
затем
будет
специфицироваться
как
shippingaddress.age. Элемент не отличается от любой другой переменной
того же типа. При указании элемента структуры в выражении ее тип есть
тип элемента. При передаче в качестве фактического аргумента он должен
совпадать с типом формального параметра,
последовательностью
и
размерностью.
Длина структуры не может превышать 65.536 байтов. Сюда включаются
все данные, плюс любые дополнительные байты. Способы,
которыми
структура сохраняется в памяти, контролируются при помощи метакоманды
$PACK и опцией /Zp командной строки.
Структуры могут выглядеть аналогичными, но при
этом
быть
различными.
Для
идентичности
двух
структур они должны иметь
совпадающие типы компонентов и в такой же последовательности; должен
совпадать также и способ упаковки структур.
СМОТРИ ТАКЖЕ
Операторы MAP...END MAP, RECORD, UNION...END UNION, $PACK.
Оператор SUBROUTINE
------------------ДЕЙСТВИЕ
Идентифицирует программный модуль как процедуру, задает ей имя,
определяет формальные параметры процедуры.
СИНТАКСИС
SUBROUTINE<subr>[[<sattrs>]][([<formal>[[<attrs>]]
[,<formal>[[<attrs>]]]...])]
Параметр
Описание
----------- ---------------------------------------------------------subr
Определенное
пользователем, глобальное,
внешнее
имя
процедуры. Имя <subr> не может появляться в операторах
AUTOMATIC, COMMON, DATA, EQUIVALENCE, INTRINSIC, LOADDS,
SAVE или в операторах типа.
sattrs
Список
атрибутов,
разделенных
запятыми.
Для имени
процедуры <subr> могут использоваться следующие атрибуты:
ALIAS, C, FAR, NEAR, PASCAL, VARYING.
formal
Определенное
пользователем имя формального параметра.
Если указано несколько имен, то они разделяются запятыми.
Формальный параметр может
быть
простой
переменной,
структурной переменной или встроенной функцией.
Формальный
параметр
может
включать
метку
(*)
альтернативного возврата.
attrs
Список атрибутов, разделенных запятыми. Для имени <formal>
могут использоваться следующие атрибуты:
FAR,
HUGE,
NEAR, REFERENCE, VALUE.
ЗАМЕЧАНИЯ
Процедура начинается оператором SUBROUTINE
и
заканчивается
оператором
END. Она может содержать любые типы операторов, за
исключением оператора PROGRAM, оператора BLOCK
DATA,
оператора
SUBROUTINE, оператора FUNCTION или оператора INTERFACE.
Внутри вызывающей программы процедура <subr> является встроенной
и может быть использована для любых других переменных или подпрограмм.
Список имен
параметров
определяет
число
параметров
для
подпрограммы.
Типы параметров устанавливаются любыми операторами
IMPLICIT, EXTERNAL, операторами типа или операторами DIMENSION внутри
собственно
процедуры.
Типы
параметров
не устанавливаются для
вызывающей программы, даже если подпрограмма появляется в исходном
файле вызывающей программы. Имена параметров не могут указываться в
операторах AUTOMATIC, COMMON, DATA, EQUIVALENCE, INTRINSIC или SAVE.
В операторе CALL передаваемые фактические параметры, которые
относятся к процедуре, должны согласовываться с соответствующими
формальными параметрами в операторе SUBROUTINE; согласование должно
удовлетворяться по последовательности, количеству (за исключением
случаев, когда специфицированы атрибуты C или VARYING) и типам
параметров.
Если формальные параметры известны, тогда компилятор
будет
выполнять процедуру проверки соответствия.
ПРИМЕР
SUBROUTINE GetNum (num, unit)
INTEGER num, unit
10 READ (unit, '(I10)', ERR = 10) num
END
Операторы типа
-------------Операторы типа рассмотрены в соответствующих подразделах данного
раздела, а именно, в подразделах, где приведено описание операторов
CHARACTER,
COMPLEX,
DOUBLE COMPLEX, DOUBLE PRECISION, INTEGER,
LOGICAL, RECORD, REAL, STUCTURE...END STRUCTURE.
UNION...END UNION
----------------ДЕЙСТВИЕ
Предписывает двум или более отображениям занимать одну
область памяти.
и
ту
же
СИНТАКСИС
UNION
<map-statement>
<map-statement>
[<map-statement>]...
END UNION
где <map-statement> - объявление отображения.
ЗАМЕЧАНИЯ
Блок UNION может указываться только внутри блока STRUCTURE.
Каждый блок UNION должен завершаться собственным оператором END UNION;
единственный оператор END UNION не может использоваться для завершения
нескольких блоков UNION.
Оператор UNION совпадает с оператором EQUIVALENCE: оба выполняют
операцию размещения одной и той же области памяти для нескольких
переменных.
Однако,
отображения
могут
содержать
группу
последовательных
переменных,
возможность большей гибкости
одной и той же области памяти.
что
предоставляет
пользователю
при присваивании значений переменным в
ПРИМЕР
Рассмотрим пример назначения первым 40 символам в массиве string2
четырехбайтовых
целых
значений;
оставшимся
20-ти
назначаются
двухбайтовые целые значения:
UNION
MAP
CHARACTER*20 string1, CHARACTER*10 string2(6)
END MAP
MAP
INTEGER*2 number(10), INTEGER*4 var(10), INTEGER*2
+
datum(10)
END MAP
END UNION
Метакоманда $PACK и опция /Zp командной строки выполняют операцию
управления размещением переменных в начальных байтах адресов. (См.
также подразд.6.2).
СМОТРИ ТАКЖЕ
Операторы MAP...END MAP, STRUCTURE...END STRUCTURE, $PACK.
Оператор WRITE
-------------ДЕЙСТВИЕ
Передает данные
из
элементов
списка
<iolist>
ассоциированный с указанным устройством <unitspec>.
в
файл,
СИНТАКСИС
WRITE ([UNIT=]<unitspec>
[,[{[FMT=]<formatspec>][[NML=]<nmlspec}]
[,ERR=<errlabel>]
[,IOSTAT=<iocheck>]
[,REC=<rec>])
<iolist>
Если
(необязательная)
строка
UNIT=
опущена, то параметр
<unitspec> должен быть первым параметром. Если опущены параметры FMT=
или NML=, то параметр <fmlspec> или <nmlspec> должен быть вторым
параметром. В противном случае параметры могут указываться в любой
последовательности.
Параметр
Описание
------------ --------------------------------------------------------unitspec
Спецификатор устройства.
Для внутренней операции вывода, <unitspec> должен быть
символьной
подстрокой,
символьной
переменной,
элементом
символьного
массива, символьным массивом,
несимвольным массивом или структурной переменной. Для
внешней
операции
вывода,
<unitspec>
должен
быть
внешним устройством.
Если файл, ассоциированный с <unitspec>, не был открыт
оператором
OPEN,
то выполняется операция
неявного
открытия, эквивалентная следующему оператору:
OPEN (unitspec, FILE =' ',
+
STATUS ='UNKNOWN',
+
ACCESS ='SEQUENTIAL',
+
FORM
= form)
formatspec
errlabel
iocheck
rec
iolist
где <form> - имеет значение 'FORMATTED для форматного
оператора
WRITE,
и
значение
'UNFORMATTED'
для
бесформатного оператора WRITE.
Спецификатор
формата.
Если
он указан, то параметр
<iolist> должен быть опущен.
Ввод/вывод,
управляемый
именованным
списком,
может
выполняться
только
для
файлов,
открытых
для
последовательного доступа.
Метка исполняемого оператора в том же программном модуле,
где указан и текущий оператор.
Если параметр <errlabel> указан, то при возникновении
ошибки ввода/вывода управление передается в оператор с
меткой
<errlabel>.
Если
же
<errlabel>
опущен,
то
при
возникновении
ошибки
ввода/вывода
будет
генерироваться сообщение об ошибке. Причины возникновения
ошибок
и
действия
по
их
устранению определяются
значением параметра <iocheck>.
Целочисленная переменная, элемент массива или структуры,
который принимает значение 0 в случае отсутствия ошибок,
и
значение
положительного целого числа в противном
случае (см. подразд.3.2.6).
Выражение положительного целого числа, называемого "номер
записи", специфицируемое для файлов прямого доступа и
двоичных
файлов
(только
для
них!)
(в
противном
случае будут получены ошибочные результаты).
Параметр
<rec> специфицирует номер выводимой записи.
Первая запись в файле имеет номер 1. По умолчанию для
параметра <rec> (в качестве его значения) принимается
текущая позиция в файле.
Список объектов, значения которых передаются по оператору
WRITE. Он не может содержать структурных переменных, хотя
элементы структуры и разрешены.
ЗАМЕЧАНИЯ
Если файл был открыт с параметром MODE='READWRITE' (принимается
по умолчанию), пользователь может альтернативно вводить и выводить
данные в один и тот же файл, не выполняя при этом каждый раз операцию
открытия файла. После выполнения оператора вывода необходимо вернуться
в начало файла последовательного доступа.
Ввод в и после
записи
"конец-файла"
может
привести
к
возникновению ошибки. Пользователь не может читать незаписанные записи
в файле прямого доступа.
Если выполняется операция записи в
файл
последовательного
доступа, то все существующие записи, находящиеся после записей,
которые заново записываются, будут удаляться. Следует отметить, что
для
файлов последовательного доступа, после выполнения операции
записи, пользователь оказывается в позиции последней
записанной
записи, и для выполнения последующей операции чтения необходимо
вернуться в начало файла. Кроме того, доступ к файлу может быть
запрещен операционной системой.
Если параметром оператора WRITE является выражение, в котором
выполняется вызов функции, то эта функция не должна активизировать
выполнение
операторов
ввода/вывода или встроенной функции EOF,
поскольку в этих случаях результаты их выполнения могут оказаться
непредсказуемыми.
ПРИМЕР
C Генерация таблицы квадратных и кубических корней
C всех чисел от 1 до 100:
WRITE (*, 10) (n, SQRT(FLOAT(n)), FLOAT(n)**(1.0/3.0),
+
n = 1, 100)
10 FORMAT (I5, F8.4, F8.5)
5. ВСТРОЕННЫЕ ФУНКЦИИ И ДОПОЛНИТЕЛЬНЫЕ ПРОЦЕДУРЫ
Встроенные функции являются предопределенными в языке ФОРТРАН.
Эти функции выполняют преобразования данных и возвращают информацию о
типах данных, выполняют операции над числовыми и символьными данными,
выполняют проверку конца файла, возвращают адреса и реализуют операции
над битами.
В первой части данного раздела приведено детальное описание
встроенных функций, реализованных в языке ФОРТРАН фирмы Microsoft.
Вторая часть представляет собой алфавитный список всех встроенных
функций. Третья часть содержит описание дополнительных функций и
процедур, реализованных в языке ФОРТРАН фирмы Microsoft.
5.1
Использование встроенных функций
"Встроенные функции" являются функциями, составляющими часть
языка
ФОРТРАН. Компилятор распознает их имена и "узнает", что
объектный
код
функции
находится
в
соответствующих
языковых
библиотеках. Встроенные функции автоматически компонуются в программу
без каких-либо дополнительных усилий
со
стороны
программиста.
(Функции, написанные пользователем, называются "внешними" функциями.
Если необходимо написать свою собственную функцию пользователь должен
объявить ее имя в операторе EXTERNAL).
Каждая
функция
возвращает
значение целого, вещественного,
логического или символьного типа и поэтому имеет соответсствующий тип
данных. Например, встроенная функция ICHAR возвращает ASCII-значение
типа символьной строки. Некоторые встроенные функции, например INT,
могут принимать аргументы более чем одного типа. Другие, такие как
ABS, могут возвращать значение, имеющее такой же тип, что и тип
аргумента.
Оператор IMPLICIT не может изменить тип встроенной функции. Для
таких
"порождающих"
встроенных
функций, для которых допустимы
несколько типов параметров, все параметры в одном указателе (ссылке)
должны
быть
одного
типа.
Встроенная функция IDIM, например,
"принимает" два целочисленных параметра и возвращает их положительную
разность. Если специфицировано DIM (i,j), то i и j должны быть одного
типа.
Если, однако, два параметра имеют различные типы данных, то
компилятор прежде всего будет пытаться преобразовать параметры к
корректному типу данных. Например, если i и j в приведенном выше
примере являются вещественными числами, то они сначала преобразуются к
типу INTEGER (см. табл.1.6) и затем выполняется непосредственно сама
операция. Или, если i имеет тип INTEGER*2 и j имеет тип INTEGER*4, то
сначала
i
преобразуется к типу INTEGER*4 и затем выполняется
непосредственно операция.
Имена встроенных функций, за исключением тех, что перечислены в
подразд.2.5, могут указываться в операторе INTRINSIC. Встроенные
операторы,
специфицированные
в
операторах
INTRINSIC,
могут
использоваться как фактические параметры
в
указателях
внешних
процедур. Также имя встроенной функции может быть указано в операторе
типа, но только в том случае, если тип совпадает со стандартным типом
для данной встроенной функции.
Параметры должны удовлетворять и согласовываться с упорядочением,
количеством и типами, указанными в таблицах 5.2 - 5.17. Кроме того,
параметры должны быть выражениями специфицированного типа.
"Порождающие" встроенные функции,
например
ABS,
позволяют
пользователю использовать одно и то же имя встроенной функции с более
чем одним типом аргумента. "Специфические"
встроенные
функции,
например IFIX, могут использоваться только с одним типом аргумента.
Внешняя процедура не может иметь имя, совпадающее с именем
встроенной функции, если однако не используется оператор EXTERNAL.
(Как
результат, встроенная функция с таким именем не может в
дальнейшем использоваться в
программе,
где
оператор
EXTERNAL
ассоциирован с внешней процреурой). В следующем примере sign, float и
index не используются как встроенные функции, а являются внешними
процедурами:
EXTERNAL Sign, Float, Index
SUBROUTINE Process (Sign, Float, Index)
Если задан параметр для которого результат не определяется
автоматически, или для которого результат
превышает
"цифровой"
диапазон
процессора,
то
результат
встроенной
функции
будет
неопределен.
При выполнении логарифмических и тригонометрических функций над
комплексными аргументами
возвращается
так
называемое
"главное
значение". Главным значением комплексного числа является число, чей
параметр меньше или равен числу pi и больше числа -pi.
Когда результаты "порождающей" встроенной функции передаются в
подпрограммы, установка метакоманды $STORAGE задает
тип
данных
передаваемого значения.
ПРИМЕЧАНИЕ
В языке ФОРТРАН фирмы Microsoft реализовано несколько встроенных
функций, длина имен которых превышает шесть символов: ALLOCATED,
EPSILON, LEN_TRIM, LOCNEAR,
MAXEXPONENT,
MINEXPONENT,
NEAREST,
PRECISION.
Если
разрешена метакоманда $TRUNCATE, то компилятор
рассматривает каждое имя функции с аналогичными первыми
шестью
символами как встроенные функции.
В
табл.5.1
объясняются
все
сокращения
(аббревиатуры),
используемые во всех таблицах, в которых описаны встроенные функции.
Таблица 5.1
Аббревиатуры, используемые при описании
встроенных функций
-----------------------------------------------------:Аббревиатура:
Тип данных
:
:------------+---------------------------------------:
:
gen
:Более чем один возможный тип параметра;:
:
:см. графу "Тип параметра" в других
:
:
:таблицах
:
: integer
:INTEGER, INTEGER*1,
:
:
:INTEGER*2 или INTEGER*4
:
:
int1
:INTEGER*1
:
:
int2
:INTEGER*2
:
:
int4
:INTEGER*4
:
:
real
:REAL, REAL*4 DOUBLE
:
:
:PRECISION или REAL*8
:
:
real4
:REAL*4
:
:
dbl
:DOUBLE PRECISION, REAL*8
:
:
log
:LOGICAL, LOGICAL*1
:
:
:LOGICAL*2 или LOGICAL*4
:
:
logl
:LOGICAL*1
:
:
log2
:LOGICAL*2
:
:
log4
:LOGICAL*4
:
:
cmp
:COMPLEX, COMPLEX*8, DOUBLE COMPLEX
:
:
:или COMPLEX*16
:
:
cmp8
:COMPLEX*8
:
:
cmp16
:COMPLEX*16 или DOUBLE COMPLEX
:
:
char
:CHARACTER[*n]
:
-----------------------------------------------------5.1.1
Преобразование типов данных
В данном подразделе описывается "процесс работы" встроенных
функций преобразования
типов
данных;
эти
встроенные
функции
перечислены в табл.5.2.
Таблица 5.2
Встроенные функции: преобразование типов
-------------------------------------------------------------: Имя
: Тип параметра
: Тип функции
:
:-------------------+--------------------+-------------------:
:INT(gen)
:int,real,cmp
:int
:
:INT1(gen)
:int,real, cmp
:INTEGER*1
:
:INT2(gen)
:int,real,cmp
:INTEGER*2
:
:INT4(gen)
:int,real,cmp
:INTEGER*4
:
:INTC(gen)
:int,real, cmp
:INTEGER[C]
:
:IFIX(real4)
:REAL*4
:int
:
:HFIX(gen)
:int,real,cmp
:INTEGER*2
:
:JFIX(gen)
:int,real,cmp
:INTEGER*4
:
:IDINT(dbl)
:REAL*8
:int
:
:
:DOUBLE PRECISION
:
:
:REAL(gen)
:int,real,cmp
:REAL*4
:
:DREAL(cmp16)
:COMPLEX*16
:REAL*8
:
:FLOAT(int)
:int
:REAL*4
:
:SNGL(dbl)
:REAL*8
:REAL*4
:
:DBLE(gen)
:int,real,cmp
:DOUBLE PRECISION
:
:DFLOAT(gen)
:int,real,cmp
:DOUBLE PRECISION
:
:CMPLX(genA[,genB]) :int real, cmp
:COMPLEX*8
:
:DCMPLX(genA[,genB]):int,real,cmp
:COMPLEX*16
:
:ICHAR(char)
:char
:int
:
:CHAR(int)
:int
:char
:
-------------------------------------------------------------Примечание: список используемых сокращений приведен в табл.5.1.
Встроенная функция INT преобразует параметры к типу целые. Если
параметр <gen> имеет тип целый, тогда INT (<gen>) равно <gen>. Если
<gen> имеет тип вещественный, тогда INT (<gen>) равно значению <gen>;
результат округляется. Например, INT (1.9) равно 1, а INT (-1.9) равно
-1.
Если
<gen>
имеет
тип
комплексный,
то сначала берется
действительная часть <gen>; затем действительная часть преобразуется к
типу целый путем округления.
Встроенная функция INT1 преобразует параметры к типу INTEGER*1;
функции INT2 и HFIX преобразуют свои аргументы к типу INTEGER*4. Они
могут использоваться для преобразования типов данных выражения или
переменной к выражению, имеющему корректный тип для процедуры в
качестве
параметра
подпрограммы. Встроенная функция INT2 может
использоваться для "указания" компилятору использовать "короткую"
арифметику (типа "short"), в противном случае используется "длинная"
арифметика (типа "long"); обратное действие выполняет встроенная
функция INT4.
Встроенная функция INTC выполняет преобразование параметров к
типу целых языка Си (они подробно описаны в подразд.1.6.3). Встроенные
функции IFIX и IDINT преобразуют параметры одинарной и двойной
точности, соответственно, к типу целый.
Встроенная функция REAL преобразует числа
к
типу
данных
вещественный с одинарной точностью. Если <gen> имеет тип целый, тогда
REAL (<gen>) имеет значение <gen>, сохраняемое как вещественное число
с одинарной точностью. Если <gen> имеет тип вещественный с одинарной
точностью, тогда REAL (<gen>) равно <gen>. Если <gen> имеет тип
комплексный, тогда REAL (<gen>) равно действительной части <gen>. Если
<gen> представляет собой число с двойной точностью, тогда REAL (<gen>)
"равно" первым шести значащим цифрам в <gen>.
Встроенная функция DBLE преобразует числа к типу вещественный с
двойной точностью. Функции FLOAT и SNGL преобразуют числа к типу
вещественный с одинарной точностью. Они "работают" подобно функции
REAL. Встроенная функция DREAL преобразует числа типа COMPLEX*16 к
типу вещественный с двойной точностью путем удаления мнимой части.
Встроенные функции CMPLX и DCMPLX выполняют преобразования чисел
к типу данных комплексные. Если указан один параметр, <gen>, то он
может быть целым, вещественным, двойной точности или комплексным. В
том случае, если <gen> имеет тип комплексный, то CMPLX (<gen>) равно
<gen>. Если <gen> имеет тип целый, вещественный или двойной точности,
то действительная часть результата равна REAL (<gen>), а мнимая часть
равна 0.0. Если специфицированы два параметра, <gen A> и <gen B>, они
должны быть оба одного типа, и могут быть целыми, вещественными или
двойной точности. В этом случае действительная часть результата равна
REAL (<gen>), а мнимая часть результата равна REAL (<gen B>).
Встроенная функция ICHAR выполняет преобразование ASCII-символов
в целые; встроенная функция CHAR выполняет обратное преобразование.
Для
реализации
преобразования
используется
символьная
последовательность
кодов
ASCII (см. приложение 1). И параметр
встроенной функции CHAR, и результат встроенной функции ICHAR должны
быть больше или равны 0 и меньше или равны 255. Параметр встроенной
функции ICHAR должен быть единственным символом.
ПРИМЕР
Ниже показаны примеры встроенных функций преобразования типов:
Указатель функции
--------------------INT (-3.7)
INT (7.682)
INT (0)
INT ((7.2, 39.3))
5.1.2
Эквивалент
------------3
7
0
7
Информация о типах данных
В данном подразделе описываются встроенные функции, которые
возвращают информацию о типах данных. За исключением функции NEAREST,
переменные, передаваемые как параметры,
не
требуют
назначения
значения; существенным является тип данных параметра. Эти функции
перечислены в табл.5.3.
Таблица 5.3
Встроенные функции: информация о типах данных
-------------------------------------------------------------: Имя
: Тип параметра
: Тип функции
:
:-------------------+--------------------+-------------------:
:ALLOCATED(gen)
: array
: log
:
:EPSILON(real)
: real
: real
:
:HUGE(gen)
: int, real
: Совпадает
:
:
:
: с параметром
:
:MAXEXPONENT(real) : real
: real
:
:MINEXPONENT(real) : real
: real
:
:NEAREST(real,
: real
: real
:
:director)
:
:
:
:PRECISION(real)
: real
: real
:
:TINY(real)
: real
: real
:
-------------------------------------------------------------Встроенная функция ALLOCATED возвращает логическое значение TRUE,
если область памяти в текущий момент занята массивом.
Встроенная
функция EPSILON возвращает наименьший инкремент,
который, при добавлении к единице, генерирует число, большее единицы
для типа данных параметра. Например, вещественное значение одинарной
точности может точно представлять некоторые числа в виде значений,
занимающих
семь десятичных разрядов: EPSILON (real4) возвращает
1.112093Е-07.
Функция EPSILON упрощает выбор значения <delta> для алгоритмов,
выполняющих поиск до тех пор, пока вычисления выполняются в диапазоне
значений <delta>. Если значение <delta> слишком мало, то алгоритм
может
оказаться
бесконечным.
Путем
шкалирования
значения,
возвращаемого функцией EPSILON, пользователь получает такое значение
для <delta>, которое обеспечивает гарантию "конечности" цикла поиска и
вычисления.
Функция
HUGE
возвращает наибольшее положительное значение,
которое может быть представлено типом данных параметров.
Функция
MAXEXPONENT
возвращает
наибольшее
положительное
десятичное значение показателя степени, которое может иметь число.
Например, MAXEXPONENT(real4) возвращает значение 38.
Функция
MINEXPONENT
возвращает
наибольшее
отрицательное
десятичное значение показателя степени, которое может иметь число.
Например, MINEXPONENT (real8) возвращает значение -308.
Функция NEAREST возвращает ближайшее отличное число в направлении
<director>. (Если <director> положительное, то возвращаемое значение
больше, чем <real>. Если <director> отрицательное, то возвращаемое
значени меньше, чем <real>). Как и в случае функции EPSILON, функция
NEAREST
позволяет
программе
выбирать подходящий инкремент для
обеспечения гарантии завершения процедуры выбора.
Функция PRECISION возвращает число значащих десятичных цифр для
типа данных <real>. Использование функции особенно полезно
при
округлении чисел.
Функция TINY возвращает наименьшее положительное число, которое
может быть представлено типом данных параметра.
5.1.3
Отбрасывание (усечение) и округление
В табл.5.4 приведены встроенные
отбрасывания (усечения) и округления.
функции,
выполняющие
операции
Таблица 5.4
Встроенные функции: отбрасывание и округление
---------------------------------------------------------------: Имя
:Отбрасывание
:Тип параметра :Тип функции
:
:
:или округление :
:
:
:------------+---------------+--------------+------------------:
:AINT(real) :
Усечение
:
real
:тот же, что и
:
:
:
:
:параметр
:
:DINT(dbl)
:
- " :
REAL*8
:REAL*8
:
:ANINT(real) : Округление
:
real
:тот же, что и
:
:
:
:
:параметр
:
:DNINI(dbe) :
- " :
REAL*8
:REAL*8
:
:NINT(real) :
- " :
real
:int
:
:IDNINT(dbl) :
- " :
REAL*8
:int
:
---------------------------------------------------------------Встроенные функции AINT и DINT усекают свои параметры. Встроенные
функции ANINT, DNINT, NINT и IDNINT округляют свои параметры и
вычисляются следующим образом:
Параметр
----------Больше нуля
Равно нулю
Меньше нуля
Результат
--------------INT(<gen>+0.5)
ноль
INT (<gen>-0.5)
ПРИМЕРЫ
Ниже приведены примеры операций усечения и округления.
Указатель функции
----------------AINT (2.6)
AINT (-2.6)
ANINT(2.6)
ANINT(-2.6)
Эквивалент
---------2.0
-2.0
3.0
-3.0
В следующей программе для
выполнения
используется встроенная функция ANINT:
операции
округления
C B данной программе к полученной величине прибавляется tax
C и распечатывается результат total
REAL amount, taxrate, tax, total
taxrate = 0.081
amount = 12.99
C вычисляется и округляется величина tax
tax = ANINT (amount * taxrate * 100.0) / 100.0
total = amount + tax
WRITE (*, 100) amount, tax, total
100 FORMAT (1X, 'AMOUNT', F7.2 /
+
1X, 'TAX
', F7.2 /
+
1X, 'TAX
', F7.2)
END
5.1.4
Абсолютное значение и преобразование знака
В табл.5.5 перечислены встроенные функции, вычисляющие абсолютные
значения и выполняющие операцию преобразования знака.
Таблица 5.5
Встроенные функции: абсолютные значения и преобразование знака
--------------------------------------------------------------------: Имя
: Описание
:Тип параметра:Тип функции
:
:--------------------+-----------------+-------------+--------------:
:ABS(<gen>)
:Абсолютн.значение:real, int,
:тип функции
:
:
:
:comp
:совпадает с
:
:
:
:
:типом парамет-:
:
:
:
:ра, за исклю- :
:
:
:
:чением случая :
:
:
:
:комплексного :
:
:
:
:параметра
:
:--------------------+-----------------+-------------+--------------:
:IABS(<int>)
:Абсолютн.значение:int
:int
:
:DABS(dbl)
:Абсолютн.значение:REAL*8
:REAL*8
:
:CABS(<cmp>)
:Абсолютн.значение:cmp
:real (*)
:
:CDABS(<cmp16>)
:Абсолютн.значение:COMPLEX*16
:REAL*8
:
:SIGN(<genA, genB>) :Преобразование
:real или
:тот же, что и :
:
:знака
:int
:тип параметра :
:ISGN(<intA,intB>)
:Преобразование
:int
:int
:
:
:знака
:
:
:
:DSIGN(<dblA,dblB>) :Преобразование
:REAL*8
:REAL*8
:
:
:знака
:
:
:
--------------------------------------------------------------------(*) Если параметр есть COMPLEX*8, то функция будет REAL*4. Если
параметр есть COMPLEX*16, то функция будет REAL*8.
Встроенные функции ABS, IABS, DABS, CABS и CDABS возвращают
абсолютные значения своих параметров. Для комплексного числа вида
(<real>,<imag>) абсолютное значение будет следующим:
(<real>**2 + <imag>**2)**(0.5)
Для двух параметров (genA,genB) встроенные функции SIGN, ISIGN и
DSIGN возвращают значение │genA│, если значение genB больше или равен
нулю, и значение -│genA│, если значение genB меньше нуля.
ПРИМЕРЫ
В
следующей
преобразования знака:
программе
используется
встроенная
функция
a = 5.2
b = -3.1
C следующий оператор передает знак величины b в величину a
C и результат присваивается величине c
c = SIGN (a, b)
C выходной результат равен -5.2
WRITE (*, *) c
END
В следующем примере используются оба типа функций:
(преобразования) знака и получения абсолютного значения:
C
C
C
C
C
C
передачи
В данной программе извлекается квадратный корень векторной
величины. Поскольку в векторе знак указывает направление,
то квадратный корень отрицательного значения не означает,
что будет получен комплексный результат. Данная процедура
"удаляет" знак, вычисляет квадратный корень, а затем
восстанавливает знак.
REAL mag, sgn
WRITE (*, '(A)')' ENTER A MAGNITUDE:
READ (*, '(F10.S)') mag
С Сохранение знака mag путем передачи ее знака в 1
С и сохранение результата в sign:
sgn = SIGN (1.0, mag)
C Вычисляется квадратный корень абсолютной величины
result = SQRT (ABS (mag))
C Восстановление знака путем умножения результата на -1 или +1
result = result * sgn
WRITE (*,*) result
END
5.1.5
Остатки (от деления)
В таблице 5.6 перечислены встроенные функции, которые возвращают
в качестве результатов остатки (от деления).
Таблица 5.6
Встроенные функции: остатки (от деления)
-----------------------------------------------------------------:
Имя
: Тип параметра
: Тип функции
:
:----------------------+------------------+----------------------:
:MOD(<genA, genB>)
:целый или
:тот же, что и параметр:
:
:вещественный
:
:
:AMOD(<real4A,real4B>) :REAL*4
:REAL*4
:
:DMOD(dblA,dblB)
:REAL*8
:REAL*8
:
------------------------------------------------------------------
Встроенные функции MOD, AMOD и DMOD возвращают
результатов остатки (от деления) следующим образом:
в
качестве
MOD (<genA,genB>) = <genA> - (INT(<genA/genB>)*<genB>)
Если значение <genB> равно 0, то результат неопределен.
5.1.6
Положительные разности
В
табл.5.7
перечислены
встроенные
положительные разности двух параметров.
функции,
возвращающие
Таблица 5.7
Встроенные функции: положительная разность
------------------------------------------------------------------: Имя
: Тип параметра
: Тип функции
:
:-----------------+------------------------+----------------------:
:DIM(<genA,genB>) :целый или вещественный :тот же, что и параметр:
:IDIM(<intA,intB>):целый
:целый
:
:DDIM(<dblA.dblB>):REAL*8
:REAL*8
:
------------------------------------------------------------------Встроенные функции DIM, IDIM и DDIM возвращают в качестве
результата положительную разность двух параметров следующим образом:
Если
-----------genA <= genB
genA > genB
Тогда
----------------------------DIM (genA,genB) = 0
DIM (genA,genB) = genA - genB
ПРИМЕРЫ
Указатель функции
----------------DIM (10, 5)
DIM (5, 10)
DIM (10, -5)
Эквивалент
---------5
0
15
5.1.7
Максимумы и минимумы
В
табл.5.8
перечислены
функции,
возвращающие в качестве
результатов максимальное или минимальное значение из двух или более
значений.
Таблица 5.8
Встроенные функции: максимумы и минимумы
---------------------------------------------------------------------:
Имя
:Определение:Тип параметра: Тип
:
:
:
:
: функции :
:--------------------------------+-----------+-------------+---------:
:MAX(genA,genB[,genC]...)
:максимум
:целый или
:совпадает:
:
:
:вещественный :с типом :
:
:
:
:параметра:
:MAXO(intA,intB[,intC]...)
: -":целый
:целый
:
:AMAX (real4A,real4B[,real4C]...): -":REAL*4
:REAL*4
:
:AMAX0(intA,intB[,intC]...)
: -":целый
:REAL*4
:
:MAX1 (real4A,real4B[,real4C]...): -":REAL*4
:целый
:
:AMAX1(dblA,dblB[,dblC]...)
: -":REAL*8
:REAL*8
:
:MIN(genA,genB[,genC]...)
:минимум
:целый или
:совпадает:
:
:
:вещественный :с типом :
:
:
:
:паметра :
:MIN0(intA,intB[,intC]...)
:минимум
:целый
:целый
:
:AMIN1(real4A,real4B[,real4C]...): -":REAL*4
:REAL*4
:
:AMIN0(intA,intB[,intC]...)
: -":целый
:REAL*4
:
:MIN1(real4A,real4B[,real4C]...) : -":REAL*4
:целый
:
:DMIN1(dblA,dblB[,dblC]...)
: -":REAL*8
:REAL*8
:
---------------------------------------------------------------------В качестве результата встроенные функции MAX, MAX0, AMAX1 и DMAX1
возвращают минимальное значение из списка параметров. Встроенные
функции AMAX0 и MAX1 возвращают максимальное значение и, кроме того,
выполняют преобразование типов.
Аналогично,
функции
MIN,
MIN0, AMIN1 и DMIN1 возвращают
минимальные значения; функции AMIN0 и MIN1 возвращают минимальные
значения и, кроме того, выполняют преобразование типов.
ПРИМЕРЫ
Указатель функции
----------------------MAX (5,6,7,8)
MAX (-5., -6., -7.)
MIN (-5, -6, -7)
MIN(.1E12,.1E14,.1E19)
Эквивалент
---------8
-5.
-7
.1E12
В следующей программе используюся встроенные функции MIN и MAX:
C В данной программе используется встроенная функция MAX
C для поиска максимального и минимального элементов вектора x
INTEGER i
REAL
x(10), small, large
DATA x/12.5, 2.7, -6.2, 14.1, -9.1, 17.5, 2., -6.3, 2.5, -12.2/
C Инициализация small и large с произвольными значениями
small = 1e20
large = -1e2
100
200
DO 100, i = 1,10
small = MIN (small,x(i))
large = MAX (large, x (i))
CONTINUE
WRITE (*,200) small, large
FORMAT ('Наименьшее число есть ',F6.1/
+
'Наибольшее число есть ',F6.1)
END
Результатами программы будут следующие значения:
Наименьшее значение есть -12.2
Наибольшее значение есть 17.5
5.1.8
Произведения с двойной точностью
В
табл.5.9
указана встроенная функция, которая возвращает
произведение (результат операции умножения) с двойной точностью.
Таблица 5.9
Встроенная функция: произведение с двойной точностью
----------------------------------------------------:
Имя
: Тип параметра : Тип функции :
:---------------------+---------------+-------------:
:DPROD(real4A,real4B) :
REAL*4
:
REAL*8
:
----------------------------------------------------Встроенная функция DPROD в качестве
результата
возвращает
произведение двойной точности двух вещественных параметров с одинарной
точностью.
ПРИМЕР
В следующей программе используется встроенная функция DPROD:
REAL
a, b
a = 3.72382
b = 2.39265
WRITE (*, *)
a * b, DPROD(a,b)
Результаты выполнения программы будут следующие:
8.9097980
8.90979744044290
5.1.9
Комплексные функции
В табл.5.10 перечислены встроенные функции, выполняющие различные
операции над комплексными числами.
Таблица 5.10
Встроенные функции: комплексные операторы
------------------------------------------------------------------:
Имя
:
Определение
: Тип параметра : Тип функции :
:--------------+-------------------+---------------+--------------:
:AIMAG(cmр8)
:Мнимая часть числа :COMPLEX*8
:REAL*4
:
:
:COMPLEX*8
:
:
:
:IMAG(cmр)
:Мнимая часть
:комплексный
:Если параметр :
:
:комплексного числа :
:имеет тип
:
:
:
:
:COMPLEX*8, то :
:
:
:
:функция имеет :
:
:
:
:тип REAL*4;
:
:
:
:
:если параметр :
:
:
:
:COMPLEX*16, то:
:
:
:
:функция REAL*8:
:DIMAG(cmр16) :Мнимая часть числа :COMPLEX*16
:REAL*8
:
:
:COMPLEX*16
:
:
:
:CONJG(cmр8)
:Сопряженное
:COMPLEX*8
:COMPLEX*8
:
:
:комплексное число :
:
:
:
:COMPLEX*8
:
:
:
:DCONG(cmр16) :Сопряженное
:COMPLEX*16
:COMPLEX*16
:
:
:комплексное число :
:
:
:
:COMPLEX*16
:
:
:
------------------------------------------------------------------Встроенные функции AIMAG, IMAG и DIMAG возвращают в качестве
результата мнимую часть комплексного числа. Встроенные функции CONJG и
DCONJG в качестве результатов возвращают сопряженные комплексные
числа.
Таким
образом, для комплексного числа complex, равного
(real,imag), функция AIMAG (complex) равна imag, а функция CONJG
(complex) выдает значение, равное (real, -imag). Следует отметить, что
встроенные функции REAL и DBLE, описанные в подразд.5.1.1, могут
использоваться для возвращения действительной части чисел COMPLEX*8 и
COMPLEX*16, соответственно.
ПРИМЕР
В
следующей
функции:
программе
используются
встроенные
комплексные
C В данном примере для вычисления многочлена применяется
C квадратичная формула; результаты - комплексные.
100
REAL a, b, c
COMPLEX ans1, ans2, desc
WRITE (*,100)
FORMAT ('Ввод a, b и c многочлена ax^2 + bx + c: ' \)
READ (*, '(3F10.5)') a, b; c
desc = GSQRT (CMPLX (b**2 - 4.0*a*c))
ans1 = (-b + desc) / (2.0 * a)
ans2 = (-b - desc) / (2.0 * a)
WRITE (*,200)
FORMAT (/'Корнями являются:'/)
WRITE (*,300) REAL (ans1), AIMAG(ans1),
+
REAL (ans2), AIMAG(ans2)
300
FORMAT (' X = ',F10.5,' +', F10.5, 'i')
END
200
5.1.10
Квадратные корни
В табл.5.11 перечислены встроенные
качестве результатов квадратные корни.
функции,
возвращающие
в
Таблица 5.11
Встроенные функции: квадратные корни
-------------------------------------------------------------------: Имя
: Тип параметра
: Тип функции
:
:---------------+----------------------------+---------------------:
:SQRT(gen)
:вещественный или комплексный:тот же, что и тип
:
:
:
:параметра
:
:DSQRT(dbl)
:REAL*8
:REAL*8
:
:CSQRT(cmр8)
:COMPLEX*8
:COMPLEX*8
:
:CDSQRT(cmр16) :COMPLEX*16
:COMPLEX*16
:
-------------------------------------------------------------------Встроенные
функции
SQRT,
DSQRT,
CSQRT
и
CDSQRT
в
качестве
результатов возвращают квадратные корни своих параметров. Следует
отметить, что параметры для этих встроенных функций должны быть больше
или равными нулю. Для комплексных параметров встроенные функции SQRT,
CSQRT и CDSQRT возвращают главное значение, у которого действительная
часть больше или равна нулю. Если действительная часть результата
равна нулю, то мнимая часть будет больше или равна нулю.
ПРИМЕР
В следующей программе используется встроенная функция SQRT.
C Данная программа вычисляет длину гипотенузы правильного
C треугольника по длинам его двух сторон.
REAL sidea, sideb, hyp
sidea = 3.0
sideb = 4.0
hyp = sqrt (sidea**2 + sideb**2)
100
WRITE (*, 100) hyp
FORMAT (/'Гипотенуза равна' ,F10.3)
END
5.1.11
Экспоненциальные и логарифмические функции
В табл.5.12 перечислены встроенные функции,
качестве результата степень или логарифм числа.
возвращающие
в
Таблица 5.12
Встроенные функции: степени и логарифмы
--------------------------------------------------------------------: Имя
: Определение
:Тип параметра:Тип функции
:
------------------+--------------------+-------------+--------------:
:EXP(gen)
:Степень
:вещественный :Тот же тип,
:
:
:
:или
:что и тип
:
:
:
:комплексный :параметра
:
:DEXP(dbl)
:Степень
:REAL*8
:REAL*8
:
:CEXP (cmp8)
:Степень
:COMPLEX*8
:COMPLEX*8
:
:CDEXP(cmp16)
:Степень
:COMPLEX*16
:COMPLEX*16
:
:LOG(gen)
:Натуральный логарифм:вещественный :тот же тип,
:
:
:
:или
:что и тип
:
:
:
:комплексный :параметра
:
:ALOG(real4)
:
-":REAL*4
:REAL*4
:
:DLOG(dbl)
:
-":REAL*8
:REAL*8
:
:CLOG(cmp8)
:
-":COMPLEX*8
:COMPLEX*8
:
:CDLOG(cmp16)
:
-":COMPLEX*16
:COMPLEX*16
:
:LOG10(real)
:Общий логарифм
:вещественный :тот же тип,
:
:
:
:
:что и тип
:
:
:
:
:параметра
:
:ALOG10(real4)
:
-":REAL*4
:REAL*4
:
:DLOG10(dbl)
:
-":REAL*8
:REAL*8
:
--------------------------------------------------------------------Встроенные
функции
EXP,
DEXP,
CEXP
и CDEXP всегда возвращают
значения e**<gen>.
Встроенные функции LOG, ALOG, DLOG, CLOG и CDLOG возвращают в
качестве значения натуральный логарифм своих параметров. Встроенные
функции
LOG10, ALOG10 и DLOG10 возвращают в качестве значения
десятичный логарифм своих параметров.
Для всех логирифмических встроенных функций, если
параметр
является вещественным, то он должен быть больше 0. Использование
комплексного параметра (0.0) во встроенных функциях CLOG или LOG не
допустимо. Мнимая часть результата функции CLOG является больше -pi и
меньше или равна pi. Мнимая часть результата функции CLOG есть pi
только тогда, когда действительная часть параметра меньше 0 и мнимая
часть параметра равна 0.
ПРИМЕР
В следующей программе используется встроенная функция EXP.
C
C
C
C
Задавая начальный размер и скорость увеличения колонии,
данная программа расчитывает размер колонии в заданный
момент времени. Предполагается, что скорость уеличения
колонии пропорциональная ее размеру
REAL sizei, sizef, time, rate
sizei = 10000.0
time = 40.5
rate = 0.0875
sizef = sizei * EXP (rate * time)
100
WRITE (*,100) sizef
FORMAT ('THE FINAL SIZE IS', E12.6)
END
5.1.12
Тригонометрические функции
Тригонометрические функции перечислены в табл.5.13.
Таблица 5.13
Встроенные функции: тригонометрические функции
-------------------------------------------------------------------:
Имя
:Определение : Тип параметра :
Тип функции :
:-------------------+------------+----------------+----------------:
:SIN(gen)
:Синус
:вещественный и :тот же тип, что :
:
:
:комплексный
:и тип параметра :
:DSIN(dbl)
:Синус
:REAL*8
:REAL*8
:
:CSIN(cmp8)
:Синус
:COMPLEX*8
:COMPLEX*8
:
:CDSIN(cmp16)
:Синус
:COMPLEX*16
:COMPLEX*16
:
:COS(gen)
:Косинус
:вещественный или:Тот же тип, что :
:
:
:комплексный
:и тип параметра :
:DCOS(dbl)
:Косинус
:REAL*8
:REAL*8
:
:CCOS(cmp8)
:Косинус
:COMPLEX*8
:COMPLEX*8
:
:CDCOS(cmp16)
:Косинус
:KOMPLEX*16
:COMPLEX*16
:
:TAN(real)
:Тангенс
:вещественный или:тот же, что и
:
:
:
:комплексный
:тип параметра
:
:DTAN(dbl)
:Тангенс
:REAL*8
:REAL*8
:
:ASIN(real)
:Арксинус
:вещественный
:тот же тип, что :
:
:
:
:и тип параметра :
:DASIN(dbl)
:
-":REAL*8
:REAL*8
:
:ACOS(real)
:Арккосинус :вещественный
:тот же тип, что :
:
:
:
:и тип параметра :
:DACOS (dbl)
:
-":REAL*8
:REAL*8
:
:ATAN(real)
:Арктангенс :вещественный
:тот же тип, что :
:
:
:
:и тип параметра :
:DATAN(dbl)
:
-":REAL*8
:REAL*8
:
:ATAN2(realA,realB) :Арктангенс :вещественный
:тот же,что и тип:
:
:(realA/realB:
:параметра
:
:DATAN2(dblA,dblB) :Арктангенс :REAL*8
:REAL*8
:
:
:(dblA/dblB) :
:
:
:COTAN(real)
:Котангенс
:вещественный
:тот же тип, что :
:
:
:
:и тип параметра :
:DCOTAN(dbl)
:
-":REAL*8
:REAL*8
:
:SINH(real)
:Гиперболи- :вещественный
:тот же,что и тип:
:
:ческий синус:
:параметра
:
:DSINH(dbl)
:
-":REAL*8
:REAL*8
:
:COSN(real)
:Гиперболичес:вещественный
:тот же,что и тип:
:
:кий косинус :
:параметра
:
:DCOSH(dbl)
:
-":REAL*8
:REAL*8
:
:TANH(real)
:Гиперболичес:вещественный
:тот же тип, что :
:
:кий тангенс :
:и тип параметра :
:DTANH(dbl)
:
-":REAL*8
:REAL*8
:
-------------------------------------------------------------------Значения
всех
углов,
используемых
во
встроенных
тригонометрических функциях, даны в радианах. В табл.5.14 приведены
некоторые
ограничения, накладываемые
на параметры и результаты
выполнения встроенных тригонометрических функций.
Таблица 5.14
Ограничения параметров и результатов
--------------------------------------------------------------------: Функция
: Ограничения параметров
: Диапазон результатов
:
:-----------+---------------------------+---------------------------:
:SIN,DSIN, :
Нет
: Все вещественные числа
:
:COS,
:
:
:
:DCOS,
:
:
:
:TAN,
:
:
:
:DTAN
:
:
:
:-----------+---------------------------+---------------------------:
:ASIN,DASIN :/arg/ <= 1
:-pi/2 <= результат <=pi/2 :
:-----------+---------------------------+---------------------------:
:ACOS,DACOS :/arg/ <= 1
:0 <= результат <= pi
:
:-----------+---------------------------+---------------------------:
:ATAN,DATAN :
Нет
:-pi/2 <= результат <= pi/2 :
:-----------+---------------------------+---------------------------:
:ATAN2,
:
:
:
:DATAN2
:Оба параметра не могут быть:-pi <= результат <= pi
:
:
:равны 0 одновременно
:
:
:-----------+---------------------------+---------------------------:
:COTAN
:Параметр не может быть
: Все вещественные числа
:
:
:равен нулю
:
:
--------------------------------------------------------------------Для
встроенных
функций
ATAN2
и
DATAN2
диапазон
значений
результатов будет следующий:
Параметры
--------------------genA > 0
genA = 0 и genB > 0
genA = 0 и genB < 0
genA < 0
genB = 0
Результат
--------------result > 0
result = 0
result = pi
result < 0
/result/ = pi/2
ПРИМЕР
В следующей программе используются тригонометрические функции.
C Данная программа требует полярные координаты и преобразует
C их в прямоугольные координаты
REAL theta, radius, x, y
WRITE (*,*) 'Введите полярные координаты (radius, angle)'
READ (*, '(2f10.5)') radius, theta
x = radius * COS (theta)
y = radius * SIN (theta)
100
WRITE (*,100) x, y
FORMAT (/' (X,Y) = (',f7.3, ',',F7.3,')')
END
5.1.13
Символьные функции
В табл.5.15 перечислены встроенные функции, выполняющие операции
над символьными константами и переменными.
Таблица 5.15
Встроенные функции: символьные функции
------------------------------------------------------------------: Имя
: Определение
: Тип параметра : Тип функции:
:------------------+-----------------+---------------+------------:
:LGE(charA,charB) :charA >= charB
: char
: log
:
:LGT(charA,charB) :charA > charB
: char
: log
:
:LLE(charA,charB) :charA <=charB
: char
: log
:
:LLT(charA,charB) :charA < charB
: char
: log
:
:LEN(char)
:Длина строки
: char
: int
:
:INDEX(charA,charB :Позиция подстроки: char
: int
:
:[,log])
:charB в строке
:
:
:
:
:charA
:
:
:
:LEN_TRIM(char)
:Длина строки
: char
: int
:
:SCAN(char,charset :Элемент charset : char,log
: int
:
:[,log])
:в char
:
:
:
:VERIFY(char,
:Элемент charset : char,log
: log
:
:charset[,log])
:в char
:
:
:
------------------------------------------------------------------Встроенные функции LGE, LGT, LLE и LLT определяют, является ли
один символьный параметр меньше, больше или равным другому символьному
параметру,
а также используют "сортировочную последовательность"
(последовательность упорядочения) кодов ASCII. Если
сравниваемые
параметры имеют разную длину, то "короткий" параметр дополняется
пробелами справа до длины "длинного" параметра.
Аргумент для функции LEN не должен иметь присвоенного значения.
В качестве результата встроенная функция INDEX возвращает целые
числа, указывающие позицию charB в charA. Если длина charA меньше
длины charB, или если charB "не встречается" в charA, то индекс равен
нулю.
Если charB "встречается" в charA более одного раза, то
встроенная функция INDEX в качестве результата возвращает позицию
"первого charB в charA". Параметр log, когда имеет занчение TRUE,
предписывает выполнить операцию
сравнения
в
конце
строки
и
переместиться в ее начало.
Функция LEM_TRIM возвращает значение длины строкового аргумента,
меньшего числа "хвостовых" пробелов.
Функции SCAN и VERIFY выполняют операцию сравнения с группой
символов в charset. Функция SCAN возвращает значение первой символьной
строки, которая соответствует символу в charset, тогда как функция
VERIFY возвращает значение позиции файла, которая не соответствует
символу в charset. Если совпадений не найдено, либо если строка имеет
нулевую длину, то функция SCAN возвращает значение 0. Функция VERIFY
возвращает значение 0 в случае обнаружения соответствий. Параметр log,
когда имеет значени TRUE, обуславливает выполнение операции сравнения
с конца строки в ее начало.
ПРИМЕР
Ниже приведены примеры символьных встроенных функций:
Указатель функции
-----------------------LLE ('A', 'B')
LLT ('A', 'a')
LEN ('abcdef')
LEN_TRIM ('abc')
INDEX('banana', 'an',
.TRUE.)
SCAN ('banana', 'nbc')
VERIFY ('banana','nbc')
5.1.14
Эквивалент
---------.TRUE.
.TRUE.
6
3
4
1
2
Функция "конец файла"
Встроенная функция "конец-файла" указана в табл.5.16.
Таблица 5.16
Встренные функции: функция "конец файла"
-----------------------------------------------------------: Имя
: Определение
: Тип параметра : Тип функции :
:----------+----------------+----------------+-------------:
:EOF (int) :
Конец файла :
целый
: логический :
-----------------------------------------------------------Если элемент, специфицируемый параметром функции, находится в
записи конца файла или указан после нее, то встроенная функция EOF
(int) возвращает значение .TRUE.; в противном случае возвращаемым
значением является .FALSE. Значением <int> должен быть спецификатор
устройства, соответствующего открытому файлу. Значение <int> не может
быть равно 0, если, однако, пользователь не переназначил нулевой
спецификатор устройству, не являющемуся экраном или клавиатурой.
ПРИМЕР
В следующем примере используется функция "конец-файла".
C Данная программа читает файл целых чисел и
C печатает их среднее значение.
CHARACTER*64 fname
INTEGER
total, count, value
WRITE(*,'(a )') 'Ввести имя файла:'
READ (*,'(a )') fname
C Открыть устойство 1 для ввода (любое устройство, кроме *)
OPEN (1, FILE = fname)
100
total = 0
count = 0
IF (.NOT. EOF(1)) THEN
count = count + 1
read (1, '(I7)') value
total = total + value
GOTO 100
ENDIF
IF (count .GE. 0) THEN
WRITE (*, *) 'Среднее есть:', FLOAT (total) / count
ELSE
WRITE (*, *) 'Входной файл пустой'
ENDIF
END
5.1.15
Адресные функции
В табл.5.17 перечислены встроенные функции,
значения возвращают адреса.
которые
в
качестве
Таблица 5.17
Встроенные функции: адресные функции
--------------------------------------------------------------------:
Имя
:
Определение
:
Тип
: Тип функции :
:
:
:параметра:
:
:---------------+--------------------------+---------+--------------:
:LOCNEAR(gen)
:Несегментированный адрес : Любой
:INTEGER*2
:
:LOCFAR (gen)
:Сегментированный адрес
: Любой
:INTEGER*4
:
:LOC (gen)
:Адрес
: Любой
:INTEGER*2 или :
:
:
:
:INTEGER*4
:
--------------------------------------------------------------------Указанные три встроенные функции в качестве значения возвращают
машинный адрес переменной, передаваемой как фактический параметр.
В приведенном ниже списке показано, как возвращается адрес для
различных типов параметров:
Параметр
-----------------------Выражение, функциональный
вызов или константа
Возвращаемое значение
-------------------------------------Для
хранения результата выражения,
функционального вызова или константы
генерируется
временная
(рабочая)
переменная.
Затем
возвращается ее
адрес.
Возвращается
машинный
адрес
фактического параметра.
Все другие параметры
Значение, возвращаемое встроенной функцией LOCNEAR, эквивалентно
процедуре near или указателю данных в языке Си, либо типу ADR в языке
ПАСКАЛЬ. Аналогично, значение, возвращаемое встроенной функцией LOCFAR
эквивалентно данным типа far или указателю функции в языке Cи, либо
типам ads, adsfunc, или adsproc в языке ПАСКАЛЬ.
Встроенная
функция
LOCNEAR может быть использована только
процедурами NEAR и с объектами, находящимися в сегменте данных,
принимаемом по умолчанию, как например объекты в "общих" блоках NEAR и
объекты, не поименованные в метакомандах $LARGE. Например, встроенная
функция LOCNEAR "не будет работать", когда она
применяется
к
параметру, если этот параметр не указан явно как находящийся в
"сегменте данных по умолчанию". Встроенная функция LOC возвращает либо
указатель типа near, либо указатель типа far, в зависимости от модели
памяти, использовавшейся при компиляции.
5.1.16
Функции "обработки разрядов"
Функции,
выполняющие операции
(битов), приведены в табл.5.18.
обработки
на
уровне
разрядов
Таблица 5.18
Встроенные функции: обработка разрядов
------------------------------------------------------------------:
Имя
:
Определение
:
Тип
:
Тип
:
:
:
:параметра:
функции :
:-----------------+------------------------+---------+------------:
:IOR(intA,intB)
:Включающее ИЛИ
:целый
:тот же тип, :
:
:
:
:что и тип
:
:
:
:
:параметра
:
:ISHL(intA,intB) :Логический сдвиг
: -": -":
:ISHFT(intA,intB) : -": -": -":
:ISHA(intA,intB) :Арифметический сдвиг
: -": -":
:ISHC(intA,intB) :Циклический сдвиг
: -": -":
:IEOR(intA,intB) :Исключающее ИЛИ
: -": -":
:IAND(intA,intB) :Логическое произведение : -": -":
:NOT(intA)
:Логическое дополнение
: -": -":
:IBCLR(intA,intB) :Чистка разряда
: -": -":
:IBSET(intA,intB) :Установка разряда
: -": -":
:IBCHNG(intA,intB):Изменение разряда
: -": -":
:BTEST(intA,intB) :Проверка разряда
: -":Логический :
------------------------------------------------------------------Все перечисленные
в
табл.5.18
встроенные
функции
могут
передаваться
как
фактические параметры. Эти встроенные функции
работают следующим образом:
Функция
------------------Включающее или
Операция
------------------------------------------------Все i-е биты (разряды) результата устанавливаются
следующим образом: если i-ый бит первого или
второго
параметра
"равен"
1, то i-ый бит
результата устанавливается в 1.
Логический сдвиг
Если intB больше или равен 0, то intA логически
сдвигается влево на intB разрядов. Если intB
меньше нуля, то intA сдвигается вправо на intB
разрядов.
Арифметический сдвиг Если
intB
больше
или
равен
0, то intA
арифметиче
чески
сдвигается
влево на intB
разрядов. Если intB меньше 0, то intA сдвигается
вправо на intB разрядов.
Циклический сдвиг
Если intB больше или равен 0, intA циклически
сдвигается влево на intB разрядов; если intB
меньше 0, то intA циклически сдвигается вправо
на intB разрядов.
Исключающее ИЛИ
Если i-ые разряды первого и второго параметров
не равны друг другу, тогда i-ый бит результата
устанавливается в 1. В противном случае, i-ый
бит результата устанавливается в 0.
Логическое
Если i-ые разряды первого и второго параметров
произведение
равны
1,
тогда
i-ый
разряд
результата
устанавли вается в 1. В противном случае, i-ый
бит результата устанавливается в 0.
Логическое
Если i-ый разряд параметра есть 1, тогда i-ый
дополнение
разряд
результата
устанавливается
в 0.
В
противном
случае
i-ый
бит
результата
устанавливается в 1.
Чистка разряда
В intA "чистится" (отменяется) intB разряд.
Установка разряда
В intA устанавливается intB разряд.
Изменение разряда
Заменяется значение разряда intB в intA.
Проверка разряда
Если разряд intB в intA установлен в 1, то
возвращается значение .TRUE. В противном случае
возвращается значение .FALSE.
ПРИМЕРЫ
Ниже приведены три примера, показывающие
трех встроенных функций обработки разрядов.
Функция
---------------------IOR(240,90) = 250
IEOR
IAND(240,90)= 80
IAND
показаны
выполнения
Двоичное представление
-----------------------11110000
IOR
01011010
-------11111010
IEOR(240,90)= 170
В
табл.5.19
обработки разрядов.
результат
результаты
11110000
01011010
-------10101010
11110000
01011010
-------01010000
других
встроенных
Таблица 5.19
функций
Примеры обработки разрядов
--------------------------------------------------------: Указатель функции:
IntA
:
Результат
:
:------------------+----------------+-------------------:
:ISHFT(IntA,2)
:1001000011000101: 0100001100010100 :
:ISHFT(IntA,-2)
:1001000011000101: 0010010000110001 :
:ISHA(IntA,3)
:1000000011011000: 0000011011000000 :
:ISHA(IntA,-3)
:1000000011011000: 1111000000011011 :
:ISHC(IntA,3)
:0111000000000100: 1000000000100011 :
:ISHC(IntA,-3)
:0111000000000100: 1000111000000000 :
:NOT(IntA)
:0001110001111000: 1110001110000111 :
:IBCLR(IntA,4)
:0001110001111000: 0001110000101000 :
:IBSET(IntA,14)
:0001110001111000: 0101110001111000 :
:IBCHNG(IntA,S)
:0001110001111000: 0001110001011000 :
:BTEST(IntA,2)
:0001110001111000: .FALSE.
:
:BTEST(IntA,3)
:0001110001111000: .TRUE.
:
--------------------------------------------------------5.2
Алфавитный список встроенных функций
В табл.5.20 приведен алфавитный список всех встроенных функций
языка ФОРТРАН фирмы Microsoft. В табл.5.1 показаны аббревиатуры,
используемые для обозначения различных типов данных.
Таблица 5.20
Встроенные функции
------------------------------------------------------------------:
Имя
: Описание :
Тип
:
Тип
:
:
:
:параметра: функции
:
:-------------------------------:-----------:---------+-----------:
:ABS (gen)
:Абсолютное :int,real,:Тот же, что:
:
:значение
:cmp
:и тип пара-:
:
:
:
:метра,если :
:
:
:
:параметр не:
:
:
:
:есть cmp
:
:-------------------------------:-----------:---------:-----------:
:ACOS (real)
:Аркосинус :real
:Совпадает :
:
:
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:AIMAG (cmp8)
:Мнимая
:
:
:
:
:часть числа:cmp8
:real4
:
:
:cmp8
:
:
:
:-------------------------------:-----------:---------:-----------:
:AINT(real)
:Усечение
:real
:Совпадает :
:
:
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:ALLOCATED(array)
:Статус
:любой
:log
:
:
:размещения :
:
:
:
:массива
:
:
:
:-------------------------------:-----------:---------:-----------:
:ALOG(real4)
:Натуральный:real4
:real4
:
:
:логарифм
:
:
:
:-------------------------------:-----------:---------:-----------:
:ALOG10(real4)
:Логарифм с :real4
:real4
:
:
:основанием :
:
:
:
:10
:
:
:
:-------------------------------:-----------:---------:-----------:
:AMAX0(int A,int B[,int C]...) :Максимум
:int
:real4
:
:-------------------------------:-----------:---------:-----------:
:AMAX1(real4A,real4B[,real4C]..):Максимум
:real4
:real4
:
:-------------------------------:-----------:---------:-----------:
:AMIN0(intA,intB[,intC]...)
:Минимум
:int
:real4
:
:-------------------------------:-----------:---------:-----------:
:AMIN1(real4A,REAL4B[,real4C]..):Минимум
:real4
:real4
:
:-------------------------------:-----------:---------:-----------:
:AMOD(real4A,real4B)
:Остаток (от:real4
:real4
:
:
:деления)
:
:
:
:-------------------------------:-----------:---------:-----------:
:ANINT(real)
:Округление :real
:Совпадает :
:
:
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:ASIN(real)
:Арксинус
:real
:Совпадает :
:
:
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:ATAN(real)
:Арктангенс :real
:Совпадает :
:
:
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:ATAN2(realA,realB)
:Арктангенс :real
:Совпадает :
:
:(realA/
:
:с типом
:
:
: realB)
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:BTEST(intA,intB)
:Проверка
:int
:log
:
:
:разряда
:
:
:
:-------------------------------:-----------:---------:-----------:
:CABS(cmp)
:Абсолютное :cmp
:real (*)
:
:
:значение
:
:
:
:-------------------------------:-----------:---------:-----------:
:СCOS(cmp8)
:Косинус
:cmp8
:cmp8
:
:-------------------------------:-----------:---------:-----------:
:CDABS(cmp16)
:Абсолютное :cmp16
:dbl
:
:
:значение
:
:
:
:-------------------------------:-----------:---------:-----------:
:CDCOS (cmp16)
:Косинус
:cmp16
:cmp16
:
:-------------------------------:-----------:---------:-----------:
:CDEXP(cmp16)
:Экспонента :cmp16
:cmp16
:
:-------------------------------:-----------:---------:-----------:
:CDLOG(cmp16)
:Натуральный:cmp16
:cmp16
:
:
:логарифм
:
:
:
:-------------------------------:-----------:---------:-----------:
:CDSIN(cmp16)
:Синус
:cmp16
:cmp16
:
:-------------------------------:-----------:---------:-----------:
:CDSQRT(cmp16)
:Квадратный :cmp16
:cmp16
:
:
:корень
:
:
:
:-------------------------------:-----------:---------:-----------:
:CEXP(cmp8)
:Экспонента :cmp8
:cmp8
:
:-------------------------------:-----------:---------:-----------:
:CHAR(int)
:Преобразо- :int
:char
:
:
:вание типов:
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:CLOG(cmp8)
:Натуральный:cmp8
:cmp8
:
:
:логарифм
:
:
:
:-------------------------------:-----------:---------:-----------:
:CMPLX(genA[,genB])
:Преобразо- :int,real,:cmp8
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:CONJG(cmp8)
:Сокращенное:cmp8
:cmp8
:
:
:комплексное:
:
:
:
:число типа :
:
:
:
:cmp8
:
:
:
:-------------------------------:-----------:---------:-----------:
:COS(gen)
:Косинус
:real,cmp :Совпадает с:
:
:
:
:типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:COSH(real)
:Гиперболи- :real
:Совпадает с:
:
:ческий ко- :
:типом
:
:
:синус
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:COTAN(real)
:Котангенс :real
:Совпадает с:
:
:
:
:типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:CSIN(cmp8)
:Синус
:cmp8
:cmp8
:
:-------------------------------:-----------:---------:-----------:
:CSQRT(cmp)
:Квадратный :cmp8
:cmp8
:
:
:корень
:
:
:
:-------------------------------:-----------:---------:-----------:
:DABS(dbl)
:Абсолютное :dbl
:dbl
:
:
:значение
:
:
:
:-------------------------------:-----------:---------:-----------:
:DACOS(dbl)
:Аркосинус :dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DASIN(dbl)
:Арксинус
:dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DATAN(dbl)
:Арктангенс :dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DATAN(dblA,dblB)
:Арктангенс :dbl
:dbl
:
:
:(dblA/dblB):
:
:
:-------------------------------:-----------:---------:-----------:
:DBLE(gen)
:Преобразо- :int,real,:dbl
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:DCMPLX(genA[,genB])
:Преобразо- :int,real,:cmp16
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:DCONJG(cmp16)
:Сопряженное:cmp16
:cmp16
:
:
:комплексное:
:
:
:
:число типа :
:
:
:
:cmp16
:
:
:
:-------------------------------:-----------:---------:-----------:
:DCOS(dbl)
:Косинус
:dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DCOSH(dbl)
:Гиперболи- :dbl
:dbl
:
:
:ческий ко- :
:
:
:
:синус
:
:
:
:-------------------------------:-----------:---------:-----------:
:DCOTAN(dbl)
:Котангенс :dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DDIM(dblA,dblB)
:Положитель-:dbl
:dbl
:
:
:ная раз:
:
:
:
:ность
:
:
:
:-------------------------------:-----------:---------:-----------:
:DEXP(dbl)
:Экспонента :dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DFLOAT(gen)
:Преобразо- :int,real,:dbl
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:DIM(genA,genB)
:Положитель-:int,real :Совпадает с:
:
:ная раз:
:типом
:
:
:ность
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:DIMAG(cmp16)
:Мнимая
:cmp16
:dbl
:
:
:часть числа:
:
:
:
:cmp16
:
:
:
:-------------------------------:-----------:---------:-----------:
:DINT(dbl)
:Усечение
:dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DLOG(dbl)
:Натуральный:dbl
:dbl
:
:
:логарифм
:
:
:
:-------------------------------:-----------:---------:-----------:
:DLOG10(dbl)
:Логарифм с :dbl
:dbl
:
:
:основанием :
:
:
:
:10
:
:
:
:-------------------------------:-----------:---------:-----------:
:DMAX1(dblA,dblB[,dblC]...)
:Максимум
:dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DMIN1(dblA,dblB[,dblC]...)
:Минимум
:dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DMOD(dblA,dblB)
:Остаток
:dbl
:dbl
:
:
:от деления :
:
:
:-------------------------------:-----------:---------:-----------:
:DNINT(dbl)
:Округление :dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DPROD(real4A,real4B)
:Произведе- :real4
:dbl
:
:
:ние с двой-:
:
:
:
:ной точ:
:
:
:
:ностью
:
:
:
:-------------------------------:-----------:---------:-----------:
:DREAL(cmp16)
:Преобразо- :cmp16
:dbl
:
:
:вание ти- :
:
:
:
:пов данных :
:
:
:-------------------------------:-----------:---------:-----------:
:DSIGN(dblA,dblB)
:Передача
:dbl
:dbl
:
│
:знака
:
:
:
:-------------------------------:-----------:---------:-----------:
:DSIN(dbl)
:Синус
:dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DSINH(dbl)
:Гиперболи- :dbl
:dbl
:
:
:ческий
:
:
:
:
:синус
:
:
:
:-------------------------------:-----------:---------:-----------:
:DSQRT(dbl)
:Квадратный :dbl
:dbl
:
:
:корень
:
:
:
:-------------------------------:-----------:---------:-----------:
:DTAN(dbl)
:Тангенс
:dbl
:dbl
:
:-------------------------------:-----------:---------:-----------:
:DTANH(dbl)
:Гиперболи- :dbl
:dbl
:
:
:ческий
:
:
:
:
:тангенс
:
:
:
:-------------------------------:-----------:---------:-----------:
:EOF(int)
:Конец файла:int
:log
:
:-------------------------------:-----------:---------:-----------:
:EPSILON(gen)
:Наименьший :real
:real
:
:
:инкремент, :
:
:
:
:больший 1 :
:
:
:-------------------------------:-----------:---------:-----------:
:EXP(gen)
:Экспонента :real,сmр :Совпадает с:
:
:
:
:типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:FLOAT(int)
:Преобразо- :int
:real4
:
│
:вание ти- :
:
:
:
:пов данных :
:
:
:-------------------------------:-----------:---------:-----------:
:HFIX(gen)
:Преобразо- :int,real,:int2
:
:
:вание типов:сmр
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:HUGE(gen)
:Наибольшее :int,real,:Совпадает :
:
:положитель-:
:с типом
:
:
:ное число :
:параметра :
:-------------------------------:-----------:---------:-----------:
:IABC(int)
:Абсолютное :int
:int
:
:
:значение
:
:
:
:-------------------------------:-----------:---------:-----------:
:IAND(intA,intB)
:Логическое :int
:Совпадает с:
:
:произведе- :
:типом
:
:
:ние
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:IBCHNG(intA,intB)
:Изменение :int
:Совпадает с:
:
:разряда
:
:типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:IBCLR(intA,intB)
:Чистка
:int
:Совпадает с:
:
:разряда
:
:типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:IBSET(intA,intB)
:Установка :int
:Совпадает :
:
:разряда
:
:с типом
:
:
:
:
:разряда
:
:-------------------------------:-----------:---------:-----------:
:ICHAR(char)
:Преобразо- :char
:int
:
:
:вание ти- :
:
:
:
:пов данных :
:
:
:-------------------------------:-----------:---------:-----------:
:IDIM(intA,intB)
:Положитель-:int
:int
:
:
:ная раз:
:
:
:
:ность
:
:
:
:-------------------------------:-----------:---------:-----------:
:IDINT(dbl)
:Преобразо- :dbl
:int
:
:
:вание типов:
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:IDNINT(dbl)
:Округление :dbl
:int
:
:-------------------------------:-----------:---------:-----------:
:IEOR(intA,intB)
:Исключающее:int
:Совпадает :
:
:ИЛИ
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:IFIX(real4)
:Преобразо- │real4
:int
:
:
:вание ти- :
:
:
:
:пов данных :
:
:
:-------------------------------:-----------:---------:-----------:
:IMAG(cmp)
:Мнимая
:cmp
:real(*)
:
:
:часть числа:
:
:
:
:типа сmр
:
:
:
:-------------------------------:-----------:---------:-----------:
:INDEX(charA,charB[,log])
:Размещение :char,log :int
:
:
:подстроки :
:
:
:
:charB в
:
:
:
:
:строке
:
:
:
:
:charA
:
:
:
:-------------------------------:-----------:---------:-----------:
:INT(gen)
:Преобразо- :int,real,:int
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:INT1(gen)
:Преобразо- :int,real,:int1
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:INT2(gen)
:Преобразо- :int,real,:int2
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:INT4(gen)
:Преобразо- :int,real,:int4
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:INTC(gen)
:Преобразо- :int,real,:INTEGER[C] :
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:IOR(intA,intB)
:Включающее :int
:Совпадает :
:
:ИЛИ
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:ISHA(intA,intB)
:Арифмети- :int
:Совпадает :
:
:ческий
:
:с типом
:
:
:сдвиг
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:ISHC(intA,intB)
:Циклический:int
:Совпадает :
:
:сдвиг
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:ISHFT(intA,intB)
:Логический :int
:Совпадает :
:
:сдвиг
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:ISHL(intA,intB)
:Логический :int
:Совпадает :
:
:сдвиг
:
:с типом
:
:
:
:
:параметра :
:-------------------------------:-----------:---------:-----------:
:ISIGN(intA,intB)
:Передача
:int
:int
:
:
:знака
:
:
:
:-------------------------------:-----------:---------:-----------:
:JFIX(gen)
:Преобразо- :int,real,:int4
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:LEN(char)
:Длина стро-:char
:int
:
:
:ки
:
:
:
:-------------------------------:-----------:---------:-----------:
:LEN_TRIM(char)
:Длина стро-:char
:int
:
:
:ки без
:
:
:
:
:"хвостовых":
:
:
:
:пробелов
:
:
:
:-------------------------------:-----------:---------:-----------:
:LGE(charA,charB)
:charA >=
:char
:log
:
:
:charB
:
:
:
:-------------------------------:-----------:---------:-----------:
:LGT(charA,charB)
:charA>charB:char
:log
:
:-------------------------------:-----------:---------:-----------:
:LLE(charA,charB)
:charA<=
:char
:log
:
:
:charB
:
:
:
:-------------------------------:-----------:---------:-----------:
:LLT(charA,charB)
:charA<charB:char
:log
:
:-------------------------------:-----------:---------:-----------:
:LOC(gen)
:Адресация :Любой
:int2,int4 :
:-------------------------------:-----------:---------:-----------:
:LOCFAR(gen)
:Сегментная :Любой
:int4
:
:
:адресация :
:
:
:-------------------------------:-----------:---------:-----------:
:LOCNEAR(gen)
:Несегмент- :Любой
:int2
:
:
:ная адреса-:
:
:
:
:ция
:
:
:
:-------------------------------:-----------:---------:-----------:
:LOG(gen)
:Натуральный:real,сmр :Совпадает с:
:
:логарифм
:
:типом пара-:
:
:
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:LOG10(real)
:Логарифм с :real
:Совпадает с:
:
:основанием :
:типом пара-:
:
:10
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:MAX(genA,genB[,genC]...)
:Максимум
:int,real :Совпадает с:
:
:
:
:типом пара-:
:
:
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:MAX0(intA,intB[,intC]...)
:Максимум
:int
:int
:
:-------------------------------:-----------:---------:-----------:
:MAX1(real4A,real4B)
:Максимум
:real4
:int
:
:[,real4C]...)
:
:
:
:
:-------------------------------:-----------:---------:-----------:
:MAXEXPONENT(real)
:Наибольшая :real
:real
:
:
:положитель-:
:
:
:
:ная экспо- :
:
:
:
:нента для :
:
:
:
:типа данных:
:
:
:-------------------------------:-----------:---------:-----------:
:MIN(genA,genB[,genC]...)
:Минимум
:int,real :Совпадает с:
:
:
:
:типом пара-:
:
:
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:MIN0(intA,intB[,intC]...)
:Минимум
:int
:int
:
:-------------------------------:-----------:---------:-----------:
:MIN1(real4A,real4B)
:Минимум
:real4
:int
:
:[real4C]...)
:
:
:
:
:-------------------------------:-----------:---------:-----------:
:MINEXPONENT(real)
:Наибольшая :real
:real
:
:
:отрицатель-:
:
:
:
:ная экспо- :
:
:
:
:нента для :
:
:
:
:типа данных:
:
:
:-------------------------------:-----------:---------:-----------:
:MOD(genA,genB)
:Остаток (от:int,real :Совпадает с:
:
:деления)
:
:типом пара-:
:
:
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:NEAREST(real,director)
:Ближайшее :real
:real
:
:
:значение в :
:
:
:
:направлении:
:
:
:
:знака
:
:
:
:
:<director> :
:
:
:-------------------------------:-----------:---------------------:
:NINT(real)
:Округление :real
:int
:
:-------------------------------:-----------:---------:-----------:
:NOT(intA)
:Логическое :int
:Совпадает с:
:
:дополнение :
:типом пара-:
:
:
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:PRECISION(gen)
:Число знача:real
:real
:
:
:щих цифр
:
:
:
:
:для типов :
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:REAL(gen)
:Преобразо- :int,real,:real4
:
:
:вание типов:cmp
:
:
:
:данных
:
:
:
:-------------------------------:-----------:---------:-----------:
:SCAN(charA,charB[,log])
:Позиция
:char, log:int
:
:
:символа из :
:
:
:
:charB в
:
:
:
:
:charА
:
:
:
:-------------------------------:-----------:---------:-----------:
:SIGN(genA,genB)
:Передача
:int,real :Совпадает с:
:
:знака
:
:типом пара-:
:
:
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:SIN(gen)
:Синус
:real,cmp :Совпадает с:
:
:
:
:типом пара-:
:
:
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:SINH(real)
:Гиперболи- :real
:Совпадает с:
:
:ческий си -:
:типом пара-:
:
:нус
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:SNGL(dbl)
:Преобразо- :dbl
:real4
:
:
:вание ти- :
:
:
:
:пов данных :
:
:
:-------------------------------:-----------:---------:-----------:
:SQRT(gen)
:Квадратный :real,cmp :Совпадает с:
:
:корень
:
:типом пара-:
:
:
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:TAN(real)
:Тангенс
:real
:Совпадает с:
:
:
:
:типом пара-:
:
:
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:TANH(real)
:Гиперболи- :real
:Совпадает с:
:
:ческий тан-:
:типом пара-:
:
:генс
:
:метра
:
:-------------------------------:-----------:---------:-----------:
:TINY(real)
:Возврат
:real
:real
:
:
:наименьшего:
:
:
:
:положитеь- :
:
:
:
:ного числа :
:
:
:
:> 0 для
:
:
:
:
:типов дан- :
:
:
:
:ных
:
:
:
:-------------------------------:-----------:---------:-----------:
:VERIFY(charA,charB[,log])
:Позиция
:char, log:int
:
:
:первого
:
:
:
:
:символа не :
:
:
:
:из charB в :
:
:
:
:charА
:
:
:
------------------------------------------------------------------(*) Если параметр имеет тип COMPLEX*8, то функция имеет тип REAL*4.
Если параметр имеет тип COMPLEX*16, то функция имеет тип DOUBLE
PRECISION.
5.3
Дополнительные процедуры
В настоящей
реализации
языка
ФОРТРАН
введены
некоторые
дополнительные процедуры, реализующие управление и доступ к системным
времени и дате, обеспечивающие возможность получения
и
сброса
информации о кодах ошибок этапа исполнения, возврата параметров
командной строки и генерации псевдослучайных чисел. Эти процедуры
описаны в последующих подразделах.
Указанные
процедуры включены в исполнительную библиотеку и
автоматически компонуются с программой пользователя при вызове. Они,
однако,
не
являются
встроенными функциями. Пользователь может
самостоятельно написать функции с такими же именами, не указывая
ссылки на эти имена в операторе EXTERNAL. Пользовательские функции
будут компоноваться вместо указанных функций.
5.3.1
Функции SETTIM и
Процедуры управления и доступа
к системным времени и дате
SETDAT, а
также
процедуры
GETTIM
и
GETDAT,
предоставляют пользователю возможность использовать системные время и
дату в своих программах. Функции SETTIM и SETDAT выполняют действия по
установке системного времени и даты, соответственно. Процедуры GETTIM
и GETDAT в качестве результатов своей работы возвращают время и дату.
Данные о процедурах управления и доступа к системным времени и дате
приведены в табл.5.21.
Таблица 5.21
Процедуры управления и доступа к системным времени и дате
------------------------------------------------------------------:
Имя
: Описание
:Тип
:Тип
:
:
:
:параметра:функции :
:-----------------------------+----------------+---------+--------:
:GETTIM(ihr.imin.isec. i100th):Получение сис- :INTEGER*2:
:
:
:темного времени :
:
:
:-----------------------------+----------------+---------+--------:
:SETTIM(ihr.imin.isec. i100th):Установка сис- :INTEGER*2:LOGICAL :
:
:темного времени :
:
:
:-----------------------------+----------------+---------+--------:
:GETDAT(iyr.imon.iday)
:Получение сис- :INTEGER*2:
:
:
:темной даты
:
:
:
:-----------------------------+----------------+---------+--------:
:SETDAT(iyr.imon.iday)
:Установка сис- :INTEGER*2:LOGICAL :
:
:темной даты
:
:
:
------------------------------------------------------------------Параметры определяются следующим образом:
Параметр
-----------ihr
imin
isec
i100th
iyr
imon
iday
Описание
-----------------------------часы
(0-23)
минуты (0-59)
секунды (0-59)
сотые доли секунды (0-99)
год (xxxx AD)
месяц (1-12)
день месяца (1-31)
Фактические
параметры, используемые в вызывающих процедурах
GETTIM и GETDAT, должны быть переменными типа INTEGER*2 или элементами
того же типа. Поскольку эти процедуры переопределяют значения своих
параметров, использование выражений других типов запрещено.
Фактические параметры функций SETTIM и SETDAT могут быть любыми
корректными выражениями типа INTEGER*2. Функции SETTIM и SETDAT
возвращают значение TRUE в том случае, если значения системного
времени или даты изменяются; в противном случае возвращается значение
FALSE.
ПРИМЕР
Следующая программа устанавливает дату и время, а затем
их на экране:
C Предупреждение: эта программа будет сбрасывать системное
C значение даты и времени.
$STORAGE:2
печатает
C
C
C
C
C
C
CHARACTER*12 cdate, ctime
LOGICAL SETDAT, SETTIM
DATA cdate / 'The date is' /
DATA ctime / 'The time is' /
IF (.NOT. (SETDAT (2001, 7, 4)))
+
WRITE (*,*) 'SETDAT failed'
установка даты July 4th, 2001:
IF (.NOT. (SETTIM (0, 0, 0, 0)))
+
WRITE (*,*) 'SETTIM failed'
установка времени в значение 00:00:00.00 (полночь)
CALL GETDAT (iyr, imon, iday)
получение даты из системного таймера
CALL GETTIM (ihr, imin, isec, i100Th)
получение времени из системного таймера
cdate, imon, iday, iyr
вывод даты
WRITE (*, '(1X, A, I2.2, 1H:, I2.2, 1H:
+I2.2, 1H., I2.2)')
+ctime, ihr, imin, isec, i100Th
вывод времени в формате xx:xx:xx.xx
END
5.3.2
Процедуры обработки ошибок этапа исполнения
Функция IGETER и процедура ICLRER включены для обеспечения
совместимости с предыдущими версиями компилятора языка ФОРТРАН. Их
функциональные возможности обеспечиваются в настоящей версии языка
ФОРТРАН при помощи параметра IOSTAT (см. подразд.3.2.6).
Функция IGETER вызывается после операции ввода/вывода, которая
включает параметр ERR= или параметр IOSTAT=. Функция возвращает
следующие значения:
Возвращаемое значение
-----------------------0
Отрицательное значение
Положительное значение
Описание
-------------------------------------------Если ошибок не произошло.
Если встретился признак "конец-файла", но
других ошибок не произошло.
Если
встретилась
ошибка.
Возвращаемым
значением
в этом случае является номер
ошибки.
Интерфейс для вызова функции IGETER имеет следующий вид:
INTEGER*2 FUNCTION IGETER (iunit)
INTEGER*2 iunit
.
.
.
END
Процедура ICLRER "сбрасывает" информацию о кодах ошибок этапа
исполнения после того, как ошибка будет обработана "при помощи"
параметров ERR= и IOSTAT=. Интерфейс для обращения к процедуре ICLRER
имеет следующий вид:
SUBROUTINE ICLRER (iunit)
INTEGER*2 iunit
.
.
.
END
5.3.3
Процедуры обработки параметров
командной строки
Функция NARGS возвращает значение общего количества параметров
командной строки, включая команду. Подпрограмма GETARG возвращает n-й
параметр командной строки. Процердура имеет следующий синтаксис:
<numargs> = NARGS()
CALL GETARG(n,buffer,status)
Функция NARGS не принимает параметров. Она также возвращает
значение типа INTEGER*4, независимо от установки метакоманды $STORAGE.
Процедура GETARG принимает три аргумента. Первый, имеющий тип
INTEGER*2, специфицирует позицию заданного аргумента.
Аргумент <buffer> есть символьная переменная, которая возвращает
требуемый параметр командной строки. Если параметр "короче" буфера
<buffer>, то процедура GETARG дополняет буфер пробелами справа. Если
параметр "длиннее" буфера, то процедура GETARG "усекает" параметр.
Параметр <status> имеет тип INTEGER*2 и возвращает значение
состояние процесса исполнения. Если ошибок не обнаружено, то <status>
возвращает число символов в параметре командной строки перед усечением
или дополнением пробелами.
Параметр <status> типа INTEGER*2 возвращает значение <status>.
Если ошибок не обнаружено, то <status> содержит число символов в
параметре командной строки перед усечением или дополнением пробелами.
(Другими словами, <status> есть исходное число символов в параметре
командной строки). Ошибки включают передачу
значения
<status>,
меньшего 1, либо спецификацию позиции параметра, меньшей 0 или большей
чем значение, возвращаемое функцией NARGS. Для всех этих ошибок
<status> возвращает значение -1.
ПРИМЕР
Рассмотрим командную строку следующего вида: ANOVA -g -c -a;
длина буфера - по крайней мере пять символов. Следующие операторы
GETARG возвращают в буфер соответствующие параметры:
Оператор
--------------------CALL GETARG (0,
buffer, status)
Возвращаемая
строка
-------------ANOVA
Возвращаемая
длина
----------------5
CALL GETARG (1,
buffer, status)
-g
2
CALL GETARG (2,
buffer, status)
-c
2
CALL GETARG (3,
buffer, status)
-a
2
CALL GETARG (4,
buffer, status)
undefined
-1
5.3.4
Процедуры обработки псевдослучайных чисел
Процедура
RANDOM
возвращает
вещественное
псевдослучайное
значение, большее или равное 0 и меньшее 1. Подпрограмма SEED изменяет
начальную точку генератора псевдослучайных чисел. Она имеет следующий
синтаксис:
CALL RANDOM(<ranval>)
CALL SEED(<seedval)
Процедура RANDOM принимает единственный параметр типа REAL*4
(с его помощью осуществляется возврат случайного числа).
Процедуа SEED принимает единственный параметр типа INREGER*2. Он
используется
для
создания
стартовой
точки
для
генератора
псевдослучайных чисел.
Если процедура SEED не вызывается перед первым вызовом процедуры
RANDOM, то последняя всегда начинает генерировать случайные значения с
1.
Если
программа
должна
иметь
отличную
псевдослучайную
последовательность при каждом ее запуске на исполнение, следует
использовать
процедуру GETTIM для установки начального значения
генерируемой последовательности случайных чисел.