## 内部：消息数量 %d 超出允许范围。

消息数量超出允许的最大值。它或者大于前端允许的最大消息数量，或者小于 1。

应避免产生此消息。消息目录或编译器安装出错。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。您可以更改代码以使编译器不再试图生成这条消息。

消息标识：INTERNAL_0001

## 内部：消息级别 %d 超出范围。

消息级别超出允许范围。它不在消息系统的消息级别有效范围内。

应避免产生此消息。消息目录或编译器安装出错。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。您可以更改代码以使编译器不再试图生成这条消息。

消息标识：INTERNAL_0002

## 内部：消息系统尝试发布消息出错。

消息系统无法发布用包含在此消息中的消息编号指示的消息。出现此内部错误的原因可能很多，包括：

- 消息编号不在消息系统消息文件中。
  很可能消息编号不在消息目录中或消息目录已经被破坏。
- 消息目录已过期或与尝试发布此消息的编译器版本不匹配。
- 没有正确设置 NLSPATH 环境变量。
- 所有用户内存空间已被编译器或其它编译系统组件用尽，因此在用户的内存分配中没有内存空间。这就造成了没有工作空间的消息系统。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免编译器尝试发布此消息。

消息标识：INTERNAL_0003

## Error:仅在通用接口块中允许 MODULE PROCEDURE 语句。

仅能在具有 generic_spec 的接口块中指定 MODULE PROCEDURE 语句。编译器在没有通用规范的接口块中找到 MODULE PROCEDURE 语句。

消息标识：ERROR_0004

## Error:此语句次序紊乱。

当前语句违犯 Fortran 标准语句排序规则。

消息标识：ERROR_0005

## Error:关键字或标识符必须跟随标签或构造名称。

编译器已找到标签或构造名称。关键字或标识符必须跟随标签或构造名称。以下示例可以阐明这一点。

    10          ! This is an illegal statement
    10 CONTINUE !This is legal; a keyword follows 10

消息标识：ERROR_0006

## Error:在此类语句中不允许出现构造名称。

构造名称仅能出现在 IF-THEN 语句、DO 语句或 SELECT CASE 语句中。构造名称出现在上述语句以外的语句中时，会生成此错误。

消息标识：ERROR_0007

## Error:在派生类型定义中，此语句必须在所有组件定义之前。

在派生类型定义中，此 PRIVATE 或 SEQUENCE 语句跟随一个或多个组件定义。PRIVATE 和 SEQUENCE 语句必须在所有组件定义之前。

消息标识：ERROR_0008

## 内部：尽管未定义，但标签 %s 无向前引用入口。

如果标签的属性入口存在，那么必须在域单元中引用它。如果已引用但从未定义它，那么至少必须有一个向前引用入口以代表非分辨的向前引用。但是，此标签的向前引用链为空。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0009

## Error:在此参数列表中已经定义伪参数“%s”。

伪参数名称在 FUNCTION、SUBROUTINE、ENTRY 或语句函数定义语句的参数列表中多次出现。

消息标识：ERROR_0010

## Log_Warning：因为自由源格式已生效，所以忽略行大小选项。

将源格式设置为自由时会忽略行大小选项，因为此行可以包含最多 132 个字符。使用固定源格式时行大小选项有效，因为 Fortran 标准将行限制到 72 个字符。选项允许将行长度扩展到 80 个字符。

消息标识：LOG_WARNING_0011

## 内部：%s 下溢。

此消息生成自 src_input.m 中的 POP_SRC 宏。源栈已经下溢。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0012

## Ansi：Fortran 要求多入口点函数结果两者都为缺省内在类型。

多入口点函数（带有一个或更多 ENTRY 语句的函数）可以具有这样的入口点，这些入口点仅在所有入口点返回标量和类型为缺省实数、缺省逻辑、双精度实数、缺省复数或缺省整数的结果时，才返回不同声明类型的结果。如果此入口点具有 POINTER 属性，那么所有入口点类型必须相同并且都是指针。编译器允许有相同声明类型的入口点具有不同的种类参数。

消息标识：ANSI_0013

## 限制：可用内存不足，编译无法继续。

在程序编译的过程中，编译器内存不足。请咨询您的产品支持组织并为此作业请求更多的内存。切记程序编译可能仅是在作业空间执行的几个过程之一。

消息标识：LIMIT_0014

## Error:块数据程序单元中不允许此语句。

在块数据程序单元中允许派生类型定义、类型声明语句和以下语句：

    	COMMON
    	DATA
    	DIMENSION
    	END BLOCK DATA
    	EQUIVALENCE
    	IMPLICIT
    	IMPLICIT NONE
    	INTRINSIC
    	PARAMETER
    	POINTER
    	SAVE
    	TARGET
    	TASK COMMON
    	USE

必须在派生类型定义中指定 SEQUENCE 语句，它才能在块数据程序单元内出现。

消息标识：ERROR_0015

## Error:主程序单元中不允许 %s 语句。

主程序单元中不允许以下语句：

    	ENTRY
    	INTENT
    	OPTIONAL
    	PRIVATE
    	PUBLIC
    	RETURN

这些语句必须在构造或包含的域单元内才能出现在主程序单元中：
-- 在派生类型定义中的 SEQUENCE、END TYPE
-- 在通用接口块中的 MODULE PROCEDURE
-- 在 IF 构造中的 ELSE、ELSE IF、END IF
-- 在 CASE 构造中的 CASE、END SELECT
-- 在 WHERE 构造中的 ELSEWHERE、END WHERE
-- 在 DO 构造中的 CYCLE、EXIT、END DO
-- 在接口块中的 FUNCTION、SUBROUTINE
-- 在接口体中的 END FUNCTION
-- 在接口体中的 END SUBROUTINE
-- 在接口块中的 END INTERFACE

消息标识：ERROR_0016

## Error:无法打开文件。此文件用于调试或跟踪。

编译器无法打开调试文件或跟踪文件。

消息标识：ERROR_0017

## Error:在通用接口块中，此语句不能跟随 MODULE PROCEDURE 语句。

接口块的语法是：

    interface_stmt
    [interface_body]...
    [module_procedure_stmt]...
    end_interface_stmt

消息标识：ERROR_0018

## Error:模块中不允许 %s 语句。

在模块中允许派生类型定义、类型声明语句和以下语句（在 END MODULE 或 CONTAINS 语句之前）：

    	ALLOCATABLE
    	COMMON
    	DATA
    	DIMENSION
    	EQUIVALENCE
    	EXTERNAL
    	IMPLICIT
    	IMPLICIT NONE
    	INTERFACE
    	INTRINSIC
    	NAMELIST
    	PARAMETER
    	POINTER
    	PUBLIC
    	PRIVATE
    	SAVE
    	TARGET
    	USE

这些语句必须在接口块或包含的域单元内才能出现在模块程序单元中。
-- 在通用接口块中的 MODULE PROCEDURE
-- 在派生类型定义中的 SEQUENCE、END TYPE
-- 在接口块中的 FUNCTION、SUBROUTINE、END FUNCTION、END SUBROUTINE、END INTERFACE

消息标识：ERROR_0019

## Ansi：使用 DOUBLE COMPLEX 是 Fortran 标准的一个扩展。

DOUBLE COMPLEX 语句不是 Fortran 标准的组成部分。

消息标识：ANSI_0020

## Error:两个入口点的类型属性冲突。

如果多入口函数（带有一个或更多 ENTRY 语句的函数）任何入口点的结果为字符类型或派生类型，那么此函数中的所有入口点必须返回相同类型的结果。如果函数结果类型为字符，那么所有入口点必须返回带有相同声明字符长度的结果。如果结果类型为派生类型，那么所有条目必须是相同的派生类型。

消息标识：ERROR_0021

## Ansi：如果函数结果“%s”的类型与其它入口点的类型不匹配，那么它必须为缺省内在类型。

多入口点函数（带有一个或更多 ENTRY 语句的函数）可以具有入口点，这些入口点仅在所有入口点返回标量结果和类型为缺省实数、缺省逻辑、双精度实数、缺省复数或缺省整数的结果时，才返回不同声明类型的结果。如果此入口点具有 POINTER 属性，那么所有入口点的类型必须相同并且具有 POINTER 属性。

编译器允许缺省和非缺省的实数、逻辑、双精度、复数和整数混合。

消息标识：ANSI_0022

## Error:在此域单元中未定义标签。

引用语句标签后，此标签必须是作为标签引用出现在相同域单元的分支目标语句的语句标签。例如，如果以下 GO TO 语句出现在子程序中，那么必须在同一子程序中定义标签 10。

    GO TO 10

消息标识：ERROR_0023

## Error:不允许将此字符常量用于此 I/O 控制信息列表项。

许多 I/O 控制信息列表项仅允许一组有限的有效字符常量集。遇到对于此控制列表项无效的字符常量。以下为 I/O 控制项及其有效字符常量：

    OPEN I/O 控制
    列表项                   字符常量
    STATUS    OLD、NEW、SCRATCH、REPLACE、UNKNOWN
    ACCESS    SEQUENCTIAL、DIRECT
    FORM      FORMATTED、UNFORMATTED
    BLANK     NULL、ZERO
    POSITION  ASIS、REWIND、APPEND
    ACTION    READ、WRITE、READWRITE
    DELIM     APOSTROPHE、QUOTE、NONE
    PAD       YES、NO

对于 CLOSE I/O 控制列表项 STATUS，允许的字符常量为 KEEP 和 DELETE。

对于 READ/WRITE I/O 控制列表项 ADVANCE，允许的字符常量为 YES 和 NO。

消息标识：ERROR_0024

## Error:派生类型定义中不允许此语句。

在派生类型定义中仅允许 PRIVATE、SEQUENCE 和组件定义语句。如果派生类型定义在模块程序单元中，那么仅能允许 PRIVATE 语句。

消息标识：ERROR_0025

## Error:在接口块中不允许此语句；可以使用 SUBROUTINE、FUNCTION、MODULE PROCEDURE 或 END 语句。

在接口块中仅允许 FUNCTION、SUBROUTINE、MODULE PROCEDURE 和 END INTERFACE 语句。FUNCTION 和 SUBROUTINE 开始接口体。END INTERFACE 结束接口块。如果接口块为通用接口，那么可以指定 MODULE PROCEDURE。通用接口包含能以通用名引用的模块过程列表。

消息标识：ERROR_0026

## Error:函数入口具有结果名称。在声明此结果为数组时，必须使用结果名称。

如果函数具有结果名称，那么在声明结果是数组时必须使用此结果名称。

消息标识：ERROR_0027

## Error:在程序字符串中缺少后缀“)”。

在可以出现在 PROGRAM 语句中的可选括号化列表中，括号组不匹配。

消息标识：ERROR_0028

## Error:未命名的块数据程序单元最多为 26，并且已经超出此限制。

在可执行程序中，Fortran 标准将未命名的块数据程序单元限制到 1。但是，编译器将此限制扩展到 26。此编译器检测到 26 个以上的未命名块数据程序单元。

消息标识：ERROR_0029

## Ansi：Fortran 标准不允许多个未命名的 BLOCK DATA 程序单元。

Fortran 标准不允许多个未命名的块数据程序单元。

消息标识：ANSI_0030

## Ansi：PROGRAM 语句的参数为 Fortran 标准的一个扩展。

PROGRAM 语句包含用圆括号括入的参数列表。Fortran 标准不向主程序提供实际参数。

消息标识：ANSI_0031

## Error:在 IMPLICIT 语句中，不允许类型说明“CHARACTER*(*)”。

在 IMPLICIT 语句中，不允许假定长度字符类型声明。

消息标识：ERROR_0032

## Error:如果正在设定类型的组件被定义为派生类型，那么它必须具有 POINTER 属性。

Fortran 标准要求，派生类型的组件可以不声明为派生类型，除非组件是指针。例如：

    TYPE BB
    TYPE(BB) ::A
    END TYPE

组件 A 为非法，因为它已被定义为正在声明的类型 (BB)。

    TYPE ZZ
    TYPE(ZZ), POINTER ::A
    END TYPE

组件 A 为合法，因为它是正在被声明类型 (ZZ) 结构的指针。

消息标识：ERROR_0033

## 内部：名称或属性索引无效。它小于 0 或大于表索引。

局部名称表索引或属性表索引无效。它或者小于零或者大于最后输入的表索引。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0034

## Error:字符长度已超出最大长度。

已超出最大字符长度。

消息标识：ERROR_0035

## Error:函数入口具有结果名称，那么在声明结果是指针时必须使用此结果名称。

如果函数具有结果名称，那么在声明结果是指针时必须使用此结果名称。

消息标识：ERROR_0036

## Ansi：字符长度超过 72 的输入行是 Fortran 标准的一个扩展。

编译器检测到大于 72 个字符的输入行。在固定源格式中，Fortran 标准未规定输入行大于 72 个字符长度。

消息标识：ANSI_0037

## 内部：此字符无效。要求在失败的分析类型说明 DOUBLE 之后跟随关键字 DO。

未按预期遇到 DO 时生成此错误。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0038

## Error:在 I/O 语句中引用了此名称列表组名。不能在此 NAMELIST 语句中指定。

名称列表语句可能与可执行语句混合。但是，特定名称列表组的所有定义必须出现在 I/O 语句首次引用名称列表组之前。

消息标识：ERROR_0039

## Error:如果此主程序未指定 PROGRAM 语句，那么在 END PROGRAM 语句中不能指定名称。

编译器检测出跟有程序单元名称的 END PROGRAM 语句。此程序单元没有 PROGRAM 语句，因此没有名称。

消息标识：ERROR_0040

## Error:%s 语句仅能被指定一次，如果是派生类型定义“%s”。

在派生类型定义中，PRIVATE 和 SEQUENCE 语句仅能被指定一次。

消息标识：ERROR_0041

## 内部：属性入口 %d 出现字段 %s 变量问题。

编译器检测到变量问题。在属性表中存取字段，但是使用了错误的变量。实际上，字段可能在属性辅助表中，但是它正在检查属性表变量。通常，无论字段是否实际驻留在属性表或属性辅助表中，在解决问题方面应该没有差别。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0042

## Error:每个此类构造中，仅允许一个此类语句。

每个 IF 构造仅能有一个 ELSE 块。每个 WHERE 构造仅能有一个 ELSEWHERE 块。编译器在 IF 或 WHERE 构造中检测到多个 ELSE 或 ELSE WHERE 语句。

消息标识：ERROR_0043

## Error:在接口体中不能重新定义主机入口点名称。

在外部子程序内，在包含的子程序内的显式接口中已指定一个入口点名称。在主机中，入口点名称已具有显式接口，因此它们不能具有在包含的过程中指定的另一接口。以下示例说明了非法重新定义。

    FUNCTION ABC()
    CONTAINS
    SUBROUTINE SAM()
    INTERFACE
    FUNCTION ABC() !Illegal re-definition
    END FUNCTION   !  of ABC's interface
    END INTERFACE
    END SUBROUTINE
    END FUNCTION

消息标识：ERROR_0044

## 错误：组件为私有类型，因此派生类型也必须为私有或具有私有组件。

如果派生类型的组件被声明为私有类型，那么不是派生类型定义必须包含 PRIVATE 语句，就是派生类型必须为私有。

消息标识：ERROR_0045

## Ansi：TASK COMMON 语句是 Fortran 标准的一个扩展。

TASK COMMON 语句是 Fortran 标准的一个扩展。

消息标识：ANSI_0046

## 错误：“*”必须仅能与 UNIT 或 FMT I/O 控制信息列表项一起使用。

在某个位置中的 I/O 控制信息列表内遇到星号 (*) 或者与除 UNIT 或 FMT 以外的关键词一起使用。

消息标识：ERROR_0047

## Error:不能定义使用中的 DO 变量。

活动 DO 变量的名称出现在将更改 DO 变量值的语句中。可以使用 DO 变量，但不可在其循环范围内重新定义。

消息标识：ERROR_0048

## Log_Error：无法打开源文件。

编译器无法打开源文件。

消息标识：LOG_ERROR_0049

## 内部：试图读取文件末尾后的内容。

它由 fixed_get_line in src_input.c 生成。此编译器试图读取 EOF 末尾后的内容。此源输入文件可能被破坏。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0050

## Error:不能继续编译器指令。

不能继续编译器指令。

消息标识：ERROR_0051

## Ansi：在此源格式中，此数量以上的续行是 Fortran 标准的一个扩展。

在固定源格式中，Fortran 标准仅允许 19 个续行，在自由格式中允许 39 个续行。

消息标识：ANSI_0052

## Error:包含文件的首行不能为续行。

包含文件的首行不能为续行。

消息标识：ERROR_0053

## Error:跟随 INCLUDE 行的源行不能为续行。

跟随 INCLUDE 行的行不能为续行。

消息标识：ERROR_0054

## 警告：文件行未以换行结束。

编译器预期源文件中的所有行应以换行字符结束。文件行未以换行结束。

消息标识：WARNING_0055

## Error:续行不能包含标签。

在续行上定义标签是非法的。

消息标识：ERROR_0056

## Error:INCLUDE 文件名长度超过字符的最大值限定。

INCLUDE 文件的名称长度超过最大长度限定。缩短 INCLUDE 文件的名称。

消息标识：ERROR_0057

## Error:缺少 INCLUDE 文件名。

INCLUDE 行未遵守预期格式。在以下语法中，file 是要包括的文件名称：

    INCLUDE 'file'

必须使用撇号或引号将文件名括入。仅嵌入的注释可以跟随结束分隔符。

消息标识：ERROR_0058

## Error:INCLUDE 文件名中缺少分隔符。

INCLUDE 行未遵守预期格式。在以下语法中，file 是要包含的文件名称：

    INCLUDE 'file'

必须使用撇号或引号将文件名括入。仅嵌入的注释可以跟随结束分隔符。

消息标识：ERROR_0059

## Error:跟随 INCLUDE 文件名的源不是注释。

INCLUDE 行未遵守预期格式。在以下语法中，file 是要包含的文件名称：

    INCLUDE 'file'

必须使用撇号或引号将文件名括入。仅嵌入的注释可以跟随结束分隔符。

消息标识：ERROR_0060

## Error:INCLUDE 行不能包含语句标签。

INCLUDE 行未遵守预期格式。在以下语法中，file 是要包含的文件名称：

    INCLUDE 'file'

必须使用撇号或引号将文件名括入。仅嵌入的注释可以跟随结束分隔符。

消息标识：ERROR_0061

## Error:运算符不是内在运算符。DATA 语句表达式中的所有运算必须为内部运算。

DATA 语句具有以下通用格式：

    data_stmt_object_list /data_stmt_value_list/

在此处，data_stmt_object 可以是变量或隐含 DO。在变量 data_stmt_object中；每个下标、段下标、子串起始点和子串结束点必须是表达式，其中，每次运算都是内运算。

DATA 语句隐含的 DO 具有以下格式：

    (data_i_do_object_list, data_i_do_variable =
    	scalar_int_expr, scalar_int_expr
    	[, scalar_int_expr])

data_i_do_object 下标列表的每个下标中的所有运算必须为内运算。同样，每个循环控制 scalar_int_expr 中的所有运算必须为内运算。

消息标识：ERROR_0062

## Error:无法打开 INCLUDE 文件。

编译器无法打开指定的 INCLUDE 文件。

消息标识：ERROR_0063

## Error:递归使用 INCLUDE 文件。

INCLUDE 文件不得包括本身。

消息标识：ERROR_0064

## Error:已定义的运算符超过 127 个字符的最大长度。

已定义的运算符不得超过 127 个字符。

消息标识：ERROR_0065

## Error:已定义运算符缺少“.”分隔符。

已定义运算符必须以句点分隔符开始和结束。此已定义运算符缺少结束分隔符。

消息标识：ERROR_0066

## Error:标识符长度超过最大值 127 个字符。

编译程序检测到长度超过 127 个字符的标识符。Fortran 标准将标识符的长度限制为 127 个字符。

消息标识：ERROR_0067

## Error:标签长度超过 5 位数的最大值。

Fortran 要求标签不超过 5 位。编译程序检测到超过 5 位的标签。

消息标识：ERROR_0068

## Error:标签必须有一位非零。

编译程序已检测到一个全为零的标签。标签必须有一位非零。

消息标识：ERROR_0069

## Error:每个控制项说明符仅能指定一次。

I/O 语句含有多个相同的说明符。例如，因为“UNIT=”被指定了两次，以下情况将发出此消息。

    WRITE(UNIT=101,FMT=10,UNIT=101)

消息标识：ERROR_0070

## Ansi：Fortran 要求自由源格式下续行在 & 符号后有文本。

Fortran 标准要求除续行字符外续行还应包含其它字符。

消息标识：ANSI_0071

## 内部：对象“%s”是与自身关联的主机。属性索引为 %d。

AT_ATTR_LINK(attr_idx) = attr_idx.这会导致编译过程中的各种内部循环。属性决不能连接到自身。

消息标识：INTERNAL_0072

## Error:此 I/O 语句不允许该控制项说明符。

I/O 语句包含不适当或无法辨认的说明符。允许在 READ 或 WRITE 语句中使用的说明符是：

    UNIT    FMT         END         REC
    ERR     IOSTAT      NML         ADVANCE
    SIZE    EOR

允许在 OPEN 语句中使用的说明符是：

    UNIT     FILE       STATUS      IOSTAT
    ERR      FORM       ACCESS      RECL
    BLANK    POSITION   ACTION      DELIM
    PAD

允许在 CLOSE 语句中使用的说明符是：

    UNIT     IOSTAT     STATUS      ERR

允许在 INQUIRE 语中使用的说明符是：

    FILE     IOSTAT     ERR         EXIST
    OPENED   NUMBER     NAMED       RECL
    NEXTREC  NAME       ACCESS      SEQUENTIAL
    FORM     DIRECT     FORMATTED   UNFORMATTED
    BLANK    UNIT       POSITION    ACTION
    READ     WRITE      READWRITE   DELIM
    PAD

消息标识：ERROR_0073

## Log_Warning：汇编语言输出（-eS 或 -S 文件名）禁用了二进制输出。已选定汇编语言输出。

编译程序不能同时打开汇编语言文件和二进制文件。禁用二进制输出文件，因为命令行要求汇编语言输出（-eS 或 -S 文件名）。缺省启用二进制输出文件；因此，在命令行中指定汇编语言文件（未关闭二进制文件）会导致出现该警告消息。

    -eS file.f     发出警告消息
    -dB -eS file.f 无警告，因为 -dB
    关闭二进制输出
    -eS -dS file.f  -eS 的警告消息。
    禁用汇编输出和二进制输出。

消息标识：LOG_WARNING_0074

## Log_Warning：检测到舍入/截断冲突。已选定单选项。

编译程序检测到命令行中的舍入/截断冲突。使用最后一个指定的选项。

消息标识：LOG_WARNING_0075

## Log_Warning：检测到内联选项冲突。选定自动模式。

在命令行中指定 -O inline[0-3] 和 -I 文件名后，就会发出此消息。选定自动内联。

消息标识：LOG_WARNING_0076

## Log_Error：命令行有未知选项。

编译程序在命令行中检测到未知选项。

消息标识：LOG_ERROR_0077

## Log_Error：此选项具有非法参数。

该指定选项的参数是非法的。

消息标识：LOG_ERROR_0078

## Log_Error：输入文件名之后不能有选项。

命令行中的源输入文件名后不要求跟东西。

消息标识：LOG_ERROR_0079

## Log_Error：当输入源自 stdin 时，必须指定文件名。

如果自 stdin 输入源文件，那么必须为二进制文件或汇编语言文件（取决于需要哪一个）指定名称。

消息标识：LOG_ERROR_0080

## 内部：处理过程中，在局部范围中找到未预料的属性条目。

例程 not_visible_semantics 已在符号表中找到属性。处理过程中在局部范围内仅允许：过程名、函数结果名，伪参数名、使用关联对象和在声明边界表达式中使用的对象。可能出现的其它的项必然带有声明错误。

消息标识：INTERNAL_0081

## Log_Warning：调试 (-G) 需要二进制输出 (-eB)。启用二进制输出。

如果禁用二进制输出（使用 -dB 选项），那么编译程序只能进行语义和语法检错。调试要求产生二进制输出。二进制输出缺省打开，可通过指定 -dB 或请求汇编语言文件（-eS 或 -S 文件名）关闭。以下为示例：

    -dB -G0   illegal – 二进制输出关闭，调试打开
    -eS -G0   illegal – 汇编语言文件打开，调试打开

消息标识：LOG_WARNING_0082

## Error:此标记缺少应该有的分隔符。

编译程序检测到由撇号或引号定界的标记之始。缺少匹配的尾分隔符。

消息标识：ERROR_0083

## Error:此霍尔瑞斯常数的字符数错误。

编译程序检测到计数和霍尔瑞斯常数中的实际指定字符数相矛盾。此种情况示例：

    4H123   常量仅包含 3 个字符，
    但 4H 表明应有 4 个字符。

消息标识：ERROR_0084

## Error:霍尔瑞斯说明符中的字符数必须大于零。

指定 0H 无效。霍尔瑞斯常数的长度必须大于 0。

消息标识：ERROR_0085

## Error:此语句的 END 语句后必须跟适宜的关键字。

Fortran 要求：模块过程或内部过程的 END 语句如果是函数，就应该是 END FUNCTION；如果是子例程，就应该是 END SUBROUTINE。编译程序仅检测到 END 语句。

消息标识：ERROR_0086

## Error:在实常量中，如果十进制字段后跟 D 或 E，则 D 或 E 之后必须跟指数。

编译器检测到实常量中缺少指数字段。实常量的语法是

    [sign] real_literal_constant

real_literal_constant 是尾数 [exponent_letter exponent] [_kind_param]

或

digit_string exponent_letter exponent [_kind_param]

尾数是 digit_string.[digit_string]

或

digit_string

exponent_letter 是 E 或指数是 signed_digit_string

消息标识：ERROR_0087

## Error:此种类参数后缀在双精度实常量格式中无效。

编译程序检测到跟随 D 指数的种类参数。

实常量的语法是

    [digit_str].digit_str[exponent_letter exponent]
    [_kind_param]

exponent_letter 是 D 或 E；指数是带有以下约束的 signed_digit_string：如果 kind_param 和 exponent_letter 都出现，exponent_letter 必须是 E。

消息标识：ERROR_0088

## Error:文字常量中的种类参数必须为整数或命名的常量。

如果已在文字常量中指定种类参数，则此种类参数必须为整数或整数类型的命名常量。例如：

    r = 10.0_8    ! is a valid kind parameter
    END

    PARAMETER (KIND=4)
    j = 10_KIND   ! is a valid kind parameter
    END

    r = 10.0_IT   ! is not valid, because IT
    ! is not an integer constant value.

消息标识：ERROR_0089

## Ansi：布尔常量是 Fortran 标准的一个扩展。

可按以下方式将八进制和十六进制值指定为布尔常量：

    1000B -->    八进制

    '1a3'X -->   十六进制

Fortran 标准不支持布尔常量。

消息标识：ANSI_0090

## Error:此常量包含 %d 个字符。允许的字符数必须 > 0 且 <= %d。

非标准的布尔常量和 Fortran BOZ 常量的大小都有限制。这些限制由机器的类型决定。 如果机器类型有 64 位，最大的长度如下： 八进制常量：22 十六进制常量：16 二进制常量： 64 如果八进制常量包含 22 个字符，高位（最左边）数字只能是 0 或 1。 如果机器类型有 32 位，最大的长度如下： 八进制常量：11 十六进制常量：8 二进制常量： 32 如果八进制常量包含 11 个字符，高位（最左边）数字只能是 0-3。

消息标识：ERROR_0091

## Error:此常量的值超过机器类型的允许范围。

非标准布尔常量和 Fortran BOZ 常量的大小有限制。这些限制由机器的类型决定。 如果机器类型有 64 位，最大的长度如下： 八进制常量：22 十六进制常量：16 二进制常量： 64 如果八进制常量包含 22 个字符，高位（最左边）数字只能是 0 或 1。 如果机器类型有 32 位，最大的长度如下： 八进制常量：11 十六进制常量：8 二进制常量： 32 如果八进制常量包含 11 个字符，高位（最左边）数字只能是 0-3。

消息标识：ERROR_0092

## Error:字符在八进制常量中无效。

在八进制常量中（BOZ 或布尔常量），仅允许 0-7 的数字。编译程序检测到此范围之外的字符。

消息标识：ERROR_0093

## Error:指定“R”格式后，霍尔瑞斯常量的字符数不能超过如下规定。

“R”霍尔瑞斯格式指定为：'123456789'R 9R123456789

两种情况都是错误的，因为在霍尔瑞斯常量中指定的字的字符数超过上限。在 64 位的机器中，最多允许 8 个字符。在 32 位的机器中，最多允许 4 个字符。

消息标识：ERROR_0094

## Error:实常量的整数和/或该小数部分必须有数字。

编译程序正在寻找实常量，但只能找到句点。

例如：

    1.2       Legal
    .2       Legal
    1.        Legal
    .        非法

消息标识：ERROR_0095

## Ansi：霍尔瑞斯常量是 Fortran 标准的扩展。

下面的霍尔瑞斯常量说明是非标准的。 2Hab 2Lab 2Rab 'ab'h 'ab'l 'ab'r "ab"H "ab"L "ab"R

消息标识：ANSI_0096

## Error:此常量之赋值与“%s”不兼容。

正在类型声明语句或 DATA 语句中初始化变量。无论哪种情况，根据内赋值规则，常量或结构构造函数的值必须与相应的变量兼容。

消息标识：ERROR_0097

## Error:点运算符应该仅含字母。

应该有点运算符，但未找到。点运算符只能含字母。

消息标识：ERROR_0098

## Log_Error：已指定一个“-O”，因此不能指定冲突的“-O”。

在命令行中出现的两个优化选项要求冲突优化。

消息标识：LOG_ERROR_0099

## Error:此语句必须以标签、关键字或标识符开始。

语句开始的标记无效。此标记必须是标签或标识符。标识符可以是语言关键字、构造名、作为赋值语句的目标变量的标识符，或语句函数定义语句中的语句函数名。

消息标识：ERROR_0100

## Error:种类参数的长度超过最大值 127。

种类参数的长度超过 127 个字符。缩短种类参数的长度。

消息标识：ERROR_0101

## Error:在 WHERE 语句中仅能使用赋值语句。

在 WHERE 语句中，屏蔽表达式后的语句不是赋值语句。

消息标识：ERROR_0102

## Log_Summary：f90：Cray CF90 版

这确定了正在使用哪一个版本的编译器。

消息标识：LOG_SUMMARY_0103

## Log_Summary：f90：编译时间 %f 秒

此消息报告程序编译过程所用的时间（以秒为单位）。

消息标识：LOG_SUMMARY_0104

## Log_Summary：f90：最大字段长度 %d 个十进制字

此消息报告编译程序在编译过程中使用的最大内存量。

消息标识：LOG_SUMMARY_0105

## Log_Summary：f90：%d 个源代码行

此消息不再使用。使用 LOG_SUMMARY_1925。

消息标识：LOG_SUMMARY_0106

## Log_Summary：f90：%d 个错误、%d 个警告、%d 个其它消息、%d ANSI

此消息不再使用。使用 LOG_SUMMARY_1926。

消息标识：LOG_SUMMARY_0107

## Log_Summary：f90：代码：%d 个字，数据：%d 个字

此消息报告了指令的字数和编译程序产生的数据的字数。

消息标识：LOG_SUMMARY_0108

## Error:不得在 TASK COMMON 语句或指令中声明空白公共区。

TASK COMMON 语句指定空白（未命名）公共块。必须给 TASK COMMON 块命名。例如：

    TASK COMMON /cbname/ n, ...! Legal
    TASK COMMON // n, ...! Illegal

消息标识：ERROR_0109

## Error:此公共块多次指定 SAVE 属性。

公共块名只能指定一次 SAVE 属性。例如：

    PROGRAM MAIN
    COMMON /BLK/A
    SAVE /BLK/
    SAVE /BLK/ !非法

    这是非法的，因为已为 BLK 两次指定 SAVE。

消息标识：ERROR_0110

## Error:已指定 PARAMETER 属性，因而必须指定初始化表达式。

如果语句包含 PARAMETER 属性，则必须出现用于数据对象名的 = initialization_expr。

消息标识：ERROR_0111

## 注释：算术 IF 语句是废弃特征。

这是过时的 FORTRAN 77 特征。使用逻辑 IF 语句或 IF 构造代替算术 IF。

消息标识：COMMENT_0112

## Error:已在局部范围中指定 IMPLICIT NONE，因此必须为此数据对象指定显式类型。

指定 IMPLICIT NONE 后，所有的数据对象都必须有个显式类型。

消息标识：ERROR_0113

## Error:延迟形或假定形数组不得有假定大小说明符或指定的上界。

编译程序检测到数组 (:10) 或数组(:*) 或它的变量。延迟形说明符和假定形说明符不得有指定的上界。允许下面的边界形式：

    显式数组	[下界：]上界

    假定形数组	[下界]：

    延迟形数组	:

    假定大小数组	[下界：]*

下例说明了整数类型的二维假定形数组。

    INTEGER, DIMENSION(1:,:):: ARRAY

消息标识：ERROR_0114

## Error:显式数组必须有指定的上界。

数组的类型由第一维决定。如果维是 1:2（其中，1 和 2 是整数，且 1 是可选的），那么这是显式数组声明且其余维必须有指定的上界。

消息标识：ERROR_0115

## Error:假定大小的说明符 (*) 必须为显式数组声明最后一维的上界。

假定大小的说明符 (*) 只能声明用于显式数组的最后一维。它必须是上界而且后跟右括号。允许下面的边界形式：

    显式数组	[下界：]上界

    假定形数组	[下界：]

    延迟形数组	:

    假定大小数组	[下界：]*

消息标识：ERROR_0116

## Error:数组声明的最高等级为 7。

数组不能超过 7 维。

消息标识：ERROR_0117

## Error:在表达式中使用了函数“%s”。假定类型为%s。

编译程序检测到这样的操作：试图重新定义先前隐式定义并在表达式中使用的函数的类型。以下是此情况的示例：

    DIMENSION ARRAY(KFUNC())
    REAL KFUNC

在此例中，KFUNC 只可定义为整数类型，因为它在 DIMENSION 语句中就已经隐式定义为整数。

消息标识：ERROR_0118

## Error:这是延迟形维数说明符。因此，应该使用逗号或右括号，但是发现了其它东西。

在分析延迟形数组说明时，编译程序应该有逗号或右括号，但是发现了其它东西。延迟形维数说明符只是一个冒号 (:)。 其它允许的边界形式类型有：

    显式数组	[下界：]上界

    假定形数组	[下界：]

    假定大小数组	[下界：]*

如果数组有 ALLOCATABLE 或 POINTER 属性，就必须指定为延迟形数组。 下例声明了整数类型名为 JOE 的三维指针数组：

    INTEGER, POINTER, DIMENSION(:,:,:):: JOE

消息标识：ERROR_0119

## Error:WHERE 语句或 WHERE 构造的屏蔽表达式必须为逻辑类型。

在 WHERE 语句或 WHERE 构造中，用作屏蔽表达式的表达式的类型不正确。它必须是逻辑表达式。

消息标识：ERROR_0120

## Error:如果“= initialization”表达式已指定，则必须使用“::”分隔标识符列表中的类型和属性。

如果在类型声明语句中指定 = initialization_expr，则需要使用 :: 分隔符。

消息标识：ERROR_0121

## Error:在函数子程序中，仅能在 ENTRY 语句中使用 RESULT 关键字。

在非函数子程序中的 ENTRY 语句中使用 RESULT 关键字。只能在函数子程序中的 FUNCTION 和 ENTRY 语句中指定 RESULT 关键字。

消息标识：ERROR_0122

## Error:这是一个派生类型的类型名称。不能多次定义其为类型名称。

派生类型类型名称只能定义一次。编译程序发现一个类型名称被再次用于定义另一个派生类型。

消息标识：ERROR_0123

## Ansi：使用%s*%d 是 Fortran 标准的扩展。

使用 data_type*length 是非字符数据类型的 Fortran 标准的扩展。

消息标识：ANSI_0124

## Error:此类型不允许这个长度。

星号后指定的长度是此类型的非法长度。例如：DOUBLE PRECISION*8 是非法的，因为 16 是 DOUBLE PRECISION 唯一有效的星类型。

下面是各种类型及其合法的星类型：

    整数： 1, 2, 4, 6, 8
    实数： 4, 8, 16
    复数： 8, 16, 32
    逻辑： 1, 2, 4, 8
    双精度： 16

消息标识：ERROR_0125

## Error:使用的派生类型没有为其定义的元素。

除非派生类型在 FUNCTION 语句或 IMPLICIT 语句中指定，否则，先定义其元素然后再使用。这种情况下，必须在引用后定义派生类型。在所有情况中，都必须定义派生类型。通过指定元素定义来定义派生类型。

消息标识：ERROR_0126

## Error:此数据引用的多个部分引用的级别高于零。

此数据引用有多个部分为值确定的数组。在一个值确定的数组数据引用中，只能有一个值确定的数组部分。在下例中，A 和 B 都是数组：

    	A(1:4)%B(3:4)  !Illegal reference

消息标识：ERROR_0127

## Error:实际参数列表中的位置实际参数必须优先于任何关键字。

位置参数之后跟随此实际参数列表中的参数关键字。

消息标识：ERROR_0128

## Error:种类类型参数必须是一个标量整型常量。

种类类型参数必须是 digit_string 或标量整型常数的名称。例如：

    INTEGER, PARAMETER ::large = 8
    REAL, PARAMETER    ::rkind = 8.0
    INTEGER ::ikind = 8

    i = 123_8      !Legal
    i = 123_large  !Legal

    i = 123_rkind  !Illegal rkind not type integer.
    i = 123_ikind  !Illegal ikind not named constant.

消息标识：ERROR_0129

## 警告：种类类型参数值对此类型无效。

以下是每个类型的有效种类类型：

    字符： 1
    整数： 1, 2, 4, 6, 8
    实数： 4, 8, 16
    复数： 4, 8, 16
    逻辑： 1, 2, 4, 8

消息标识：WARNING_0130

## Error:显形数组“%s”具有非恒定边界，所以仅能在函数或子例程程序单元中声明。

具有非恒定边界的显形数组仅能在子例程、函数或描述子例程和函数的接口体中声明。编译器检测到具有非恒定边界的数组，但程序单元不是子例程或函数。

消息标识：ERROR_0131

## Error:函数入口“%s”具有结果名称“%s”，在声明该结果将成为目标时必须使用该结果名称。

如果函数具有结果名称，则在声明结果将成为目标时必须使用该结果名称。

消息标识：ERROR_0132

## Ansi：Fortran 标准要求没有“已保存实体列表”的 SAVE 语句在作用单元中为唯一的 SAVE。

如果在作用单元中出现了省略 saved_entity_list 的 SAVE 语句，则在同一作用单元中就不允许出现其它 SAVE 属性或 SAVE 语句的显式情况。

消息标识：ANSI_0133

## Ansi：Cray 指针是 Fortran 标准的一个扩展。

Cray 指针是非标准的并声明如下： POINTER(pointer,pointee) Fortran 指针声明如下： POINTER [::] object-name 不能混合这两种类型的指针。

消息标识：ANSI_0134

## Error:要求 FORMAT 语句具有语句标签。

FORMAT 语句的语法为：

format_stmt 是 FORMAT format_specification

format_specification 是 ([format_item_list])

FORMAT 语句必须具有语句标签。

消息标识：ERROR_0135

## 内部：在传递到的属性入口中使用的变量无效。

传递到命名例程的属性表索引无效。它具有错误的活动变量。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0136

## Error:EQUIVALENCE 列表需要在列表中至少有两个项目。

EQUIVALENCE 列表中的项目少于两个。EQUIVALENCE 列表需要至少两个项目。

消息标识：ERROR_0137

## 内部：表不能在此机器的字边界上正确排列。

所列的表不能在此机器的字边界上排列。请检查以确保该表被分成 32 位的块，且该表的 NUM_...._WDS 宏被设置为正确的字数。

应避免产生此消息。这是一个错误的编译器或错误的安装。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。

消息标识：INTERNAL_0138

## Error:此 I/O 控制列表说明符需要关键字。

除了 UNIT、FMT 和 NML 说明符，用在 I/O 语句 OPEN、CLOSE、BACKSPACE、ENDFILE、REWIND 和 INQUIRE 中的所有参数必须用 keyword= 在参数前进行标识。UNIT 如果未用关键字指定，则必须为控制列表中的第一个项目。FMT 或 NML 说明符如果未用关键字指定，则必须为列表中的第二个项目；第一个项目必须为未用关键字指定的 UNIT。

消息标识：ERROR_0139

## Error:所定义的派生类型为序列类型，所以派生类型的任何组件也必须为序列类型。

如果所定义的派生类型中出现 SEQUENCE 语句，则所有在组件定义中指定的派生类型都必须为序列类型。编译器检测到不是序列类型的派生类型组件。

消息标识：ERROR_0140

## 内部：此语句的起始标记已经导致错误选择语句类型。

语句分析驱动程序调用了 parse_bad_stmt 例程。检查起始标记和分析例程表标记。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0141

## Error:标签变量必须为标量和缺省整数类型。

ASSIGN 语句或赋值 GO TO 语句具有标签变量 (scalar_int_variable)，而该变量不是标量和/或缺省整数类型。ASSIGN 语句的语法是：

    ASSIGN label TO scalar_int_variable

赋值 GO TO 语句的语法是：

    GO TO scalar_int_variable [ [,] (label_list) ]

scalar_int_variable 必须是非限定名称；它不能是结构组件、数组元素或子字符串指示器。变量必须为缺省整数类型，且它必须为标量。

消息标识：ERROR_0142

## Error:字符对象具有非恒定范围。仅能在函数或子例程程序单元中声明。

定义为具有非恒定长度的字符对象仅能在子例程、函数或接口体（描述子例程和函数）中声明。编译器检测到非恒定长度的字符对象，但是，子例程、接口体或函数中没有声明。

消息标识：ERROR_0143

## Error:不允许将控制传输到此行的非执行语句。

该语句试图将控制传输到非执行语句。仅能将控制传输到可执行的分支目标语句。

消息标识：ERROR_0144

## Error:不允许将控制传输到此行的此语句。

该语句试图将控制传输到不能用作分支目标的可执行语句。所有可执行语句都是分支目标，但除了：CASE、ELSE、ELSE IF、ELSE WHERE、END WHERE 和 IF-THEN。仅在有限制的上下文中，允许将控制传输给一些执行语句：
-- 只从 CASE 构造内部转移到其 END SELECT 语句是允许的。
-- 应该只从 IF 构造内部将控制传输到 END IF 语句。将控制传输到 IF 构造外的 END IF 语句是一个废弃特征。
-- 应该只从 DO 构造内部将控制传输到 DO 循环终止语句。对于共享公共循环终止语句的嵌套 DO 循环，应该只从 DO 构造的最深层将控制传输到该循环终止语句。

这些特定条件的违规情况由其它消息诊断。

消息标识：ERROR_0145

## Error:语句标签先前在另一行已定义。

语句标签仅能在作用单元中定义一次。编译器在指定行发现该语句标签的另一个定义。

消息标识：ERROR_0146

## Error:不允许将控制传输到起始于那行的 WHERE 构造中。

该语句试图将控制传输到 WHERE 构造的 WHERE 块或 ELSEWHERE 块中的语句。在 WHERE 构造中，只有 WHERE 构造语句本身可以是分支目标。

消息标识：ERROR_0147

## Error:不允许将控制传输到起始于那行的 CASE 块中。

错误语句试图从 CASE 构造外部或同一 CASE 构造内的另一个 CASE 块将控制传输到 CASE 块。从 CASE 块的外部将控制传输到其内部是不被允许的。

消息标识：ERROR_0148

## 注释：将控制传输到 IF 构造外的 END IF 语句是一个废弃特征。

不是从其 IF 构造外分支转移到 END IF 语句，而是分支转移到 END IF 跟有的语句。如果跟随 END IF 的语句不是有效的分支目标语句，那么可能要求更改程序逻辑。

废弃特征是 FORTRAN 77 特征，现在是多余的并且有更好的方法。ANSI Fortran 委员会建议程序员在新程序中使用首选方法并将现有代码转换为首选方法。如果在 Fortran 程序中废弃特征的使用已经不重要，将来的 Fortran 标准委员会考虑将其从此标准中删除。

消息标识：COMMENT_0149

## Error:不允许将控制传输到块 DO 构造外的 END DO 语句。

错误语句试图将控制传输到 END DO 语句，但由标记 END DO 终止的块 DO 构造中没有分支转移语句。从 DO 构造内部转移到其 END DO 语句是允许的。

消息标识：ERROR_0150

## Error:使用此派生类型“%s”无效。

派生类型名称是在可执行语句中，但未用作派生类型的构造函数。

消息标识：ERROR_0151

## Error:WHERE 语句或在 WHERE 构造中的赋值语句不能是已定义的赋值。

此屏蔽数组赋值决定了已定义的赋值。

消息标识：ERROR_0152

## Error:不允许将控制传输到其 CASE 构造外的 END SELECT 语句。

错误语句试图将控制传输给 END SELECT 语句，但由标记 END SELECT 终止的 CASE 构造的 CASE 块中没有分支转移语句。只从 CASE 构造内部转移到其 END SELECT 语句是允许的。

消息标识：ERROR_0153

## 警告：将控制传输到起始于那行的 DO 循环中不安全。

该语句正在将控制传输到 DO 循环体或 DO 循环终止语句，但该循环中没有分支转移语句。在含有公共终止语句的嵌套循环中，仅能从最深层循环将控制传输到公共终止语句。

消息标识：WARNING_0154

## Ansi：将控制传输到起始于那行的 DO 循环中不标准。

Fortran 标准不允许从循环的外部将控制传输到 DO 循环体或 DO 循环终止语句。

消息标识：ANSI_0155

## 警告：将控制传输到起始于那行的此块中不安全。

该语句正在从 IF 构造外部或 IF 构造中的另一个块中将控制传输到 THEN、ELSE 或 ELSE IF 块。将控制从块的外部传输到其内部是不被允许的。

消息标识：WARNING_0156

## Ansi：将控制传输到起始于那行的此块中不标准。

Fortran 标准不允许从 IF 构造外部或 IF 构造中的另一个块中将控制传输给 THEN、ELSE IF 或 ELSE 块。

消息标识：ANSI_0157

## Error:在 END BLOCK DATA 语句中不能为未命名的块数据程序单元指定名称。

未命名的块数据程序单元不能在其 END 语句中指定名称。在 END BLOCK DATA 语句中，编译器检测到未命名块数据程序单元的名称。

消息标识：ERROR_0158

## Error:发现一个以上用于此 CASE 构造的 CASE DEFAULT 语句。

编译器检测到一个以上用于此 CASE 构造的 CASE DEFAULT 语句。每个 CASE 构造只允许有一个 CASE DEFAULT 语句。

消息标识：ERROR_0159

## 内部：位于块栈索引 %d 的块栈出现问题。

出现了以下错误之一：
-- 编译器在已指定块索引的块栈中发现未知块。块栈中决不应有未知块。
-- 该块栈含有一个后面紧跟 IF_THEN_BLK、IF_ELSE_IF_BLK 或 IF_ELSE_BLK 的 If_Blk。
-- blk_stk_idx = NULL_IDX。块栈应该始终含有作为第一入口的程序单元块。
-- 当前块是 If_Then_Blk、If_Else_If_Blk 或 If_Else_Blk，但前面的块入口不是 If_Blk。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0160

## Ansi：用作霍尔瑞斯常量的字符文字是 Fortran 标准的一个扩展。

字符常量正在用于不允许使用字符常量而允许使用霍尔瑞斯常量的上下文中。这是 Fortran 标准的一个扩展。在算术和逻辑表达式以及等号左边为整数或实数类型实体的赋值语句中，允许使用霍尔瑞斯常量。在 I/O 语句的控制信息列表中将文字串用作文件标识符时，也会出现此消息。

消息标识：ANSI_0161

## Error:在 IF 构造的 ELSE IF 块中不允许此语句。

以下语句允许在 IF 构造的 ELSE IF 之后：

    ALLOCATE               ASSIGN
    BACKSPACE              BUFFER
    CALL                   CLOSE
    CONTINUE               DATA
    DEALLOCATE             DECODE
    DO                     ENCODE
    ENDFILE                ENDIF
    ELSE                   ELSEIF
    FORMAT                 GOTO
    IF                     INQUIRE
    NAMELIST               NULLIFY
    OPEN                   PAUSE
    PRINT                  READ
    RETURN                 REWIND
    SELECT                 STOP
    WHERE                  WRITE
    assignment

如果满足所列条件，则允许下面的语句。
-- CASE 构造中的 CASE、END SELECT
-- WHERE 构造中的 ELSEWHERE、END WHERE
-- DO 构造中的 CYCLE、EXIT、END DO。

消息标识：ERROR_0162

## Error:在 IF 构造的 ELSE 块中不允许此语句。

在 IF 构造的 ELSE 块中允许以下语句：

    ALLOCATE               ASSIGN
    BACKSPACE              BUFFER
    CALL                   CLOSE
    CONTINUE               DATA
    DEALLOCATE             DECODE
    DO                     ENCODE
    ENDFILE                ENDIF
    ELSE                   ELSEIF
    FORMAT                 GOTO
    IF                     INQUIRE
    NAMELIST               NULLIFY
    OPEN                   PAUSE
    PRINT                  READ
    RETURN                 REWIND
    SELECT                 STOP
    WHERE                  WRITE
    assignment

如果满足所列条件，则允许下面的语句。
-- CASE 构造中的 CASE、END SELECT
-- WHERE 构造中的 ELSEWHERE、END WHERE
-- DO 构造中的 CYCLE、EXIT、END DO。

消息标识：ERROR_0163

## Error:在内部过程中不允许此语句。

以下语句在内部过程中不被允许：

    CONTAINS
    TASK COMMON
    PUBLIC
    PRIVATE

以下语句必须位于将要在内部子程序中的接口块、作用单元或构造内。
-- 派生类型定义中的 SEQUENCE、END TYPE
-- 通用接口块中的 MODULE PROCEDURE
-- IF 构造中的 ELSE、ELSEIF、END IF
-- CASE 构造中的 CASE、END SELECT
-- WHERE 构造中的 ELSEWHERE、END WHERE
-- DO 构造中的 CYCLE、EXIT、END DO
-- 接口块中的 FUNCTION、SUBROUTINE、END INTERFACE

消息标识：ERROR_0164

## Error:此语句在模块过程中是不被允许。

以下语句在模块过程中不被允许：

    PUBLIC
    PRIVATE
    TASK COMMON

以下语句必须位于将要在模块过程中的接口块、作用单元或构造内。
-- 派生类型定义中的 SEQUENCE、END TYPE
-- 通用接口块中的 MODULE PROCEDURE
-- IF 构造中的 ELSE、ELSEIF、END IF
-- CASE 构造中的 CASE、END SELECT
-- WHERE 构造中的 ELSEWHERE、END WHERE
-- DO 构造中的 CYCLE、EXIT、END DO
-- 接口块中的 FUNCTION、SUBROUTINE、END INTERFACE

消息标识：ERROR_0165

## Error:格式说明之后跟随有外来数据。

此格式说明有无法识别的字符，它们超出了格式说明的末尾。以下语句会发出此消息：

    10 FORMAT(1X,A8) X6		! 非法

消息标识：ERROR_0166

## 警告：在此应用中字段宽度太小。

不正确的字段宽度与 E、F、D、G、I、Z 或 O 编辑描述符一起使用。在以下编辑描述符中，w 必须大于或等于 d：

    Ew.d  Ew.dEe
    Fw.d
    Gw.d  Gw.dEe
    Dw.d

对于下列编辑描述符，w 必须大于或等于 m。

    Iw.m
    Bw.m
    Ow.m
    Zw.m

消息标识：WARNING_0167

## Ansi：FORMAT 中的空括号是 Fortran 标准的一个扩展并已被忽略。

空格式说明出现在另一格式说明中。Fortran 标准要求格式说明是以下格式：

    ([format_item_list])

format_item_list 是以下格式的项目列表：

    [r] data_edit_desc
    control_edit_desc
    [r] char_string_edit_desc
    (format_item_list)

r 是非零、无符号整型常量。

消息标识：ANSI_0168

## Ansi：Fortran 标准要求在这些格式字段之间加逗号。

此格式说明有两个没有用逗号分隔的连续格式描述符。Fortran 标准要求在格式说明的项目之间加逗号。Fortran 标准允许在以下位置省略逗号：
-- P 描述符和其后面紧跟的 F、E、D 或 G 描述符之间
-- 斜线前后
-- 冒号前后

消息标识：ANSI_0169

## Ansi：右括号之前的逗号是 Fortran 标准的一个扩展。

此格式说明中逗号之后跟随另一逗号，或逗号之后跟随一个右括号。Fortran 标准不允许逗号位于右括号之前。

消息标识：ANSI_0170

## Error:先前已在那行声明了构造名。

构造名仅能作用单元中定义一次。编译器在指定行发现此构造名的定义。

消息标识：ERROR_0171

## Error:赋值变量名必须为非限定名。

ASSIGN 语句中的赋值变量名必须为简单变量名。该名称既不能包含结构组件的限定也不能由下标列表或子串范围限定。

消息标识：ERROR_0172

## Error:编译器要求 NAMELIST 组名跟随在 NML 说明符之后。

编译器要求名称列表组名跟随在 NML 说明符之后。

消息标识：ERROR_0173

## Ansi：不带有单元 I/O 说明符的 WRITE 语句是 Fortran 标准的扩展。

遇到了以下形式的 WRITE 语句：

    WRITE f [,iolist]

此形式的 WRITE 语句没有控制信息列表，是 Fortran 标准的一个扩展。

消息标识：ANSI_0174

## Error:IMPLICIT 范围未按字母顺序排序。

在 IMPLICIT 语句中，如果显式说明列表是：letter1 - letter2，则按字母顺序 letter2 必须跟随在 letter1 之后。

消息标识：ERROR_0175

## Error:在此范围中已经指定 IMPLICIT NONE，因此不允许其它 IMPLICIT 语句。

如果在过程的范围内已经指定 IMPLICT NONE，则不允许其它的 IMPLICIT 语句。

消息标识：ERROR_0176

## Error:在先前的 IMPLICIT 语句中指定了指定的字母。不能再次指定它们。

在作用单元的 IMPLICIT 语句中，字母仅能被指定一次。例如：

    IMPLICIT INTEGER (A)
    IMPLICIT REAL (A,B)          !非法

这是非法的，因为已经在先前的 IMPLICIT 语句中指定了 A。

消息标识：ERROR_0177

## 内部：数组类为 Unknown_Array，但是维数说明无声明错误。

如果维数说明有声明错误，则数组类只能为 Unknown_Array。在 parse_array_spec 末尾检测到该问题。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0178

## 内部：在此例程条件语句中选择 DEFAULT 条件。从不应到此处。

处理开关语句时，进入了不该进入的条件。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0179

## 内部：找到的标识符位于表中，但是本不应该找到。

在表中查找的名称在当前范围内应该找不到（例如程序单元名和伪参数标识符）。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0180

## Error:WHERE 语句或 WHERE 构造中的屏蔽表达式必须为值确定的数组表达式。

编译器检测到 WHERE 语句中的屏蔽表达式是标量表达式。它必须为值确定的数组表达式。

消息标识：ERROR_0181

## Ansi：使用带有斜线编辑描述符的重复计数是 Fortran 标准的一个扩展。

在斜线编辑描述符之前发现重复计数。此重复计数的使用对 Fortran 标准的一个扩展。

消息标识：ANSI_0182

## Error:在 CASE 构造的 CASE 块中不允许%s语句。

在 CASE 构造中允许以下语句，并跟随 CASE 语句：

    ALLOCATE               ASSIGN
    BACKSPACE              BUFFER
    CALL                   CLOSE
    CONTINUE               DATA
    DEALLOCATE             DECODE
    DO                     ENCODE
    ENDFILE                ENDIF
    ELSE                   ELSEIF
    FORMAT                 GOTO
    IF                     INQUIRE
    NAMELIST               NULLIFY
    OPEN                   PAUSE
    PRINT                  READ
    RETURN                 REWIND
    SELECT                 STOP
    WHERE                  WRITE
    assignment

如果满足所列条件，则允许下面的语句。
-- CASE 构造中的 CASE、END SELECT
-- WHERE 构造中的 ELSEWHERE、END WHERE
-- DO 构造中的 CYCLE、EXIT、END DO。

消息标识：ERROR_0183

## 注意：递归函数入口名必须具有在声明数组时能够递归调用的结果名称。

如果递归函数的结果是数组，为了递归调用，它必须具有已声明的结果名称。如果未指定结果名称，则对函数名称的引用就是对该结果变量的引用。这样就不能在此函数范围内递归调用其本身。例如：

    RECURSIVE FUNCTION IARRAY(I) RESULT(I_RESULT)
    REAL, DIMENSION ::I_RESULT(100)
       ...
    ! The following reference to I_RESULT
    ! is a reference to the 10th element of
    ! the result variable.

    X = I_RESULT(10)

    ! The following reference to IARRAY
    ! is a recursive reference to the function

    Y = IARRAY(10)
    END FUNCTION

消息标识：CAUTION_0184

## Error:函数入口具有结果名称。设定函数结果的类型时使用结果名称。

如果函数入口具有结果名称，则在设定或指定该函数结果的属性时必须使用结果名称。

消息标识：ERROR_0185

## Error:意外语法：要求 END 关键字之后跟随一项内容，但却发现了其它内容。

编译器正在查找 END 关键字之后的以下串之一：BLOCK DATA、MODULE、PROGRAM、SUBROUTINE、FUNCTION、INTERFACE、TYPE、IF、DO、SELECT、WHERE 或“EOS”。编译器没有找到相应的串。

消息标识：ERROR_0186

## Error:如果指定了 POINTER 或 DIMENSION 属性，则组件定义语句中必须有“::”分隔符。

根据 Fortran 标准的要求，组件声明语句的 POINTER 和/或 DIMENSION 属性说明之后跟 :: 分隔符。例如：

    TYPE ::NEW_TYPE
    INTEGER, POINTER ::A     !Legal
    REAL, DIMENSION(100)  B   !非法
    END TYPE

消息标识：ERROR_0187

## Error:此名称已经用作此派生类型的组件名称。

派生类型的每个组件都必须有唯一的名称。此名称已经是此派生类型的组件名称。

消息标识：ERROR_0188

## Error:组件具有 POINTER 属性，因此 DIMENSION 属性必须为延迟形维数。

如果组件具有 POINTER 和 DIMENSION 属性，则其维数必须为延迟形维数。

消息标识：ERROR_0189

## Error:组件“%s”没有 POINTER 属性，所以其维数必须为带有恒定边界的显形数组。

如果组件有 DIMENSION 属性，但没有 POINTER 属性，则 DIMENSION 必须为带有恒定边界的显形定义。

消息标识：ERROR_0190

## Error:组件声明的字符长度必须为常量表达式。

组件定义的字符长度必须为常量表达式。

消息标识：ERROR_0191

## Error:“* char-length”必须只能为字符类型的对象指定。

为非字符型组件或数据对象指定了“*char_length”。

消息标识：ERROR_0192

## 内部：在入口字段中发现未预料值。

在符号表字段中发现的值无效。它是由于下列原因生成的：
-- 在 AT_TYPE 中发现超出“结构”外的某些东西。
-- 发现一个函数，其在 ATP_RSLT_IDX 中有 NULL_IDX。
-- 如果对于一个派生类型，计数非零，那么必须设置 ATO_CHAR_CPNT、ATO_POINTER_CPNT 或 ATO_NUMERIC_CPNT。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0193

## Error:DO 变量必须为变量名。

迭代 DO 语句具有以下格式：

    DO [label] [,] do_variable = scalar_numeric_expr,
    scalar_numeric_expr [, scalar_numeric_expr]

DO 变量必须是一个命名标量变量； 例如，它不能是一个函数名或命名常量名。

消息标识：ERROR_0194

## Error:在屏蔽的数组赋值中，屏蔽表达式和所定义的变量必须为同形数组。

所有屏蔽赋值语句必须与屏蔽表达式的形式相匹配。

消息标识：ERROR_0195

## 内部：使用长度超过字符数最大值的标记调用函数。

符号表搜索例程经过优化并对所搜索项大小有限制。调用此例程来搜索超出例程限制的项。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0196

## Error:意外语法：预期要求的与找到的不一样。

此语句的语法不正确。在分析期间，编译器在查找一项内容，但却找到了其它内容。这是一个分析器使用的常见消息。

消息标识：ERROR_0197

## Error:在 EXTERNAL 和 INTRINSIC 语句中，“::”分隔符是非法的。

INTRINSIC 语句的语法是：

    INTRINSIC intrinsic_procedure-name_list

EXTERNAL 语句的语法是：

    EXTERNAL external_name_list

消息标识：ERROR_0198

## Error:DO 变量必须为非限定名。

迭代 DO 语句具有以下格式：

    DO [label] [,] do_variable = scalar_numeric_expr,
    scalar_numeric_expr [, scalar_numeric_expr]

DATA 语句、某些 I/O 语句和数组构造函数必须包含隐含 DO 语句。隐含 DO 语句的格式是：

    (data_i_do_object_list, data_i_do_variable =
    scalar_int_expr, scalar_int_expr [, scalar_int_expr])

    (io_implied_do_object_list, do_variable =
    scalar_numeric_expr, scalar_numeric_expr
    [, scalar_numeric_expr])

    (ac_value_list, ac_do_variable =
    scalar_int_expr, scalar_int_expr
    [, scalar_int_expr])

DO 语句和 I/O 语句的 DO 变量，DATA 语句的 data_i_do_variable 和数组构造函数的 ac_do_variable 都称为“DO 变量”。在每种情况下，DO 变量必须是命名变量；即必须是一个简单的非限定名。例如，不能包含下标列表或结构组件分隔符“%”。

消息标识：ERROR_0199

## Ansi：此编辑描述符的使用是对 Fortran 标准的一个扩展。

格式说明包含一个对 Fortran 标准扩展的编辑说明符。以下非标准编辑说明符可被编辑器接受：

Zw
  十六进制整数
Rw
  右对齐字符
$
  禁止回车控制
[n]X
  空格，忽略 n 是非标准的
n/
  回车控制，n 是非标准的

消息标识：ANSI_0200

## Error:在 ALLOCATE 语句中的分配对象必须是指针或可分配数组。

ALLOCATE 语句中的所有参数必须事先声明为指针或可分配数组。

消息标识：ERROR_0201

## Error:此 ALLOCATE/DEALLOCATE 语句的状态变量必须为标量整型变量。

在 ALLOCATE 或 DEALLOCATE 语句中用作状态变量的变量，STAT = stat_variable，不能是数组并且必须是整数类型。

消息标识：ERROR_0202

## Error:在 ALLOCATE 语句中，STAT= 必须跟随所有分配项之后。

在 ALLOCATE 语句中没有必须跟随状态变量的分配项。STAT = stat_variable 必须是列表中的最后一项。

消息标识：ERROR_0203

## Error:下标的数量大于声明维数的数量。

使用了格式为 a(s[,s]...) 的数组引用。引用中的下标数应等于在 DIMENSION、COMMON、POINTER 或类型语句中为数组声明的维数。作为对 Fortran 标准的扩展，编译器允许数组引用指定小于声明维数的下标数。在此情况下，使用还未指定的维数的下界。

消息标识：ERROR_0204

## Error:如果在 ALLOCATE 语句中指定了数组，那么它必须具有分配形式规范列表。

在未提供分配形式规范列表的 ALLOCATE 语句中试图分配数组。分配形式规范列表的语法是

    [lower_bound :]upper_bound

消息标识：ERROR_0205

## Error:常量初始化表达式中的指数必须为整数类型。

Fortran 标准要求如果在常量初始化表达式中使用了求幂，那么该幂必须具有整数指数。

消息标识：ERROR_0206

## 内部：复位句式试图将源输入复位到不在源缓冲区中的行中。

例程 reset_src_input 试图将源输入索引重新设置为一个在源输入缓冲区中不再有效的行号。源输入只应在当前行上被重新设置。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0207

## Ansi：将 Cray 指针用作 DO 变量是 Fortran 标准的一个扩展。

Cray 指针被用作一个 DO 变量。对 Cray 指针的支持是对 Fortran 标准的一个扩展。

消息标识：ANSI_0208

## Error:没有与此伪参数编号对应的实际参数。

交替返回伪参数 (*) 没有与其相匹配的标签实际参数。

消息标识：ERROR_0209

## Error:它包含错误的属性。因为它不是常量，所以不能用于初始化表达式。

编译器检测到对此对象的非法使用。若要在初始化表达式中使用，对象必须是常量。常量只可能有的属性是 PARAMETER、PRIVATE 或 PUBLIC。常量必须指定为显式类型并且可声明为显形数组。

消息标识：ERROR_0210

## Error:此语句不允许续行。

此固定源格式的续行未跟随在一个正规源行之后。此错误消息在程序第一行为续行时出现。

消息标识：ERROR_0211

## Error:这是设定类型的，因此它不能包含为其指定的组件引用。

正在讨论的对象后面跟随一个结构组件名分隔符 (%)，但对象未声明为派生类型。

消息标识：ERROR_0212

## Error:这不是那种派生类型的组件。

在分析组件引用时，编译器检测到未声明为派生类型组件的名称。

消息标识：ERROR_0213

## 限制：已超出致命错误的最大数量。

编译器将在超出允许的致命错误最大数量时终止。最大数量被设置为 100。 使用命令行选项 -dq 可更改此设置。-dq 选项允许不限制致命错误的数量。

消息标识：LIMIT_0214

## Error:语句函数的伪参数必须具有长度为整型常数表达式的字符长度。

如果语句函数的伪参数为字符型，那么其长度必须为整型常量表达式。编译器检测到语句函数伪参数类型为字符型，但其长度为假定长度或变量长度。

消息标识：ERROR_0215

## Error:字符串在用作数据集名称或布尔常量时，必须少于最大字符数。

编译器检测到不适合机器字的字符串。预期应该是数据集名或整型表达式。数据集名是 I/O 语句中控制信息列表中的外部文件标识符。

消息标识：ERROR_0216

## Error:DO 循环表达式必须是整型、缺省实数、或双精度实数等类型。

DO 语句的 loop_control 部分中的每个表达式都必须为数值并且为整型、缺省实数或双精度实数。缺省实数或双精度实数类型的 DO 循环表达式是一个废弃特征。整型类型为首选。

消息标识：ERROR_0217

## 注释：缺省实数或双精度实数类型的 DO 循环表达式是一个废弃特征。

实数或双精度实数 DO 循环表达式是一个废弃特征。（废弃特征是 FORTRAN 77 的特征，现在是多余的并且有更好的方法。）类型为整型的表达式应用来替代类型为缺省实数或双精度实数的 DO 循环表达式。

消息标识：COMMENT_0218

## Error:DO 变量必须是整型、缺省实数、或双精度实数等类型。

DO 语句的 DO 变量必须为数值并且为整型类型、缺省实数或双精度实数。对缺省实数或双精度实数 DO 变量的使用是一个废弃特征。整型类型为首选。

消息标识：ERROR_0219

## 注释：缺省实数或双精度实数类型的 DO 变量是一个废弃特征。

废弃特征是 FORTRAN 77 特征，现在是多余的并且有更好的方法。类型为整型的 DO 变量应被用来替换类型为缺省实数或双精度实数的 DO 变量。

消息标识：COMMENT_0220

## Ansi：非整型边界表达式是 Fortran 标准的一个扩展。

Fortran 标准要求所有的边界表达式为整型类型。

消息标识：ANSI_0221

## Error:这个 DO 语句表达式必须是标量。

在以下格式的 DO 语句中

    DO [label] [,] do_variable = scalar_numeric_expr,
    scalar_numeric_expr [, scalar_numeric_expr]

每个 scalar_numeric_expr 都必须是标量。

在以下格式的 DO 语句中

    DO [label] [,] WHILE (scalar_logical_expr)

scalar_logical_expr 必须是标量。

消息标识：ERROR_0222

## Error:DO 变量必须是标量。

在以下格式的 DO 语句中

    DO [label] [,] do_variable = scalar_numeric_expr,
    scalar_numeric_expr [, scalar_numeric_expr]

do_variable 必须是标量。

消息标识：ERROR_0223

## 内部：编译器生成的 DO 循环表达式的语义分析失败。

有两个由编译器生成的表达式树作为 DO 语句表示的一部分：迭代计数计算和 DO 变量的求值计算。这两个计算都只涉及已建立的编译器临时变量。语义分析只用来在表达式树中向上传送数据类型等，因此语义分析不应失败。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0224

## Error:对于 [%s][%s]，表 %s 中的错误标志是 TRUE (1)，但消息编号是 0。

此消息后面总是跟随一个内部消息并且编译器终止。

此消息由调试编译主初始化时调用的调试例程发出。此例程仔细检查语义表并确认标志和消息相一致。所涉及的表为：

标志表
  消息表
obj_to_attr
  attr_msg_num
obj_to_name
  name_msg_num
obj_to_other
  other_msg_num

检验两个表中的条目并改变一个或另一个表以使两个表一致。如果发出了此消息，组合将被在表中标记为错误，但没有为表中的组合指定的错误消息。

消息标识：ERROR_0225

## 内部：语义表有问题。请参阅前一个错误消息。

如果在语义表中 verify_semantic_tbls 发现任何问题，将生成此内部错误。为每个问题生成致命错误。此最终内部错误在停止编译的结束处生成。

应避免产生此消息。这是一个错误的编译器或错误的安装。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。

消息标识：INTERNAL_0226

## Error:对于此，表中的错误标志为 FALSE (0)，但消息编号是未预料的。

此消息后面总是跟随一个内部消息并且编译器终止。

此消息由调试编译主初始化时调用的调试例程发出。它仔细检查语义表并确认标志和消息相一致。所涉及的表为：

标志表
  消息表
obj_to_attr
  attr_msg_num
obj_to_name
  name_msg_num
obj_to_other
  other_msg_num

检验两个表中的条目并改变一个或另一个表以使两个表一致。如果生成了此消息，那么组合是合法的，但表中有此组合的错误消息。

消息标识：ERROR_0227

## Error:BUFFER IN 或 BUFFER OUT 语句的模式说明符必须为整型类型。

BUFFER IN 或 BUFFER OUT 语句包含不正确的模式说明符。在以下语句中，模式说明符 m，必须为整型表达式：

    BUFFERIN (id,m) (bloc,eloc)
    BUFFEROUT (id,m) (bloc,eloc)

模式说明符不能是数组表达式。

消息标识：ERROR_0228

## Error:单元说明符或文件标识符不是有效的数据类型或形式。

I/O 语句包含不正确的单元或文件标识符。

单元标识符可以是以下之一：
-- 一个取值范围为 0 至 101 的整型表达式。
-- 一个表示缺省单元的星号。

文件标识符可以是以下之一：
-- 一个字符变量、数组元素、数组或指定一个内部文件的子串。
-- 一个使用撇号括起、最多包含 7 位字母数字字符并指定一个外部文件名的字符串。

消息标识：ERROR_0229

## Error:BUFFER IN 或 BUFFER OUT 语句的模式说明符必须是标量。

BUFFER IN 或 BUFFER OUT 语句包含不正确的模式说明符。在以下语句中，模式说明符 m，必须为整型表达式：

    BUFFERIN (id,m) (bloc,eloc)
    BUFFEROUT (id,m) (bloc,eloc)

模式说明符不能是数组表达式。

消息标识：ERROR_0230

## Error:字符串超出了数据集名称大小的最大值。

I/O 语句中控制信息列表内的外部文件标识符超过了 7 个字符。在 Cray Research 通用（64 位）体系结构中，文件标识符必须由 1 至 7 个数字字母字符组成。在 32 位体系结构中，限制为 4 个字符。

消息标识：ERROR_0231

## Error:IMPLICIT NONE 在局部范围指定，因此必须为此函数指定显式类型。

当设置了 IMPLICIT NONE 时，所有函数必须具有显式类型。

消息标识：ERROR_0232

## Error:IMPLICIT NONE 在主机范围内指定，因此必须为此函数指定显式类型。

当在主机范围内设置了 IMPLICIT NONE 时，所有函数必须具有显式类型，包括任何包含范围中的函数。

消息标识：ERROR_0233

## Error:DO WHILE 表达式必须为逻辑类型。

在以下格式的 DO 语句中：

    DO [label] [,] WHILE (scalar_logical_expr)

scalar_logical_expr 必须是逻辑类型。

消息标识：ERROR_0234

## Error:具有指针组件的派生类型 I/O 列表项是不被允许的。

如果一个派生类型最终包含了一个指针组件，那么此类型的对象既不能作为一个 I/O 输入项也不能作为 I/O 输出列表项的评估结果出现。

消息标识：ERROR_0235

## 内部：在完成编译器生成的 CONTINUE 语句时所遇到的 NULL_IDX。

为完成一个编译器生成的 CONTINUE 语句，continue_stmt_semantics 将搜索跟在当前语句标题 (SH) 后面的不是由编译器生成并具有非零行号的语句标题。当遇到语句标题链的结束，而未发现满足以上标准的一个语句标题时将生成此内部错误消息。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0236

## 限制：对于此表，已超出表大小的最大值。

出现内部错误条件，因为一个内部表对于其索引字段大小来说变得太大。通常，这是由于程序太大，以致编译器无法处理而导致的。将您的代码分解为几个编译单元可能使得编译成功完成。

请通知您的产品支持组织以便我们检验是否达到了编译器的限制。

消息标识：LIMIT_0237

## Error:这被声明为一个命名常量。类型假定为不同。

编译器检测到通过类型声明语句或 IMPLICIT 语句试图来重新设定命名常量的类型。这样做只有在类型符合对象的隐式类型时才合法。

    PARAMETER (A = 3.0)
    INTEGER A               !非法

    PARAMETER (I = 4)
    INTEGER I        !Legal

    PARAMETER (I = 4)
    IMPLICIT INTEGER (I)    !Legal

    PARAMETER (I = 4)
    IMPLICIT CHARACTER (I)  !非法

消息标识：ERROR_0238

## Error:它已在 DATA 语句中初始化。类型假定为不同。

编译器检测到试图重新设定已初始化对象的类型。这样做只有在类型符合对象的隐式类型时才合法。

    DATA A /3/
    INTEGER A	! This is illegal

    DATA I /3/
    INTEGER I	! Legal

消息标识：ERROR_0239

## Error:在边界规范表达式中引用了外部函数。它必须有一个非指针型标量结果。

在数组维数约束声明符或字符长度声明符中允许外部函数调用是对 Fortran 标准的一个扩展。这些函数不能具有值确定的数组或值确定的指针结果。

消息标识：ERROR_0240

## 注释：非块 DO 构造是一个废弃特征。

废弃特征是 FORTRAN 77 特征，现在是多余的并且有更好的方法。非块 DO 构造是一个废弃特征。如果一个 DO 语句包含一个标签，并且循环终止语句不是 END DO 或 CONTINUE，那么该循环就定义为非块 DO 构造。应使用 CONTINUE 或 END DO 语句来终止一个 DO 循环。如果多个 DO 循环使用相同的语句终止，那么单独的 CONTINUE 或 END DO 语句应被用来终止每个嵌套 DO 循环。

消息标识：COMMENT_0241

## Error:非块 DO 构造的终止语句不能是无条件 GO TO 语句。

如果一个 DO 语句包含一个标签，并且循环终止语句不是 END DO 或 CONTINUE，那么该循环就定义为非块 DO 构造。无条件 GO TO 语句不能用作非块 DO 构造的终止语句。

消息标识：ERROR_0242

## Error:非块 DO 构造的终止语句不能是赋值 GO TO 语句。

如果一个 DO 语句包含一个标签，并且循环终止语句不是 END DO 或 CONTINUE，那么该循环就定义为非块 DO 构造。赋值 GO TO 语句不能用作非块 DO 构造的终止语句。

消息标识：ERROR_0243

## Error:非块 DO 构造的终止语句不能是此语句。

如果一个 DO 语句包含一个标签，并且循环终止语句是 action_stmt 而不是 END DO 或 CONTINUE，那么该循环就定义为非块 DO 构造。以下 action_stmt 不能用作非块 DO 构造的终止语句：RETURN、STOP、EXIT、CYCLE、END FUNCTION、END SUBROUTINE、END PROGRAM 或算术 IF。

消息标识：ERROR_0244

## 内部：调用列表中的参数数量大于预期的最大列表。

实际参数数量大于分配的内部表大小。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0245

## Error:非块 DO 构造的终止语句不能是过时的 IF 语句。

如果一个 DO 语句包含一个标签，并且循环终止语句不是 END DO 或 CONTINUE，那么该循环就定义为非块 DO 构造。过时的 IF 语句是间接逻辑 IF 语句或二叉算术 IF 语句。这些语句已经被能够增强 Fortran 程序可移植性的其它语句所代替。IF 构造或逻辑 IF 应被用来替换这些过时的格式。

消息标识：ERROR_0246

## Error:EQUIVALENCE 语句中的下标或子串表达式必须是整型常数表达式。

等价项中的每个下标或子串表达式必须是标量整型常量表达式。

消息标识：ERROR_0247

## Error:DO 语句标签已定义。

DO 语句指定的终止语句标签已在作用单元中定义。按照定义，循环终止语句必须跟随 DO 语句。因此，此标签必须是在 DO 语句之后的一个语句上。

消息标识：ERROR_0248

## 内部：fold_relationals 中存在编译器内部错误。未预料操作数类型。

例程 fold_relationals 发现无效的操作数类型。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0249

## Error:EQUIVALENCE 语句中不允许数组语法。

EQUIVALENCE 语句中不允许分段数组引用。

消息标识：ERROR_0250

## 内部：fold_relationals 中存在编译器内部错误。未预料运算符。

调用例程 fold_relationals 来收起不打算显示的运算符。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0251

## Error:这个数组语法运算中的操作数不一致。

数组语法操作中的两个操作数必须在形式上相一致。具有常数下标的两个数组在形式上不一致。

消息标识：ERROR_0252

## Error:此数组语法赋值的左右侧必须是一致的数组。

当一个赋值语句采用数组语法时，其左右两侧必须在形式上相一致。

消息标识：ERROR_0253

## 注意：DO 语句表达式的值妨碍循环的执行。

迭代 DO 语句具有以下格式：

    DO [label] [,] do_variable =
    	start_expr, end_expr [, inc_expr]

DO 循环的迭代数由下式计算：

    MAX( INT( (end_expr - start_expr + inc_expr) /
    	inc_expr), 0)

对于以下两种情况，迭代数是 0：

    start_expr > end_expr  and  inc_expr > 0,
    或
    start_expr < end_expr  and  inc_expr < 0

如果迭代数为 0，那么循环将不执行。

消息标识：CAUTION_0254

## Error:增加表达式的值一定不能是 0。

DO 语句包含值为 0 的增量表达式。它必须大于或小于 0。

消息标识：ERROR_0255

## Error:伪参数具有 POINTER 属性。它需要一个具有 POINTER 属性的实际参数。

具有 POINTER 属性的伪参数必须与具有 POINTER 属性的实际参数相匹配。

消息标识：ERROR_0256

## 内部：在属性表的此字段中检测到非法项。

在符号表中发现未预料值。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0257

## Error:此实际参数是一个假定大小数组，因此它一定不能与假定形伪参数相关联。

假定形伪参数不能与假定大小实际参数相关联。

消息标识：ERROR_0258

## Error:在边界规范表达式中对其递归引用是非法的。

在边界规范表达式中允许函数引用是对 Fortran 标准的一个扩展。递归函数引用在边界规范表达式中是不允许的。编译器检测到与下列示例相似的内容：

    FUNCTION IFUNC()
    RECURSIVE IFUNC
    DIMENSION A(IFUNC())

对 IFUNC 的引用是非法的，因为边界表达式必须在入口点计算。

消息标识：ERROR_0259

## 内部：未预料块栈顺序。

如果当前块类型大于 Interface_Body_Blk，过程 cif_begin_scope_rec 预期它是这样，因为这些块类型之一是主程序中的第一个语句。“块栈”已经被破坏或 cif_begin_scope_rec needs 应被修正，因为它做了不正确的假设。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0260

## Error:此语句在函数子程序中不被允许。

函数子程序中不允许出现 PRIVATE 和 PUBLIC 语句。

以下语句必须位于将要在函数子程序中的接口块、作用单元或构造内。
-- 派生类型定义中的 SEQUENCE、END TYPE
-- 通用接口块中的 MODULE PROCEDURE
-- IF 构造中的 ELSE、ELSEIF、END IF
-- CASE 构造中的 CASE、END SELECT
-- WHERE 构造中的 ELSEWHERE、END WHERE
-- DO 构造中的 CYCLE、EXIT、END DO
-- 接口块中的 FUNCTION、SUBROUTINE、END SUBROUTINE

消息标识：ERROR_0261

## Error:此语句不在匹配 DO 构造范围内。

CYCLE 和 EXIT 语句必须在 DO 构造范围内指定。如果 CYCLE 或 EXIT 语句引用了 DO 构造名，那么它必须在具有该 DO 构造名的 DO 构造范围之内。

消息标识：ERROR_0262

## 内部：语义传递语句驱动程序遇到非法或未知语句类型。

语义传递中将语义处理应用到每个语句的驱动程序，从函数指针数组中选择适当的语义例程。进入数组的索引无效。它必须是正值，但却可能是 0 或负值。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0263

## Error:此语句不允许在 CONTAINS 语句之后。应该是 FUNCTION、SUBROUTINE 或 END 语句。

CONTAINS 语句后只允许是 SUBROUTINE、FUNCTION 和 END 语句。SUBROUTINE 和 FUNCTION 开始一个新的内部或模块子程序。

消息标识：ERROR_0264

## Ansi：在第一个可执行语句后指定 NAMELIST 语句是对 Fortran 标准的一个扩展。

Fortran 标准要求所有的 NAMELIST 语句处于程序单元的规范部分。允许 NAMELIST 语句散布在可执行语句之间是 Fortran 标准的一个扩展。然而，名称列表组的所有定义必须在引用之前完成。

消息标识：ANSI_0265

## Ansi：编辑描述符 -nX 的使用是 Fortran 标准的一个扩展。

使用带有 X 编辑描述符的负值是 Fortran 标准的一个扩展。

消息标识：ANSI_0266

## Error:在 IF 构造的 THEN 块中不允许此语句。

IF 构造允许以下语句：

    ALLOCATE               ASSIGN
    BACKSPACE              BUFFER
    CALL                   CLOSE
    CONTINUE               DATA
    DEALLOCATE             DECODE
    DO                     ENCODE
    ENDFILE                ENDIF
    ELSE                   ELSEIF
    FORMAT                 GOTO
    IF                     INQUIRE
    NAMELIST               NULLIFY
    OPEN                   PAUSE
    PRINT                  READ
    RETURN                 REWIND
    SELECT                 STOP
    WHERE                  WRITE
    assignment

如果满足所列条件，则允许下面的语句。
-- CASE 构造中的 CASE、END SELECT
-- WHERE 构造中的 ELSEWHERE、END WHERE
-- DO 构造中的 CYCLE、EXIT、END DO。

消息标识：ERROR_0267

## Error:在 DO 构造中不允许此语句。

在 DO 构造中允许以下语句：

    ALLOCATE               ASSIGN
    BACKSPACE              BUFFER
    CALL                   CLOSE
    CONTINUE               DATA
    DEALLOCATE             DECODE
    DO                     ENCODE
    ENDFILE                ENDIF
    ELSE                   ELSEIF
    FORMAT                 GOTO
    IF                     INQUIRE
    NAMELIST               NULLIFY
    OPEN                   PAUSE
    PRINT                  READ
    RETURN                 REWIND
    SELECT                 STOP
    WHERE                  WRITE
    assignment

在列出的构造中允许下面的语句。
-- CASE 构造中的 CASE、END SELECT
-- IF 构造中的 ELSE、ELSEIF、END IF
-- WHERE 构造中的 ELSEWHERE、END WHERE

消息标识：ERROR_0268

## Error:此语句不允许跟在 SELECT CASE 语句之后。

SELECT CASE 语句后只能跟 CASE 语句。编译器发现 SELECT CASE 语句后有其它语句（不是 CASE 语句）。

消息标识：ERROR_0269

## Error:在 WHERE 构造中不允许此语句。

在 WHERE 构造的 WHERE 块或 ELSEWHERE 块中只允许数组赋值语句。编译器在 WHERE 或 ELSEWHERE 块中发现另外的语句（不是数组赋值语句）。

消息标识：ERROR_0270

## Error:%s 语句不允许在接口体中出现。

接口体允许以下语句：

ALLOCATABLE
  COMMON
派生类型定义
  DIMENSION 语句
END FUNCTION
  END SUBROUTINE
EQUIVALENCE
  EXTERNAL
IMPLICIT
  IMPLICIT NONE
INTENT
  INTRINSIC
NAMELIST
  OPTIONAL
PARAMETER
  POINTER
SAVE
  TARGET
类型声明
  USE

如果满足所列条件，则允许下面的语句：
-- 派生类型定义中的 SEQUENCE、END TYPE
-- 模块程序单元中的 PUBLIC、PRIVATE

消息标识：ERROR_0271

## Error:此语句在子例程子程序中不被允许。

子例程子程序中不允许出现 PRIVATE 和 PUBLIC 语句。

这些语句必须位于将要在子例程子程序中的接口块、作用单元或构造中。
-- 在派生类型定义中的 SEQUENCE、END TYPE
-- 在通用接口块中的 MODULE PROCEDURE
-- 在 IF 构造中的 ELSE、ELSEIF、END IF
-- 在 CASE 构造中的 CASE、END SELECT
-- 在 WHERE 构造中的 ELSEWHERE、END WHERE
-- 在 DO 构造中的 CYCLE、EXIT、END DO
-- 在接口块中的 FUNCTION、END FUNCTION、SUBROUTINE、END SUBROUTINE、END INTERFACE

消息标识：ERROR_0272

## Error:为组件声明多次指定此属性。

一个组件只能指定一次属性。已为组件多次指定 DIMENSION 或 POINTER 属性，如下所示：

    TYPE ::ABC
    REAL, POINTER, POINTER ::IJK ! illegal
    END TYPE ABC

消息标识：ERROR_0273

## Ansi：对于限定表达式，Fortran 要求所有的内在过程实际参数为整型或字符类型。

在 Fortran 中，限定表达式允许基本函数引用。内在过程的每个参数都必须为整数或字符类型。如果表达式结果为整数或字符类型，编译器允许参数为整数或字符之外的其它类型。

消息标识：ANSI_0274

## Error:对于此派生类型，PUBLIC 和/或 PRIVATE 属性被多次指定。

只能为派生类型声明一次 PUBLIC 或 PRIVATE 属性。

消息标识：ERROR_0275

## Error:要在初始化表达式中使用，它必须是常量。

编译器检测到此对象的非法使用。要在初始化表达式中使用，它必须是常量。

消息标识：ERROR_0276

## Error:它作为此调用的关键字是无效的。

编译器检测到与被调用例程显式接口中的伪参数名不匹配的实际参数关键字。

消息标识：ERROR_0277

## 内部：不存在用于此语句类型的语义例程。

语句级别语义处理驱动程序遇到一个语义标题，其中包含无语义例程语句的语句类型值。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0278

## Ansi：已经为被编译的程序单元指定了 EXTERNAL 属性。这是非标准的。

编译器检测到以下内容：

    SUBROUTINE JOE()
    EXTERNAL JOE  !This is nonstandard
    RETURN
    END

消息标识：ANSI_0279

## Ansi：对于规范表达式，Fortran 要求所有的内在过程实际参数为整数类型。

在 Fortran 中，规范表达式允许基本函数引用。内在过程的每个参数都必须为整数类型。只要表达式结果的类型为整型，编译器就允许参数类型为整数之外的其它类型。

消息标识：ANSI_0280

## Error:赋值语句的左侧必须是变量或函数结果。

此赋值语句左侧无效。这可能是向以下量赋值导致的：常量、外部子程序名、名称列表组名或除当前函数的变量或函数结果名外的其它实体。

消息标识：ERROR_0281

## Error:函数是在一个接口块中声明的，因此，其类型不能为假定长度的字符。

类型可为假定长度字符的函数只有外部函数。如果函数是在一个接口块内声明的，那么其类型不能为假定长度的字符。接口块只能用于显式声明的外部子程序。

消息标识：ERROR_0282

## Error:在此语句中指定的名称必须匹配。

编译器检测到在 END 语句中指定的名称与程序单元或派生类型的名称不匹配。

以下语句的名称必须匹配：

    PROGRAM/END PROGRAM program_name
    MODULE/END MODULE  module_name
    BLOCKDATA/END BLOCK DATA block_data_name
    SUBROUTINE/END SUBROUTINE subroutine_name
    FUNCTION/END FUNCTION function_name
    TYPE/END TYPE type_name

消息标识：ERROR_0283

## Error:此构造具有构造名，因此，该语句必须指定相同的构造名。

如果 IF、DO 或 CASE 构造具有构造名，那么 END IF、END DO 或 END SELECT 语句必须指定相同的构造名。编译器检测到构造名间有差异，或 END 语句缺少构造名。

消息标识：ERROR_0284

## Error:如果此构造没有构造名，那么该语句不能有指定的构造名。

如果 DO、IF 或 CASE 构造没有构造名，那么相应的 END DO、END IF 或 END SELECT 语句也不能具有指定的构造名。

消息标识：ERROR_0285

## Error:派生类型的类型名不能与内类型%s的名称相同。

编辑器检测到下列情况之一：

    TYPE ::INTEGER
    TYPE ::REAL
    TYPE ::DOUBLE PRECISION
    TYPE ::COMPLEX
    TYPE ::CHARACTER
    TYPE ::LOGICAL

以上均为非法，因为派生类型的类型名不能与任何内类型的名称相同。

消息标识：ERROR_0286

## 警告：函数子程序中的函数名的结果未定义。

到达函数末尾，并且函数中未定义或指定函数返回值。必须在函数执行期间定义函数返回值。

消息标识：WARNING_0287

## Error:此 DO 语句丢失终止语句。

编译器检测到此 DO 语句没有相应的终止语句。如果 DO 语句未指定标签，那么 DO 循环必须使用 END DO 语句终止。如果 DO 语句指定了标签，那么 DO 循环必须使用 END DO 语句或除下列语句外的任何活动语句终止：

    无条件 GO TO
    赋值 GO TO
    RETURN
    STOP
    EXIT
    CYCLE
    END FUNCTION
    END SUBROUTINE
    END PROGRAM
    算术 IF

消息标识：ERROR_0288

## Error:此语句无匹配语句。

编译器不能找到以此 END 语句结束的块的开始语句。以下 END 语句关闭相应的块：

    END              PROGRAM, MODULE, BLOCK DATA,
    FUNCTION, SUBROUTINE
    END PROGRAM      PROGRAM
    END FUNCTION     FUNCTION
    END SUBROUTINE   SUBROUTINE
    END BLOCK DATA   BLOCK DATA
    END MODULE       MODULE
    END IF           IF
    END DO           DO
    END SELECT       SELECT CASE
    END WHERE        WHERE
    END INTERFACE    INTERFACE
    END TYPE         TYPE

消息标识：ERROR_0289

## Error:派生类型必须具有至少一个为其声明的组件。

编译器没有检测到声明为结束于此语句的派生类型的组件。派生类型定义的语法要求至少一个组件声明，如下所示：

    derived_type_stmt
    [private_sequence_stmt]...
    component_def_stmt
    [component_def_stmt]...
    end_type_stmt

消息标识：ERROR_0290

## Error:此语句缺少 END 语句。

编译器检测到以下语法构造之一丢失其 END 语句：模块、块数据子程序、子例程子程序、函数子程序、IF 构造、DO 构造、CASE 构造、WHERE 构造、接口块、接口体或派生类型定义。END 语句要求所有这些内容。

消息标识：ERROR_0291

## Error:它在 USE 语句中被指定为模块名，但编译器找不到它。

编译器无法定位在 USE 语句中指定的模块名。编译器搜索了所有在当前程序单元之前指定的模块。如果它仍不能找到该模块，将搜索在 -p 命令行选项中指定的所有文件。

消息标识：ERROR_0292

## Error:此未命名的主程序单元缺少 END 语句。

编译器检测到文件提前结束。主程序单元必须由 END 语句终止。未命名主程序单元指没有使用 PROGRAM、SUBROUTINE、FUNCTION、MODULE 或 BLOCKDATA 语句作为其第一个语句的程序单元。

消息标识：ERROR_0293

## Error:等价对象必须是序列派生类型。

如果对象出现在 EQUIVALENCE 语句中，并且是派生类型，则它必须是序列派生类型。

消息标识：ERROR_0294

## 内部：例程预期 LA_CH 输入不同。

例程具有内置假定 - 先行字符是指定字符。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0295

## 内部：PRINTMSG 接收到一个 0 行编号。

所有消息（除了输出为标准错误的 Log 消息）必须具有非零的行号。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0296

## Error:已在主机范围中指定 IMPLICIT NONE，因此必须为此数据对象指定显式类型。

当在主机范围内指定 IMPLICIT NONE 时，所有数据对象必须具有显式类型，包括任何包含范围中的数据对象。

消息标识：ERROR_0297

## Error:在一个范围内只允许有一个 IMPLICIT NONE 语句。

当在作用单元中指定了 IMPLICIT NONE 语句时，在此作用单元中不能有其它 IMPLICIT 语句。

消息标识：ERROR_0298

## Error:在声明了独立的函数结果变量后，不能给函数名赋值。

在函数声明指定独立函数结果变量后，试图为函数名（函数结果变量）赋值。必须使用此结果变量。

消息标识：ERROR_0299

## Error:运算符“=、=> 和 %%”不能用作已定义的运算符。

编译器检测到运算符 =、=>，或 % 被用作 OPERATOR(defined_operator) 中的 defined_operator in 。有效 defined_operator 为：

       **	*	/	+
    -	//	.EQ.	.NE.
    .LT.	.LE.	.GT.	.GE.
       ==	/=	<	<=
    >	>=	.NOT.	.AND.
    .OR.	.EQV.	.NEQV.
    defined-unary-op
    defined-binary-op

备注：defined-unary-op 和 defined-binary-op 是 .letter[letter]... .

消息标识：ERROR_0300

## 警告：对于要创建模块的模块信息文件必须请求二进制输出。

因为未创建二进制输出文件，将不创建模块信息文件。模块信息文件在该二进制文件中，因此不可写入。在命令行指定 -dB 或生成汇编语言文件，将使此二进制文件无法生成。

消息标识：WARNING_0301

## Error:操作数等级不一致。

数组语法表达式中的二进制运算符的等级必须一致。这意味着等级必须相等，或一个或两个操作数必须为标量。

消息标识：ERROR_0302

## Error:对于此运算不允许使用此数据类型。

表达式的两个操作数所属数据类型对于正在使用的运算符非法。

消息标识：ERROR_0303

## Error:FORMAT 说明符中缺少左括号。

此格式说明包含不对称的括号。

消息标识：ERROR_0304

## Error:FORMAT 说明符中缺少右括号或出现未预料结束。

格式说明包含不对称的括号。左括号多于右括号。

消息标识：ERROR_0305

## Error:应该是整型常量。

格式说明中使用了不完整的编辑描述符。在指定以下编辑描述符时必须严格遵循格式：

    Ew.d	Ew.dEe
    Fw.d
    Gw.d	Gw.dEe
    Dw.d	Dw.dEe
    Iw	Iw.m
    Bw	Bw.m
    Ow	Ow.m
    Zw	Zw.m
    Rw
    Lw
    kP    -kP   +kP
    Tc
    TLc
    TRc
    -nX

不能省略值 w、d、m、k、n 和 c。

消息标识：ERROR_0306

## Error:应该是句点。

编译器要求这里是句点。这些编辑描述符必须依照以下格式：

    Ew.d	Ew.dEe
    Fw.d
    Gw.d	Gw.dEe
    Dw.d

消息标识：ERROR_0307

## Error:应该有 -nP、-nX 或 +nP，但却找到其它东西。

编译器发现了 -n（其中 n 是整数）并预期其后为 P 或 X；或编译器发现了 +n 并预期其后为 P。

消息标识：ERROR_0308

## Error:对于此编辑描述符不允许重复计数。

不可重复编辑描述符与重复计数一起使用。以下编辑描述符不能重复：

    kP    比例因子
    "     文字串
    '     文字串
    BN    被忽略的空格
    BZ    视为 0 的空格
    :     终止格式控制
    Tn    定位
    TLn
    TRn
    nX    间距
    $     回车控制
    SP    加法符号
    S     加法符号
    SS    加法符号

消息标识：ERROR_0309

## Error:重复计数值必须大于 0。

对于此格式说明，重复计数无效。格式说明必须为以下格式：

    ([format_item_list])

format_item_list 是以下格式的项目列表：

    [r] data_edit_desc
    control_edit_desc
    char_string_edit_desc
    [r] (format_item_list)

r 是非零、无符号整型常量。

消息标识：ERROR_0310

## Error:字段宽度不能为 0。

编译器在编辑描述符上发现 0 字段宽度或指数宽度。在以下编辑描述符中，值 w 和 e 不能为 0：

    Ew.d  Ew.dEe
    Fw.d
    Gw.d  Gw.dEe
    Dw.d  Dw.dEe
    Iw    Iw.m
    Aw
    Ow    Ow.m
    Zw    Zw.m
    Rw
    Lw

消息标识：ERROR_0311

## Error:已超出了字段宽度、十进制字段宽度、指数字段宽度或重复计数的最大值。

对于可重复编辑描述符，字段总宽度和十进制数字段宽度允许的最大值为 16,777,215。指数字段宽度允许的最大值为 63。重复计数允许的最大值为 2,147,483,647。

消息标识：ERROR_0312

## Error:H 编辑描述符丢失或其长度为 0。

H 编辑描述符与不适当的字符数值一起使用。用于输出霍尔瑞斯字符串的 H 编辑描述符，必须依照以下格式：

    nH

n 必须为非零正整数。

消息标识：ERROR_0313

## Error:检测到未知编辑描述符。

此格式说明包含未知编辑描述符。

消息标识：ERROR_0314

## Error:在最后编辑描述符处理完成前遇到数据结束。

H 编辑描述符指定了大于语句长度的字符数。例如，以下语句将导致发出此消息：

    10    FORMAT(100HABCDEFGHIJ)

消息标识：ERROR_0315

## Error:霍尔瑞斯、八进制、十六进制和二进制常数不允许作为 I/O 列表项。

在 I/O 语句中布尔类型的常量不允许作为输入或输出列表项。布尔常数为霍尔瑞斯常数或十六进制、八进制或二进制常数。一些示例包括

    	4habcd
    	"abcd"R
    	77b
    	x"a77"

消息标识：ERROR_0316

## Ansi：将它用作点运算符是 Fortran 标准的一个扩展。

以下点运算符是 Fortran 标准的扩展。

    .A.    （.AND. 的同义字）
    .N.    （.NOT. 的同义字）
    .O.    （.OR. 的同义字）
    .X.    （.NEQV. 的同义字）
    .XOR.

扩展点运算符不允许用作已定义的运算符。

消息标识：ANSI_0317

## Error:此运算符未声明为用户定义运算符。

编译器检测到未声明为定义运算符并且不是内点运算符的点运算符。

消息标识：ERROR_0318

## Error:下标必须是标量整型表达式。

在数组引用或下标三元组数组引用中，编译器检测到不是标量整型表达式的下标。

消息标识：ERROR_0319

## Error:向量下标必须是等级为 1 的整型表达式。

编译器检测到数组引用中有等级大于 1 的向量下标。

消息标识：ERROR_0320

## Error:第二个下标不能从假定大小数组最后一维的下标三元组中省略。

第二个下标不能从假定大小数组最后一维的下标三元组中省略。

消息标识：ERROR_0321

## Error:这个对函数或派生类型的使用无效。

应该是加括号的列表，但未找到。正在讨论的对象是派生类型名或是对内部函数的向前引用。

消息标识：ERROR_0322

## Error:子串范围内的表达式必须是标量整数表达式。

编译器检测到不是标量整型表达式的子串范围。

消息标识：ERROR_0323

## Error:不允许将这种类型的表达式赋值给那种类型的变量。

除非有允许这样做的扩展赋值，否则，赋值语句两侧的等级必须一致，或右侧必须是 0 级表达式。

消息标识：ERROR_0324

## 内部：例程 get_dummy_arg_type 的调用使用了不是数据对象的伪参数。

例程 get_dummy_arg_type 的调用使用了无效参数。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0325

## Error:此赋值语句的左侧是一个常量。

赋值语句的左侧是命名常量或命名常量的子对象。

消息标识：ERROR_0326

## Ansi：IACHAR 和 ICHAR 的实际参数必须具有一个字符的长度。

IACHAR 和 ICHAR 的实际参数必须是长度等于 1。

消息标识：ANSI_0327

## Error:语句标签不是 FORMAT 语句标签。

正在需要 FORMAT 语句标签的上下文中，引用未在 FORMAT 语句上定义的语句标签。

消息标识：ERROR_0328

## Error:内在函数不允许出现在初始化表达式中。

在初始化表达式中不允许有该内在函数。它必须是基本内在函数或以下转换内在函数之一：

    REPEAT
    RESHAPE
    SELECTED_INT_KIND
    SELECTED_REAL_KIND
    TRANSFER
    TRIM

消息标识：ERROR_0329

## Error:已为伪参数指定了多个实际参数。

编译器发现为一个特定的伪参数指定了多于一个的实际参数。这可能是由两个相同参数关键字导致，或者由同一伪参数的一个参数关键字和一个位置参数导致。

消息标识：ERROR_0330

## Error:没有与该实际参数号对应的伪参数。

此实际参数无相应的伪参数。这是由于指定的实际参数多于伪参数。

消息标识：ERROR_0331

## Error:没有与该伪参数相对应的实际参数。

声明被调用例程的显式接口。编译器发现非可选性伪参数（没有 OPTIONAL 属性）没有相应实际参数。

消息标识：ERROR_0332

## Error:显式接口未知时，使用实际参数关键字。

只有编译时已知被调用例程的接口，才能使用参数关键字。此信息可以由接口块提供给外部子程序。内部子程序和模块子程序始终具有由定义指定的关键字信息。

消息标识：ERROR_0333

## Error:该实际参数的类型与伪参数的类型不匹配。

检测到被调用例程的显式接口中提供的实际参数的类型和伪参数的类型之间有差异。

消息标识：ERROR_0334

## Error:在 CALL 语句中，函数为非法引用。

该 CALL 语句正试图调用函数。只有子例程才能在 CALL 语句中指定。

消息标识：ERROR_0335

## Error:此实际参数的种类和与其相关联伪参数种类不匹配。

检测到被调用例程的显式接口中提供的伪参数的种类类型参数和实际参数的种类类型参数之间有差异。

消息标识：ERROR_0336

## Error:此实际参数的等级和相应的伪参数的等级不匹配。

发现在被调用例程的显式接口中，提供的伪参数的等级和实际参数的等级之间存在差异。

消息标识：ERROR_0337

## Error:交替返回的伪参数 (*) 需要用户标签作为其实际参数。

显式接口将此伪参数定义为交替返回参数 (*)，但是调用点不提供作为相应的实际参数的用户标签。

消息标识：ERROR_0338

## Error:意外语法：应该是标签、左括号或变量名，但是发现其它符号。

有三种形式的 GO TO 语句：
-- 无条件：GO TO 标签
-- 计算的：GO TO (label_list) [,] scalar_int_expr
-- 赋值：GO TO scalar_int_variable [ [,] (label_list) ]

关键字 TO 后面的标记应该是语句标签、左括号或变量名。

消息标识：ERROR_0339

## Error:在此作用单元中 ASSIGN 语句没有出现变量。

在当前作用单元中，被诊断变量没有被 ASSIGN 语句赋予语句标签值。当执行赋值 GO TO 语句时，必须用出现在同一作用单元中的分支目标语句的语句标签值，定义整型变量。该变量只能由同一作用单元中的 ASSIGN 语句，用语句标签值定义为赋值 GO TO 语句。

消息标识：ERROR_0340

## 注释：该 ASSIGN 语句是一个废弃特征。

废弃特征是 FORTRAN 77 特征，现在是多余的并且有更好的方法。ASSIGN 语句允许将标签动态赋值给整型变量，而且赋值 GO TO 语句允许通过此变量的“间接分支”。这就防碍了程序流的可读性，特别是算术运算也使用整型变量时。整型变量这两种完全不同的用途可能导致混淆性错误。

这些语句一般用于模拟现在可以直接编码的内部过程。

消息标识：COMMENT_0341

## 注释：该赋值 GO TO 语句是废弃特征。

废弃特征是 FORTRAN 77 特征，现在是多余的并且有更好的方法。ASSIGN 语句允许将标签动态赋值给整型变量，而且赋值 GO TO 语句允许通过此变量的“间接分支”。这就防碍了程序流的可读性，特别是算术运算也使用整型变量时。整型变量这两种完全不同的用途可能导致混淆性错误。

这些语句一般用于模拟现在可以直接编码的内部过程。

消息标识：COMMENT_0342

## Error:必须为子程序声明 RECURSIVE 关键字，这样才可递归调该用子程序。

函数或子程序正被递归调用，但是该程序单元的 FUNCTION 或 SUBROUTINE 语句中没有 RECURSIVE 关键字。

消息标识：ERROR_0343

## Ansi：此子程序没有结果名称，但正被递归调用。这是 Fortran 标准的一个扩展。

Fortran 标准规定，如果函数声明中不包含 RESULT 子句，则任何对该函数名称的引用是对函数结果变量的引用，而不是递归调用。已进行了扩展，如果函数结果不是值确定的数组或派生类型，则允许对函数名称的引用成为递归引用。在要递归调用函数时，使用 RESULT 子句更清楚更安全。

消息标识：ANSI_0344

## Error:没有对可执行语句或 FORMAT 语句定义标签。

在 ASSIGN 语句中，标签必须是可执行语句（必须是有效的分支目标语句）的语句标签，或者它必须是 FORMAT 语句的语句标签。可执行语句或格式语句也必须定义在与 ASSIGN 语句相同的作用单元中。

消息标识：ERROR_0345

## Error:此行语句不是有效的分支目标语句。

在 ASSIGN 语句中，如果标签是可执行语句的语句标签，则可执行语句必须是有效的分支目标语句。是可执行语句但不是有效分支目标语句的示例有：ELSE IF、ELSE、CASE、ELSEWHERE 和 END WHERE。

消息标识：ERROR_0346

## 警告：在起始于该行的 WHERE 构造中定义标签。

ASSIGN 语句中的标签定义于 WHERE 构造中的语句中。禁止将控制传输到 WHERE 构造的内部。

消息标识：WARNING_0347

## 警告：在起始于该行的 CASE 块中定义标签。

ASSIGN 语句中的标签定义于 CASE 块内的语句中。禁止将控制从 CASE 块外部（即使从相同 CASE 构造的另一 CASE 块）传输到 CASE 块中。

消息标识：WARNING_0348

## 警告：在此作用单元的 ASSIGN 语句中没有出现标签。

正被诊断的赋值 GO TO 语句使用了此消息引用的标签，但是在当前作用单元的任一 ASSIGN 语句中都不出现该标签。当执行赋值 GO TO 语句时，必须用出现在同一作用单元中的分支目标语句的语句标签值，定义整型变量。该变量只能由同一作用单元中的 ASSIGN 语句，用语句标签值定义为赋值 GO TO 语句。

消息标识：WARNING_0349

## Error:这是一个已定义类型的 CHARACTER*(*)，因此它必须是伪参数、常量或 Cray 指针对象。

声明为假定长度字符 (CHARACTER*(*)) 的数据对象必须是伪参数、常量或 Cray 指针对象。Cray 指针对象是非标准的。

消息标识：ERROR_0350

## Error:这是一个假定形数组，因此它必须是非指针的伪参数。

根据定义，假定形数组必须是非指针的伪参数。通过指定方式声明假定形数组

    DIMENSION NEW_ARRAY(10:)

这声明了一个名为 NEW_ARRAY、下界为 10 的一级数组。不得使用 POINTER 属性声明 NEW_ARRAY。

消息标识：ERROR_0351

## Error:由于有 OPTIONAL 和/或 INTENT 属性，因此它必须是伪参数。

被赋予 OPTIONAL 和/或 INTENT 属性的对象必须声明为伪参数。

消息标识：ERROR_0352

## Error:因为它是延迟形数组，所以必须具有 POINTER 或 ALLOCATABLE 属性，或者是伪参数。

延迟形数组必须是伪参数、指针或具有 ALLOCATABLE 属性。此项没有这些特性。

消息标识：ERROR_0353

## Error:等价对象为含具有 POINTER 属性的最终组件的派生类型。

派生类型的等价对象的一个组件为指针。具有指针组件的派生类型无法等价。

消息标识：ERROR_0354

## Error:在表达式中使用，或在名称列表组中指定，类型已假定为不同。

在表达式中使用或在名称列表组中指定对象时，如果该对象是首次引用，就隐式定义类型。只有对象与此类型相符时，接下来才能在类型声明语句中定义此对象的类型。

示例：

    DIMENSION ARRAY(K)
    REAL K          !非法

K 只能被定义为整型，因为它在 DIMENSION 语句中被隐式定义为整型。

    IMPLICIT INTEGER(A-Z)
    NAMELIST /GROUP/ R
    REAL R           !非法

R 只可定义为整数类型，因为在 NAMELIST 语句中它已隐式定义为整型。

消息标识：ERROR_0355

## Error:不允许将这种类型的表达式赋值给那种类型的变量。

在此赋值语句中，类型的组合无效。只有在同一声明中定义各种类型，或其声明不仅包含 SEQUENCE 语句并且各方面都相同，才允许派生类型赋值。“相同”意味着类型名称、组件数目、组件顺序、组件名称以及组件类型和属性一致。

消息标识：ERROR_0356

## Error:此派生类型构造函数中的组件数目与声明的数目不匹配。

此派生类型构造函数的组件数目不正确。

消息标识：ERROR_0357

## Error:此派生类型构造函数存在类型不匹配错误。

派生类型构造函数的每一组件的类型必须与派生类型定义的相应组件的类型相同。此构造函数组件的类型和派生类型的相应组件的类型不匹配。

消息标识：ERROR_0358

## Error:与指针组件相对应的这个结构构造函数项为非允许目标。

当派生类型含指针组件时，相应的结构构造函数表达式必须计算以下对象的值：在指针赋值语句中它是此指针的允许目标。在以下的例子中，两种结构构造函数都是允许的。

    TYPE X
    INTEGER, POINTER ::IPTR
    END TYPE

    TYPE(X) ::LEFT
    INTEGER, POINTER ::INT_PTR
    INTEGER, TARGET  ::INT_TARGET

    LEFT = X(INT_PTR)

    LEFT = X(INT_TARGET)

消息标识：ERROR_0359

## Error:派生类型构造函数组件的等级与声明的等级不匹配。

在类型和形式方面，派生类型构造函数的所有组件必须与相应的声明组件相匹配。

消息标识：ERROR_0360

## Error:DPROD 的两个实际参数都必须是缺省实数类型。

DPROD 的两个实际参数都必须是缺省实数类型。

消息标识：ERROR_0361

## 警告：不能执行该语句。

诊断语句前面是 GO TO 语句。当前语句没有标签；因此无法控制当前语句。例如：

    GO TO 20
    I = J !无法执行此语句。

消息标识：WARNING_0362

## Error:此内在调用的所有实际参数不一致。

同一基本内在过程的所有实际参数必须一致。

消息标识：ERROR_0363

## 限制：编译器生成的标签数目超出了编译器的限制。

在编译过程中，编译器必须生成内标签。编译器所用标签数超出了标明的限制。源文件必须分割为若干更小的、单独的文件。

消息标识：LIMIT_0364

## Error:该语句不能是逻辑 IF 语句的操作语句。

逻辑 IF 语句包含不允许作为逻辑 IF 语句的 action_stmt 部分的语句。

逻辑 IF 语句的语法为：

    IF (scalar_logical_expr) action_stmt

action_stmt 必须是非以下情况的可执行语句：
-- 另一逻辑 IF 语句
-- 任一形式的 END 语句
-- 为构造组成部分的语句（例如，IF 构造的 IF、ELSE IF 或 ELSE 语句）

消息标识：ERROR_0365

## 内部：分析逻辑 IF 的目标语句时，定义了未预料的语句类型。

逻辑 IF 语句处理程序遇到未预料的 stmt_type 值。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0366

## Error:对象是过程模块或内部函数，因此不能定义为假定长度字符类型。

内部和模块过程不能定义为假定长度字符类型。

消息标识：ERROR_0367

## Error:模块过程必须在此作用单元中定义，或者与另一作用单元关联。

MODULE PROCEDURE 语句列出的所有名称必须在那个作用单元中定义，或者可从另一作用单元访问。下例为一尚未定义的模块过程。

    MODULE Error

    INTERFACE Undefined
    MODULE PROCEDURE Not_Here
    END INTERFACE

    END MODULE Error

Not_Here 不对。它既不存在于模块 ERROR 中，也未使用关联启用。

消息标识：ERROR_0368

## Error:这个表达式必须是个整数标量表达式。

在此上下文中的表达式必须是整数标量表达式（例如，RETURN 语句后面的表达式必须是整数标量表达式）。

消息标识：ERROR_0369

## Error:函数子程序中不允许有交替返回说明符。

如果用户在函数子程序中编写 RETURN 语句，则关键字 RETURN 必须独立。函数子程序中不允许有交替返回说明符。

消息标识：ERROR_0370

## 注释：交替返回说明符已废弃。

废弃特征是 FORTRAN 77 特征，现在是多余的并且有更好的方法。

交替返回允许被调用过程控制返回时调用过程的执行情况。通过返回满足以下条件的整数值可以实现同样的效果：在返回调用过程时，用此值控制 CASE 构造或计算的 GO TO 语句。

消息标识：COMMENT_0371

## Error:COMMON 语句中的所有维数说明符都必须在常数范围内声明。

common_block_object_list 中对象的语法是

    variable_name [(explicit_shape_spec_list)]

explicit_shape_spec 中的每个边界必须是常量规范表达式。要在 common_block_object_list 中声明指针，使用 DIMENSION 语句将此数组声明为延迟形数组；然后在 COMMON 语句中指定它。

消息标识：ERROR_0372

## Error:对象在公共块中且为派生类型。此派生类型必须是序列类型。

如果 common_block_object 是派生类型，则它一定是序列类型。

消息标识：ERROR_0373

## Error:此数值常量超出范围。

发现一个数值常量超出范围。整型常量太大，或者实数常量的指数太大。

消息标识：ERROR_0374

## 警告：下标数小于声明的维数。

使用了格式为 a(s[,s]...) 的数组引用。引用中的下标数应等于为数组声明的维数。Fortran 标准的扩展允许下标比声明的维数小。数组引用中指定的下标用于最左边的维数，下界用于省略的最右边的下标。

消息标识：WARNING_0375

## Ansi：维数少于声明维数的数组引用是对 Fortran 标准的一个扩展。

编译器允许引用维数比声明维数小的数组。未指定的维数缺省为该维的下界。这是 Fortran 标准的一个扩展。

消息标识：ANSI_0376

## Error:意外语法：应该是关键字 THEN、操作语句的开始或一个标签。

对于欲为 IF 构造的 IF-THEN 语句者，IF 条件的结束括号后必须跟关键字 THEN。对于欲为 IF 语句者，action_stmt 必须始于 IF 条件的结束括号之后。对于欲为算术 IF 语句、间接逻辑 IF 或二叉算术 IF 语句者，必须在 IF 条件的结束括号后跟一个标签。

算术 IF 是一个废弃特征，间接逻辑 IF 和二叉算术 IF 是过时的扩展。

消息标识：ERROR_0377

## Error:此子程序引用是非法的。

编译器检测到一处本应为数据对象或函数调用的子程序引用。这可能是由于没有实际参数列表的函数名或不在 CALL 语句中的子程序名造成的。

消息标识：ERROR_0378

## Error:过程必须是 EXTERNAL、模块过程，或在接口块中声明为实际参数。

过程名被用作函数或子程序调用的实际参数，但是该过程名未赋予 EXTERNAL 属性、不是模块过程或未在接口块内指定。备注：为正在编译的 SUBROUTINE 的名称赋予 EXTERNAL 属性是对标准的扩展。

消息标识：ERROR_0379

## Error:未发现定义的通用运算的特定匹配。

已定义运算符或通用调用的操作数类型与接口块中的所有特定子程序接口不匹配。在类型、种类类型和等级方面，所有实际参数必须与相应的伪参数严格一致，以便产生匹配。所有无相应实际参数的伪参数必须声明为 OPTIONAL。

消息标识：ERROR_0380

## 注释：PAUSE 语句是废弃的。

PAUSE 语句是废弃的。废弃特征是 FORTRAN 77 特征，现在是多余的并且有更好的方法。在多数情况下，用等待输入数据的 READ 语句，可以采用可移植的方式实现PAUSE 语句的功能。

消息标识：COMMENT_0381

## Log_Error：无法打开编译器信息文件。

编译器无法打开名为 input_name.T 的“编译器信息文件”(CIF) 或写入用临时 CIF。检查工作目录的文件权限。

消息标识：LOG_ERROR_0382

## Error:不能写入到“编译器信息文件”。

编译器无法将记录写入到“编译器信息文件”(CIF)。编译将继续进行，但是会关闭 CIF 进程。将不创建对象文件。

消息标识：ERROR_0383

## 内部：关键字表中的关键字长度大于最大长度 127。

鉴于标记尺寸限制，关键字表中的所有项都必须少于 127 个字符。发出此消息时，请检查正在使用的表。

应避免产生此消息，它表示编译器错误或安装错误。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。

消息标识：INTERNAL_0384

## Ansi：STOP/PAUSE 语句后的字符变量/表达式或整型常数是非标准的。

Fortran 标准允许在 STOP 或 PAUSE 后跟标量字符文字常量或 5 位整型文字常量（前导零不算）。使用字符变量、字符表达式或多于 5 位的整型常量是 Fortran 标准的扩展。

消息标识：ANSI_0385

## Error:STOP/PAUSE 语句后的表达式必须是一个标量字符表达式或无符号整型常数。

Fortran 标准允许在 STOP 或 PAUSE 关键字后跟 5 位无符号标量整型常量（前导零不算）或标量字符常量。编译器允许在 STOP 或 PAUSE 关键字后跟任意长度的无符号标量整型常量或标量字符表达式。

消息标识：ERROR_0386

## Error:CONTAINS 语句后必须是一个 FUNCTION 或 SUBROUTINE 语句。

编译器检测到其后没有 SUBROUTINE 或 FUNCTION 语句的 CONTAINS 语句。CONTAINS 语句的语法如下：

在模块中：

    contains_stmt
    module_subprogram
    [module_subprogram]...

在外部过程中

    contains_stmt
    internal_subprogram
    [internal_subprogram]...

消息标识：ERROR_0387

## Log_Warning：汇编语言列表 (-rg) 禁用汇编语言输出（-eS 或 -S 文件名）。已选择此列表。

编译器不能同时具有汇编语言列表和汇编语言输出文件。汇编语言输出文件被禁用。

示例：

    -eS -rg file.f（将发出警告信息）

消息标识：LOG_WARNING_0388

## Error:对于通用子程序调用没有发现特定匹配。

调用通用接口名称的函数或子例程调用与通用接口块中的所有特定子程序接口不匹配。在类型、种类类型和等级方面，没有 OPTIONAL 属性的所有伪参数都必须与所有相应的实际参数严格一致。

消息标识：ERROR_0389

## Error:派生类型是在主机范围内定义并在局部范围内使用的，因此不能重定义。

编译器检测到以下内容：

    TYPE ::NEW_TYPE
    INTEGER ::A
    END TYPE NEW_TYPE
         ...

    CONTAINS
    SUBROUTINE EXAMPLE
    TYPE(NEW_TYPE) ::VAR

    TYPE ::NEW_TYPE  !This redefinition is illegal.
    INTEGER ::B
    END TYPE NEW_TYPE
           ...
    END SUBROUTINE
    END

消息标识：ERROR_0390

## 警告：类型将被重映射。

因为编译器目前不支持此指定数据类型，它已被映射为新的数据类型。

消息标识：WARNING_0391

## Error:此运算符不允许数据类型。

一元运算符的操作数之数据类型是无效的。

消息标识：ERROR_0392

## Error:具有括号的数组引用至少要有一个下标。

编译器发现不带下标的数组引用，但它不是整个数组的引用。下面的例子说明了此问题：

    DIMENSION I(10)
    J = I()

如果 J 是标量引用，则必须在对 I 的引用中指定下标才能确保正确，例如 I(3)。

消息标识：ERROR_0393

## Error:此霍尔瑞斯常量大于一个字。

用作数值常量的霍尔瑞斯常量不能大于一个字。

消息标识：ERROR_0394

## Ansi：屏蔽表达式是对 Fortran 标准的一个扩展。

逻辑运算符与以下操作数一起使用：整数类型、实数、布尔和/或 Cray 指针。这称为屏蔽表达式，它是 Fortran 标准的一个扩展。

消息标识：ANSI_0395

## Error:此通用接口具有子例程和函数专用接口。

通用接口只能拥有所有函数专用接口或所有子例程专用接口。此通用接口具有子例程和函数专用接口。

消息标识：ERROR_0396

## Error:不能将通用接口作为子例程调用。

在 CALL 语句中使用了通用接口名，但是此接口只包含函数专用接口。

消息标识：ERROR_0397

## Error:通用接口不能用作函数。

通用接口名被用作函数名，但是此接口只包含子例程专用接口。

消息标识：ERROR_0398

## 注释：通用接口调用已转变。

此注释说明通用接口引用或重载的运算符的转变情况。

消息标识：COMMENT_0399

## Error:在标签域中发现的字符无效。

在固定源格式下，行的标签域（第一列到第五列）只能有空格或数字。在此行的标签域中已发现不合法的字符。

消息标识：ERROR_0400

## Error:ALLOCATE 语句的数组形式规范中的跨度规范是非法的。

数组形式规范具有指定的跨度。仅可指定下界（可选）和上界。allocate_shape_spec 的语法为 [lower_bound:]upper_bound。

消息标识：ERROR_0401

## Error:为此分配对象指定的范围数与声明的等级不匹配。

如果 allocate_object 是可分配的数组或指针数组，则在 ALLOCATE 语句中指定的形式必须具有指定的所有维的范围。

消息标识：ERROR_0402

## Error:分配对象中一维的上或下边界必须是标量整数表达式。

在 ALLOCATE 语句中，allocate_object 用非标量整数表达式的边界指定其形状。

消息标识：ERROR_0403

## Error:只有标量对象可分配到 ALLOCATE 语句中。

在 ALLOCATE 语句的 allocation_list 中遇到非标量对象。这是因为在派生类型引用中的 part_ref 是整个数组引用或数组段。

消息标识：ERROR_0404

## Error:分配/释放对象不能是子串引用。

使用子串限定符引用了 ALLOCATE 或 DEALLOCATE 语句中的 allocate_object。

消息标识：ERROR_0405

## Ansi：非直接逻辑 IF 和两分支算法 IF 语句是非标准和过时的。

非直接逻辑 IF 语句和两分支算法 IF 语句都是废弃特征。这些过时特征已经被能够增强 Fortran 程序可移植性的其它语句所代替。IF 构造或逻辑 IF 应被用来替换这些过时的格式。不要使用这些过时的格式，尤其是在新代码中。

消息标识：ANSI_0406

## Error:标签必须在固定源格式的第 1 至 5 列。

这是固定源格式，因此标签必须在第 1 至 5列。此种错误示例如下：

    i = 1; 100 read *,i

100 不对。它应指定为：

    i=1
    100   read *, i

消息标识：ERROR_0407

## Error:此指针在一个非 0 等级部分引用的右面。

非零级的 part_ref 不允许右边具有 POINTER 属性的另一个 part_ref。

消息标识：ERROR_0408

## Error:条件表达式的类型必须是整数、实数或双精度实数。

算术 IF 的条件表达式的类型必须是整数、实数或双精度实数。

消息标识：ERROR_0409

## Error:条件表达式必须是标量。

算术 IF 的条件表达式的类型必须具有标量结果并且必须是类型整数、实数或双精度实数。

消息标识：ERROR_0410

## Error:赋值语句中的变量不能是假定大小数组。

赋值语句的左边不能是假定大小数组的整个数组引用。

消息标识：ERROR_0411

## Error:假定大小数组的整个数组引用是不允许的。

除非假定大小数组是实参数，否则它不能作为整个数组引用出现。

消息标识：ERROR_0412

## Error:STAT 变量不能分配到它在其中出现的 ALLOCATE 语句中。

此 ALLOCATE 语句的STAT= 变量也是在同一 ALLOCATE 语句中的 allocate_object。

消息标识：ERROR_0413

## Error:条件表达式的类型必须是逻辑类型、整数、实数或双精度实数。

如果两分支 IF 要成为非直接逻辑 IF，那么条件表达式必须是逻辑类型。如果两分支 IF 要成为两分支算术 IF，那么条件表达式的类型必须是整数、实数或双精度实数。

两分支 IF 语句的两种格式都是过时特征。它们应当不再使用。

消息标识：ERROR_0414

## Error:自由源格式中的这个词法表示前需要一个空白。

Fortran 标准需要一个空格来分隔名称、常量、标签与邻近的关键词、名称、常量、标签。

消息标识：ERROR_0415

## 条件表达式必须是逻辑类型。

IF-THEN 语句的语法是：

    [if_construct_name:]IF (scalar_logical_expr) THEN

ELSE IF 语句的语法是：

    ELSE IF (scalar_logical_expr) THEN [if_construct_name]

IF 语句的语法是：

    IF (scalar_logical_expr) action_stmt

在所有这三种情况中，条件表达式必须是逻辑类型并且必须是标量。

消息标识：ERROR_0416

## Error:指针赋值语句中的指针对象必须具有 POINTER 属性。

指针赋值语句的左边必须具有 POINTER 属性。

消息标识：ERROR_0417

## Error:指针赋值语句中的变量必须具有 TARGET 属性或 POINTER 属性。

指针赋值语句右边的变量必须是目标、目标子对象或指针。

消息标识：ERROR_0418

## Error:指针赋值语句中的目标必须具有与指针相同的类型参数。

要想生效，指针赋值语句左右两边的类型、种类类型和等级都必须一致。这也适用与指针组件相对应的结构构造函数的表达式。

消息标识：ERROR_0419

## Error:指针赋值语句中的目标不能是具有向量下标的数组段。

指针赋值语句的右边不能是具有向量定值下标的数组段。这也适用于相应组件是指针的结构构造函数内的表达式。

消息标识：ERROR_0420

## Error:指针赋值语句中使用的表达式必须传送指针结果。

只有指针定值函数可以在指针赋值语句的右边。

消息标识：ERROR_0421

## Error:字符在二进制常量中无效。

在二进制常量 (boz_literal_constant) 中，仅允许 0 和 1 两数字。编译器检测到超出此范围的字符。

消息标识：ERROR_0422

## Error:字符在十六进制常量中无效。

在十六进制常量（BOZ 或布尔常量）中，仅允许 0-9 和 A-F（a-f 也是合法的）的数字。编译器检测到 0-9 或 A-F 以外的字符。

消息标识：ERROR_0423

## Error:属性多次出现在该属性列表中。

在类型声明语句中，多次指定同一属性是非法的。编译器检测到如同此例的错误：

    REAL, ALLOCATABLE, DIMENSION(::), &
    ALLOCATABLE ::A

ALLOCATABLE 不对。它被指定了两次。

消息标识：ERROR_0424

## Error:属性不能出现在同一列表中。

指定的属性是互斥的。一个对象不能同时具有这两个属性。以下是跟随冲突属性的属性列表。

ALLOCATABLE
  EXTERNAL,
  INTENT,
  INTRINSIC,
  OPTIONAL,
  PARAMETER,
  POINTER
DIMENSION
EXTERNAL
  ALLOCATABLE,
  INTENT,
  INTRINSIC,
  PARAMETER,
  POINTER,
  SAVE,
  TARGET
INTENT
  ALLOCATABLE,
  EXTERNAL,
  INTRINSIC,
  PARAMETER,
  POINTER,
  SAVE
INTRINSIC
  ALLOCATABLE,
  EXTERNAL,
  INTENT,
  PARAMETER,
  POINTER,
  PRIVATE,
  PUBLIC,
  SAVE,
  TARGET
OPTIONAL
  ALLOCATABLE,
  PARAMETER,
  SAVE
PARAMETER
  ALLOCATABLE,
  EXTERNAL,
  INTENT,
  INTRINSIC,
  OPTIONAL,
  POINTER,
  TARGET
POINTER
  ALLOCATABLE,
  EXTERNAL,
  INTENT,
  INTRINSIC,
  PARAMETER,
  TARGET
PRIVATE
  INTRINSIC,
  PUBLIC
PUBLIC
  INTRINSIC,
  PRIVATE
SAVE
  EXTERNAL,
  INTENT,
  INTRINSIC,
  OPTIONAL
TARGET
  EXTERNAL,
  INTRINSIC,
  PARAMETER,
  POINTER

消息标识：ERROR_0425

## Error:NULLIFY 语句中的每个指针对象都必须有 POINTER 属性。

NULLIFY 语句中的每个对象都必须是变量名或具有 POINTER 属性的结构组件。

消息标识：ERROR_0426

## Error:STAT= 变量不能在同一 DEALLOCATE 语句中被解除分配。

正在此 DEALLOCATE 语句中解除其中的 STAT= 变量。

消息标识：ERROR_0427

## Error:分配对象必须或者是指针或者是 DEALLOCATE 语句中的可分配数组。

ALLOCATE 语句中的所有参数必须事先声明为指针或可分配数组。

消息标识：ERROR_0428

## Error:只有标量对象可在 DEALLOCATE 语句中解除分配。

DEALLOCATE 语句的 deallocate_object_list 包含非标量对象。这是因为在派生类型引用中的 part_ref 是整个数组引用或数组段。

消息标识：ERROR_0429

## Error:DEALLOCATE 语句中解除分配对象不能是数组元素或数组段。

deallocate_object_list 中的对象必须是指针或可分配数组的名称。它可以是结构组件，但不能是数组元素引用或数组段。

消息标识：ERROR_0430

## Error:指针赋值语句中的目标必须有与指针相同的等级。

要想有效，指针赋值语句左右两边的类型、种类类型和等级都必须一致。这也适用与指针组件相对应的结构构造函数的表达式。

消息标识：ERROR_0431

## Error:不允许将%s目标或指针赋值给%s指针。

要想有效，指针赋值语句左右两边的类型、种类类型和等级都必须一致。这也适用与指针组件相对应的结构构造函数的表达式。

消息标识：ERROR_0432

## 内部：不创建开始和结束 I/O 语句试图分割 I/O 语句。

编译器检测到当标志 io_stmt_must_be_split在将 I/O 语句分为多个语句的例程内时就为假。这暗示一个内部错误条件。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0433

## Error:标量实参数与假定形伪参数“%s”非法关联。

假定形数组伪参数不能具有与其相关联的标量实际参数。

消息标识：ERROR_0434

## Error:标量实际参数与数组伪参数非法关联。

除非标量实参数是数组元素引用，否则它不能被传递给数组伪参数。

消息标识：ERROR_0435

## Error:值确定的数组实参数与标量伪参数非法关联。

标量伪参数需要标量实参数。

消息标识：ERROR_0436

## Error:这具有 OPTIONAL 属性，因此其不能在边界规范表达式中使用。

此对象不能在边界规范表达式中使用，因为其具有 OPTIONAL 属性。

消息标识：ERROR_0437

## Error:名称列表组具有 PUBLIC 属性，因此名称列表组对象不能具有 PRIVATE 属性。

如果名称列表组具有 PUBLIC 属性，那么在名称列表组对象列表中的任何项目都不能具有 PRIVATE 属性。同样，派生类型的任何组对象列表项都不能拥有具有 PRIVATE 属性的组件。

消息标识：ERROR_0438

## Error:此语句的 I/O 控制列表必须有 UNIT 说明符。

对于此 I/O 语句，UNIT 说明符（用于外部或内部文件）必须出现。

消息标识：ERROR_0439

## Error:INQUIRE 语句的 I/O 控制列表必须具有 UNIT 或 FILE 说明符。

INQUIRE 语句必须具有 UNIT 或 FILE 说明符。但它不能同时具有这两个说明符。

消息标识：ERROR_0440

## Error:此类型的表达式作为此说明符的参数不是有效的。

I/O 控制列表说明符无效。

消息标识：ERROR_0441

## Error:INQUIRE 语句不能有 UNIT 和 FILE 两个说明符。

INQUIRE 语句必须具有 UNIT 或 FILE 说明符。但它不能同时具有这两个说明符。

消息标识：ERROR_0442

## Error:不能在同一 I/O 控制列表中指定 FMT 和 NML 说明符。

遇到的 I/O 控制列表含有具有 FMT 和 NML 说明符的 WRITE 或 READ 语句。该语句可以是格式化语句，也可以是名称列表 I/O 语句；但它不能同时是这两个语句。

消息标识：ERROR_0443

## Error:如果出现 I/O 列表，则不能出现名称列表组名称。

名称列表 I/O 不能具有输入或输出列表。

消息标识：ERROR_0444

## Error:此说明符不可用在 WRITE 语句控制列表中。

不能在 WRITE 语句中使用 END=、EOR= 和 SIZE= 说明符。

消息标识：ERROR_0445

## Error:NML= 控制列表说明符需要名称列表组名称作为参数。

NML= 说明符在具有不是名称列表组名参数的 READ、WRITE 或 PRINT 语句中。

消息标识：ERROR_0446

## Error:FMT= 控制列表项必须是标签、字符表达式或 ASSIGN 整数变量。

格式 I/O 控制列表说明符必须是标签或整型变量。I/O 控制列表说明符必须事先在 ASSIGN 语句中定义，或者必须是字符变量或字符表达式。

消息标识：ERROR_0447

## Error:此 I/O 控制列表项必须是标签或 ASSIGN 变量。

指定分支目标的 I/O 说明符（如 EOR=、ERR= 或 END=）必须有作为参数的标签或已在 ASSIGN 语句中定义的整型变量。

消息标识：ERROR_0448

## Error:此等级的表达式对于此控制列表说明符不是有效的。

I/O 控制列表中项目的等级高于零。

消息标识：ERROR_0449

## 内部：使用不需要类型描述符的事件调用过程 get_type_desc。

在 PDGCS 接口的过程中，调用 get_type_desc 为不需要类型的事件查找类型描述符。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0450

## Error:没使用实际参数列表引用函数是非法的。

对程序的这个调用无括号跟随。如果实参数列表为空，函数名被调用时必须有括号跟随。

消息标识：ERROR_0451

## Error:对子例程的这个引用不在 CALL 语句中。

子例程的引用在表达式中。子例程子程序仅能使用 CALL 语句调用。

消息标识：ERROR_0452

## Error:对主程序的这个引用是非法的。

主程序名称的引用在表达式中。主程序名称不能引用。

消息标识：ERROR_0453

## Error:对数据块的这个引用是非法的。

块数据名称的引用在表达式中。块数据子程序名称不能引用。

消息标识：ERROR_0454

## Error:对模块的这个引用是非法的。.

模块的引用在表达式中。模块名称不能在表达式中指定。

消息标识：ERROR_0455

## Error:主程序在 CALL 语句中是非法引用。

主程序名称不能在 CALL 语句中指定。

消息标识：ERROR_0456

## Error:块数据在 CALL 语句中是非法引用。

块数据子程序名称不能在 CALL 语句中指定。

消息标识：ERROR_0457

## Error:模块在 CALL 语句中是非法引用。

模块名称不能在 CALL 语句中指定。

消息标识：ERROR_0458

## Error:此类型的变量作为此说明符的参数不是有效的。

用作 I/O 控制列表说明符的变量类型无效。

消息标识：ERROR_0459

## Error:此控制列表说明符必须具有作为此语句参数的所需类型标量变量。

一些 I/O 控制列表说明符需要作为参数的变量名。该变量名必须是所需类型并且必须具有缺省的种类类型。

消息标识：ERROR_0460

## Error:此 I/O 控制列表说明符需要具有缺省种类参数的参数。

控制列表项没有缺省的种类类型。

消息标识：ERROR_0461

## Error:如果 FMT= 说明符是整数变量，则它必须是缺省类型。

用作 READ、WRITE 或 PRINT 语句中格式说明符的整型变量必须是缺省整数类型。

消息标识：ERROR_0462

## Error:如果出现 REC=，则 END= 说明符不能出现在此语句中。

READ 或 WRITE 语句中的 END= 说明符也具有 REC= 说明符。

消息标识：ERROR_0463

## Error:如果出现 REC=，则在此语句中格式不能列表控制。

星号 (*) 是也具有 REC= 说明符的 READ 或 WRITE 语句中的格式说明符。

消息标识：ERROR_0464

## 如果出现 EOR= 说明符，则 ADVANCE= 还必须出现在%s语句中。

EOR= 说明符出现在没有 ADVANCE= 说明符的 READ 或 WRITE 语句中。

消息标识：ERROR_0465

## Error:如果出现 REC=，则名称列表组名称不能出现在此语句中。

名称列表组名出现在具有 REC= 说明符的 READ 或 WRITE 语句中。

消息标识：ERROR_0466

## Error:内部文件使用的变量不能是具有向量下标的数组段。

用作 READ 或 WRITE 语句中 UNIT 说明符的字符变量具有向量下标。

消息标识：ERROR_0467

## Error:如果出现 ADVANCE= 说明符，则必须出现 FMT= 说明符。

ADVANCE= 说明符仅能在格式化的顺序 I/O 语句中出现，并且该语句具有显式格式说明而没有内部文件单元说明符。

消息标识：ERROR_0468

## Error:如果出现 ADVANCE= 说明符，则 FMT= 说明符不列表控制。

ADVANCE= 说明符仅能在格式化的顺序 I/O 语句中出现，并且该语句具有显式格式说明而没有内部文件单元说明符。

消息标识：ERROR_0469

## Error:如果出现 ADVANCE= 说明符，则 UNIT= 说明符不能指定内部文件。

ADVANCE= 说明符仅能在格式化的顺序 I/O 语句中出现，并且该语句具有显式格式说明而没有内部文件单元说明符。

消息标识：ERROR_0470

## Error:如果 UNIT= 说明符引用一个内部文件，则不能出现 REC= 说明符。

如果单元说明符指定一个内部文件，那么 io_control_spec_list 不能包含 REC= 说明符或名称列表组名。

消息标识：ERROR_0471

## Error:如果 UNIT= 说明符引用一个内部文件，则不能出现名称列表组名称。

如果单元说明符指定一个内部文件，那么 io_control_spec_list 不能包含 REC= 说明符或名称列表组名。

消息标识：ERROR_0472

## Error:如果出现 ADVANCE= 说明符，该语句必须是顺序存取的 I/O 语句。

ADVANCE= 说明符仅能在格式化的顺序 I/O 语句中出现，并且该语句具有显式格式说明而没有内部文件单元说明符。REC= 说明符使此语句成为直接存取 I/O 语句。

消息标识：ERROR_0473

## Error:隐含 DO 循环的 DO 变量必须是整数，缺省为实数，或双精度实数。

DO 变量必须是整数、实数、或双精度实数。

消息标识：ERROR_0474

## Error:如果特定接口在已定义的赋值接口块内部，则特定接口必须是子例程。

特定接口在已定义的赋值接口块内部，但不是子例程。在已定义赋值接口块中的所有特定接口都必须是子例程。

消息标识：ERROR_0475

## Error:隐含的 DO 控制表达式必须是标量。

控制 I/O 语句 I/O 列表中隐含 DO 循环的数值表达式必须是标量。这些表达式是隐含 DO 变量的开始值、结束值和可选增量值。

消息标识：ERROR_0476

## Error:隐含的 DO 控制表达式必须是整数、缺省实数、或双精度实数表达式。

每个隐含的 DO 控制表达式必须是整数、缺省实数或双精度实数类型的标量数值表达式。

消息标识：ERROR_0477

## Error:在此语句中不可将表达式用作输入项。

I/O 输入项是表达式。输入项必须是变量。

消息标识：ERROR_0478

## Error:在此语句中不可将常量用作输入项。

I/O 输入项是常量。输入项必须是变量。

消息标识：ERROR_0479

## 警告：此类型将被映射到 DOUBLE PRECISION。

DOUBLE PRECISION*16 类型已被映射到 DOUBLE PRECISION，因为编译器当前不支持 DOUBLE PRECISION*16。编译器将完全支持以后版本中的 DOUBLE PRECISION*16。

消息标识：WARNING_0480

## Error:此隐含的 DO 控制变量无效。

表达式或常量出现在应该是隐含 DO 变量的位置。

消息标识：ERROR_0481

## Error:此隐含的 DO 变量不是标量。

隐含 DO 变量的等级高于零。

消息标识：ERROR_0482

## Error:INQUIRE 语句中的 IOLENGTH= 说明符必须是标量缺省整型变量。

在 INQUIRE 语句中，IOLENGTH= 说明符要求指定缺省种类类型的标量整型变量。

消息标识：ERROR_0483

## Error:这拥有具有 POINTER 属性的最终组件，因此它不能在名称列表组中。

名称列表组对象不能拥有具有指针组件或最终指针组件的派生类型。具有指针组件的派生类型的项目不允许出现在名称列表组中。

消息标识：ERROR_0484

## Ansi：用作 UNIT= 标识符的字符常量文件名称是 Fortran 标准的一个扩展。

在应该是单元数的位置，指定字符常量。常量被解释为文件名并且是 Fortran 标准的一个扩展。

消息标识：ANSI_0485

## Error:这已通过此模块用作关联，并且至少与一个以上模块关联。不要引用它。

如果一个实体通过一个以上模块用作关联，那么不要引用它。例如：

    MODULE one
    INTEGER two_uses
    END MODULE

    MODULE two
    INTEGER two_uses
    END MODULE

    PROGRAM show
    USE one
    USE two       !It is legal to use
    ! associate TWO_USES twice.

    J = two_uses  !This is illegal, because
    ! the compiler cannot determine
    ! which TWO_USES is correct.

消息标识：ERROR_0486

## Error:特定接口使通用或定义接口产生歧义。

通用或定义接口中的两个特定接口产生歧义。在一个作用单元内，同一通用或定义接口中的两个过程通过其无选择的伪参数加以区分。一种区分特定接口的方法是按其伪参数的个数。如果特定接口具有相同的伪参数个数，则伪参数必须在类型、种类类型或者等级上有所不同。

消息标识：ERROR_0487

## Error:所有边界和种类选择符表达式必须是整数类型，但这一个不是。

在边界表达式或种类选择符表达式中，编译器检测到非整数表达式。边界表达式用于声明数组维数大小和字符长度并且必须总是整数类型。种类选择符表达式必须总是整型常量并且用于声明类型的种类。

消息标识：ERROR_0488

## Error:当特定接口在已定义的赋值接口块内部时，其必须恰好有两个伪参数。

在已定义赋值接口块内部必须只有特定接口，该接口是恰好有两个所需伪参数的子例程。

消息标识：ERROR_0489

## 伪参数“%s”在已定义的运算符或赋值接口块中不能有 OPTIONAL 属性。

一个伪参数有 OPTIONAL 属性，但声明该伪参数的特定接口是定义运算符接口块或是定义赋值接口块。

消息标识：ERROR_0490

## Error:在已定义的运算符或已定义的赋值接口块内，伪参数的 INTENT 必须被正确指定。

在定义的运算符或赋值接口块内，伪参数的 intent 必须用特定的值来指定。对于定义的赋值，第一个伪参数必须具有 INTENT(OUT) 或 INTENT(INOUT)。第二个伪参数必须有 INTENT(IN)。对于已定义的运算符，伪参数必须具有 INTENT(IN)。

消息标识：ERROR_0491

## Error:特定接口必须是已定义的运算符接口块中的函数。

在已定义运算符接口块内的所有特定接口必须是具有一个或两个伪参数的函数。

消息标识：ERROR_0492

## Error:函数结果不能是假定长度字符，因为它在已定义的运算符接口块中。

在已定义运算符接口块内的函数特定接口不能有假定长度的字符结果。

消息标识：ERROR_0493

## Error:当特定接口在已定义的一元运算符接口块内部时，其必须恰好有一个伪参数。

在已定义运算符接口块内的所有特定接口都被解释为一元运算，因此仅能具有一个参数。

消息标识：ERROR_0494

## Error:该特定接口与运算符的内在使用发生冲突。

在已定义运算符中或赋值接口块中的特定接口拥有具有类型、种类类型和等级的伪参数，该伪参数作为对运算符的内在使用是有效的。此冲突产生歧义，并且是不被允许的。

消息标识：ERROR_0495

## Error:当特定接口在已定义的二元运算符接口块内部时，其必须恰好有两个伪参数。

在已定义的运算符接口块中，特定接口的伪参数数量必须与运算符的内在使用相匹配。严格的二元运算符（如星号）需要两个伪参数。

消息标识：ERROR_0496

## Error:当特定接口在已定义的运算符接口块内部时，其必须有一个或两个伪参数。

在已定义的运算符接口块中，特定接口的伪参数数量必须与运算符的内在使用相匹配。如同 + 或 – 的运算符可用作一元或二元运算符，因此特定接口可具有一个或两个伪参数。

消息标识：ERROR_0497

## Error:伪参数是伪过程。已定义的赋值或已定义运算符接口内不允许这种用法。

在定义赋值接口块或定义运算符接口块内的特定接口必须具有是数据对象的伪参数。不允许出现伪过程。

消息标识：ERROR_0498

## Error:已定义的运算符不能与逻辑文字常量相同。

在应该是运算符的位置指定逻辑文字常量、.TRUE. 或 .FALSE.。

消息标识：ERROR_0499

## Error:数组是假定的大小，因此它必须是伪参数。

用假定大小说明符声明的数组必须是伪参数。如果它是类型字符，那么它也可以是 Cray 字符指针对象。Cray 指针是 Fortran 标准的一个扩展。

消息标识：ERROR_0500

## Error:这是字符类型的假定大小数组。它必须是伪参数或 Cray 字符指针对象。

使用假定长度说明符声明的的字符数组必须是伪参数或 Cray 字符指针的对象。Cray 指针是 Fortran 标准的一个扩展。

消息标识：ERROR_0501

## Error:此实参数不是程序单元。伪参数是伪过程。

正在调用的子程序具有显式接口。此显式接口允许实参数与伪参数进行比较。此检查已经暴露出实参数和伪参数之间的不匹配。伪参数是伪过程，而实参数不是程序单元。

消息标识：ERROR_0502

## Error:参数不匹配：实参数与伪参数不匹配。

正在调用的子程序具有显式接口。此显式接口允许实参数与伪参数进行比较。此检查已经暴露出实参数和伪参数之间的不匹配。

消息标识：ERROR_0503

## Error:实参数是标签但伪参数不是交替返回说明符。

标签仅能被传递给那些为“*”交替返回说明符的伪参数。

消息标识：ERROR_0504

## Error:自由源格式中字符上下文的续行需要用“&”作为下一行的第一个非空白字符。

自由源格式中的字符上下文的续行必须有一个 & 作为下一行的第一个非空字符。

消息标识：ERROR_0505

## Error:函数是递归函数，其类型不能设定为假定长度字符

Fortran 标准禁止将递归函数的类型设定为假定长度字符。

如果函数是内部函数或模块函数、值确定的数组、值确定的指针或者递归函数，那么函数名不能用星号字符长度进行声明。

消息标识：ERROR_0506

## Error:函数是值确定的数组和/或值确定的指针，因此其类型不能设定为假定长度字符。

Fortran 标准禁止将结果是数组或指针的函数设定为假定长度字符类型。

如果函数是内部函数或模块函数、值确定的数组、值确定的指针或者递归函数，那么函数名不能用星号字符长度进行声明。

消息标识：ERROR_0507

## Error:子串引用的父字符串必须是字符类型。

仅能从字符变量或字符常量中格式化子串。

消息标识：ERROR_0508

## Error:这不能用于边界规范表达式。

在声明和此对象的使用之间，编译器已检测到冲突。该对象不能用于边界规范表达式，因为它已被声明为以下形式之一：

    Cray 指针
    Cray 指针对象
    函数结果
    模块过程
    内部过程
    派生类型
    通用接口
    名称列表组
    语句函数
    构造
    module
    块数据
    程序
    subroutine

消息标识：ERROR_0509

## Ansi：将此形式用作逻辑文字常量是 Fortran 标准的一个扩展。

这些是 Fortran 标准的扩展。

    .F.    （代表 .FALSE.）
    .T.    （代表 .TRUE.）

如果这些扩展形式中的任意一个被声明为已定义的运算符，那么该扩展不被允许。

消息标识：ANSI_0510

## Error:这是标量，但是其正被用作数组或函数引用。

名称之后跟随加括号的列表，但它不是数组名或函数名。

消息标识：ERROR_0511

## Error:这是名称列表组的名称。这是非法使用。

名称列表组名仅能用作控制列表项，供 READ、WRITE 或 PRINT 语句指定名称列表 I/O。

消息标识：ERROR_0512

## Error:意外语法：应该是逗号、标识符、WHILE 或 EOS，却找到其它内容。

DO 语句的语法是：

    [do_construct_name:]DO [label] [loop_control]

loop_control 的格式是：

    [,] do_variable = scalar_numeric_expr,
    	scalar_numeric_expr [, scalar_numeric_expr]

    或

    [,] WHILE (scalar_logical_expr)

编译器发现跟随着标签的关键字 DO。标签之后应该跟随着逗号、标识符、关键字 WHILE 或语句的结束，却找到了其它内容。

消息标识：ERROR_0513

## 内部：malloc_check 发现 malloc'd 表有问题。参见前一条消息。

在调试模式中，malloc_check 在每个 malloc、realloc 和自由分配之前被调用。这时 malloc_check 发现了问题。malloc_check 将打印一条说明此问题的消息。该消息将在此内部消息之前输出。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0514

## Error:意外语法：应该是标签、逗号、标识符、WHILE 或 EOS，却找到其它内容。

DO 语句的语法是：

    [do_construct_name:]DO [label] [loop_control]

loop_control 的格式是：

    [,] do_variable = scalar_numeric_expr,
    scalar_numeric_expr [, scalar_numeric_expr]

    或

    [,] WHILE (scalar_logical_expr)

编译器发现关键字 DO 并且要求其后跟随着语句标签、逗号、标识符、关键字 WHILE 或语句的结束。

消息标识：ERROR_0515

## 内部：对于“%s”，LN_NAME_IDX (%d) 与 AT_NAME_IDX(%d) 不匹配。

符号表条目需要共享同一名称的同一名称池条目。局部名称表不使用同一名称池作为属性表。这会在模块和接口压缩中造成错误的索引问题。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0516

## Error:该 DO 变量已经作为外部循环的 DO 变量被使用。

活动的 DO 变量仅能使用其 DO 语句改变其值。其值不能被循环中的任何语句改变。这意味着如果变量正在用作 DO 变量，那么就不能用作内部循环的 DO 变量。

消息标识：ERROR_0517

## Error:这被用作子例程，因此其不能在范围规范表达式中使用。

编译器检测到此对象使用之间的冲突。该对象被用作子例程，从而禁止在表达式中使用。

消息标识：ERROR_0518

## Error:伪参数具有 INTENT(OUT) 属性，因此其不能在边界规范表达式中使用。

具有 INTENT(OUT) 的伪参数不能在边界规范表达式中使用。

消息标识：ERROR_0519

## Error:在边界规范表达式中使用外部函数“%s”是不标准的。

在数组维数边界声明符或字符长度声明符中引用外部函数是 Fortran 标准的一个扩展。

消息标识：ERROR_0520

## Error:局部变量必须是伪参数或者在公共区中，才能用于边界规范表达式。

规范表达式的每个初等量必须是常数、伪参数、公共块成员、使用关联或主机关联。编译器检测到上述之外的变量。

消息标识：ERROR_0521

## Ansi：允许字符和非字符彼此等价是 Fortran 标准的一个扩展。

如果等价列表中有一个对象是字符或字符序列类型，则该列表中的所有对象都一定是字符或字符序列类型。编译器放松了此约束。字符与非字符可以彼此等价。但是，如果由于此类等价，某个非字符项未在字边界上对齐，就会发生致命错误。

消息标识：ANSI_0522

## Error:等价对象“%s”的类型与其它等价对象的类型不同。

如果 equivalence_object 所属的派生类型不是数值序列或字符序列类型，则此等价组中的所有对象都必须属于这些类型。或者，如果 equivalence_object 所属的内类型不是缺省整数、缺省实数、双精度实数、缺省复数、缺省逻辑或字符，则此等价集中的所有对象都必须是具有相同种类类型参数值的相同类型。

消息标识：ERROR_0523

## Error:在固定源格式中不允许多于 99 个续行。

固定源格式和自由源格式的编译器的续行限制都是 99。

消息标识：ERROR_0524

## Error:在自由源格式中不允许多于 99 个续行。

固定源格式和自由源格式的编译器的续行限制都是 99。

消息标识：ERROR_0525

## Error:通过等价公共块已被扩展超过起始点。

通过非公共块变量与公共块的等价，此公共块已被扩展超过其起始地址。不允许在此方向上扩展公共块。

消息标识：ERROR_0526

## Error:由于字符项目对齐，对象不在字边界上开始。

非字符对象被等价到字符对象，导致此非字符对象未在字边界上对齐。

消息标识：ERROR_0527

## Error:对象在两个不同位置进行等价操作。

某个变量被等价，导致该变量内的两个不同位置重叠。例如：

    EQUIVALENCE (A(1), A(3))  !This is illegal

消息标识：ERROR_0528

## Error:对象先前已在可执行语句中使用，因此不能是伪参数。

ENTRY 语句中的伪参数必须在声明后才能在可执行语句中引用。但可在边界规范表达式中使用。

消息标识：ERROR_0529

## Error:隐含的 DO 变量不能是变量子对象。

隐含 DO 变量必须是整数类型、缺省实数或双精度实数类型的命名标量。不能由组件引用或下标列表限定该名称。

消息标识：ERROR_0530

## Error:编译器指令必须出现在第一个可执行语句之前。

必须在程序单元的声明部分指定下列编译器指令。

    AUXILIARY
    NAME
    NOSIDE EFFECTS
    SYMMETRIC
    TASK COMMON
    VFUNCTION

消息标识：ERROR_0531

## Error:输入项目不能是任何隐含的 DO 循环的隐含 DO 变量，如果该循环包含输入项目。

在隐含 DO 循环内遇到身为该循环 DO 变量的 I/O 输入项目。

消息标识：ERROR_0532

## Error:不允许在嵌套的隐含 DO 中将它作为隐含 DO 变量重复使用。

DATA 语句中的隐含 DO 变量名称在隐含 DO 列表或数组构造中多次出现。导致发出此消息的语句示例如下：

    DATA ((A(I,J), I = 1,5), I = 1,5)

    IARRY = (/ ((I + I, I = 1, 3), I = 1, 3) /)

消息标识：ERROR_0533

## Error:它位于空白公共区，因此不能通过编译器指令语句赋予 AUXILIARY 属性。

辅助存储器中不允许存在空白公共区的数组或变量。

消息标识：ERROR_0534

## Error:它被定为字符类型，因此不能通过编译器指令语句赋予 AUXILIARY 属性。

辅助存储器中的变量和数组不能定义为字符类型。

消息标识：ERROR_0535

## Error:因为它所属类型含有字符或指针组件，所以它不能在辅助存储器中。

如果某项在辅助存储器中且被定义为派生类型，则该派生类型的组件不能是字符或指针。

消息标识：ERROR_0536

## Error:它位于 TASK COMMON 块中。不能通过编译器指令语句赋予其 AUXILIARY 属性。

不能向 TASK COMMON 块中的变量或数组赋予 AUXILIARY 属性。

消息标识：ERROR_0537

## Error:实数类负底数不可以有实数幂。

下例是算术上未定义的求幂运算。

         (-1.0)**3.5

不允许此类未定义的表达式。

消息标识：ERROR_0538

## Error:应该是续行，但这不是续行。

在自由源格式中，如果行尾有 &，说明该行将继续到下一个非注释行。此行之后没有非注释行。

消息标识：ERROR_0539

## Error:DIM 的指定值无效。

DIM 的指定值大于 ARRAY 的等级或小于 1。

消息标识：ERROR_0540

## Error:对此 Fortran 语句、类型、表达式或构造函数的支持将在以后版本中实现。

下列项目将在以后版本中实现： 使用内数组参数 REAL*16 REAL (KIND=16) COMPLEX*32 (KIND=16) 的MODULES USE 语句、CONTAINS 语句、内部过程、模块过程、构造函数边界声明

消息标识：ERROR_0541

## Error:重复因子不能带符号。

DATA 语句重复因子 (data_stmt_repeat) 必须是无符号标量整型常数 (scalar-int-constant)。整型常数可以是文字常量或命名常量，不能带符号。

消息标识：ERROR_0542

## 警告：将同种类型参数值映射到另一种类。

因为编译器当前不支持指定种类类型，它已被映射为新的种类类型。

消息标识：WARNING_0543

## Error:非空白 DO 结构的终止语句必须是可执行语句。

非空白 DO 结构的终止语句必须是诸如 CONTINUE 或赋值语句的可执行语句。它不能是非执行性语句（如 DATA 或 FORMAT 语句）。

消息标识：ERROR_0544

## 内部：两个运算符节点在引用树中标记为 IR_ARRAY_NODE。

来自 make_base_subtree 的内部编译器错误。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0545

## 内部：在 expr_semantics 中非数组与 subscript_opr 一起使用。

来自 expr_semantics 的内部编译器错误。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0546

## Ansi：它是命名常量，还是公共块名称。这是 Fortran 标准的一个扩展。

Fortran 标准禁止命名常量和公共块使用同一名称。

消息标识：ANSI_0547

## Error:它已被用作变量，所以不能用作派生类型名称。

编译器检测到此对象使用时的冲突。该对象被用作变量，所以禁止用作派生类名称。

消息标识：ERROR_0548

## Error:平行区域内不允许此语句。

f90 任务实现不允许在平行区域内部或外部有分支。平行区域既可能是 DOALL 循环，也可能是由 PARALLEL/ENDPARALLEL 对限制的代码区域。此类区域中不允许返回语句，否则会成为该区域的不当出口。同样，也不允许会成为该区域不当入口的 ENTRY 语句。

消息标识：ERROR_0549

## Error:它的一个属性限制用冲突属性对其进行声明。

编译器检测到此对象声明中有冲突。该对象不能同时具有这两个属性。

消息标识：ERROR_0550

## Error:它不能用该属性声明。

编译器检测到此对象声明中有冲突。该对象不能被赋予指定属性。

消息标识：ERROR_0551

## Error:它的一个属性限制以该方式对其进行声明。

编译器检测到此对象声明中有冲突。鉴于对象的给定属性，不能将其声明为新的项目。

消息标识：ERROR_0552

## Error:它不能以该方式声明。

编译器检测到此对象声明中有冲突。对象已声明为给定项目，因而不能声明为新的项目。

消息标识：ERROR_0553

## Error:它不能被再次赋予该属性。

在作用单元中，任何属性都不能多次地显式赋予一个实体。

消息标识：ERROR_0554

## 内部：不能写入到临时消息文件中。

编译器不能向临时消息文件中写入任何（更多）记录。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0555

## Log_Error：不能打开临时消息文件。

编译器无法打开此临时消息文件。要求该文件缓冲消息直至编辑结束，那时信息将以在源行顺序输出这些消息。检查工作目录的文件权限。

消息标识：LOG_ERROR_0556

## Error:它已用作变量，因此不能声明为或用作过程。

对象被引用为或定义为变量之后，一定不能重新声明为或引用为过程。

消息标识：ERROR_0557

## Error:它已被用作变量，因而不能以该方式声明。

声明的对象已被用作变量，所以不能声明为下列项目之一：

    	Cray 指针
    	Cray 指针对象
    	函数结果
    	派生类型
    	通用接口
    	名称列表组
    	语句函数
    	构造名
    	函数
    	subroutine

消息标识：ERROR_0558

## Error:它已被用作变量，因而不能用该属性声明。

声明的对象已被用作变量，所以不能赋予下列属性之一：

    	DIMENSION
    	ALLOCATABLE
    	PARAMETER
    	INTRINSIC
    	VFUNCTION
    	NOSIDE EFFECTS

消息标识：ERROR_0559

## Error:它已被定义为变量长度字符类型，因而不能用该属性声明。

编译器检测到此对象声明中有冲突。声明的对象类型已被定义为变量长度字符实体，所以不能赋予下列属性：

    	AUXILIARY
    	PARAMETER
    	SAVE
    	EXTERNAL
    	INTRINSIC
    	VFUNCTION
    	NOSIDE EFFECTS

定义为变量长度字符类型的对象不能多次赋予显式类型。一定不能对其进行等价或数据初始化。

消息标识：ERROR_0560

## Error:它已被定义为变量长度字符类型，因而不能以该方式声明。

编译器检测到此对象声明中有冲突。声明的对象类型已被定义为变量长度字符实体，所以不能声明为下列项目：

    	Cray 指针对象
    	伪参数
    	派生类型
    	通用接口
    	名称列表组
    	语句函数
    	构造名
    	函数
    	subroutine

消息标识：ERROR_0561

## Error:它是一个带有非恒定边界的显形数组，因而不能用该属性声明。

编译器检测到此对象声明中有冲突。声明的对象是一个带有非恒定边界的显形数组，因而不能赋予下列属性：

    	ALLOCATABLE
    	DIMENSION
    	PARAMETER
    	SAVE
    	POINTER
    	EXTERNAL
    	INTRINSIC
    	VFUNCTION
    	NOSIDE EFFECTS

一定不能对其进行等价或数据初始化。

消息标识：ERROR_0562

## Error:它是一个带有非恒定边界的显形数组，因而不能用该方式声明。

编译器检测到此对象声明中有冲突。声明的对象是一个带有非恒定边界的显形数组，因而不能声明为下列项目：

    	Cray 指针
    	Cray 指针对象
    	派生类型
    	通用接口
    	名称列表组
    	语句函数
    	构造名
    	subroutine
    	内部过程
    	模块过程

消息标识：ERROR_0563

## Error:它在公共块中，因而不能用该属性声明。

编译器检测到此对象声明中有冲突。声明的对象在公共块中，所以不能赋予下列属性：

    	ALLOCATABLE
    	PARAMETER
    	INTENT
    	OPTIONAL
    	SAVE
    	EXTERNAL
    	INTRINSIC
    	VFUNCTION
    	NOSIDE EFFECTS

它既不能定义为假定长度字符类型，也不能声明为假定大小或假定形式数组。

消息标识：ERROR_0564

## Error:它在公共块中，因此不能使用该方式声明。

编译器检测到此对象声明中有冲突。声明的对象在公共块中，所以不能声明为下列项目：

    	Cray 指针对象
    	函数结果
    	伪参数
    	派生类型
    	通用接口
    	名称列表组
    	语句函数
    	构造名
    	函数
    	subroutine

消息标识：ERROR_0565

## Error:它是在显式接口中定义的，因此不能用该属性声明。

如果已为过程声明了显式接口，则必须在此显式接口内部指定描述此过程的所有信息（除 PTIONAL、PRIVATE 和 PUBLIC 属性）。此过程可以被指定为伪参数。

消息标识：ERROR_0566

## Error:它是在显式接口中定义的，因此不能以该方式声明。

如果已为过程声明了显式接口，则必须在此显式接口内部指定描述此过程的所有信息（除 PTIONAL、PRIVATE 和 PUBLIC 属性）。此过程可以被指定为伪参数。

消息标识：ERROR_0567

## Error:它在子例程调用中是无效引用。

CALL 语句中只能引用子例程。

消息标识：ERROR_0568

## Error:标签变量必须是变量，不能是命名常量。

ASSIGN 语句或赋值 GO TO 语句中有命名常量，该处本应为标签变量 (scalar_int_variable)。

ASSIGN 语句的语法是：

    ASSIGN label TO scalar_int_variable

赋值 GO TO 语句的语法是：

    GO TO scalar_int_variable [ [,] (label_list) ]

scalar_int_variable 必须是变量的非限定名，即它不能是结构组件、数组元素或子串指示器。标签必须为缺省整数类型，且它必须为标量。

消息标识：ERROR_0569

## Error:它有 ALLOCATABLE 属性，因而必须声明为延迟形数组。

如果某对象已声明为可分配对象，则也必须声明为延迟形数组。以下是声明 A 为可分配的两种正确方式。

    ALLOCATABLE ::A(:)

    REAL, ALLOCATABLE ::A
    DIMENSION A(:)

消息标识：ERROR_0570

## Error:函数结果是延迟形数组，因此必须具有 POINTER 属性。

函数结果是延迟形数组，必须具有 POINTER 属性。同样，具有 POINTER 属性且为数组的函数名称必须用 deferred_shape_spec_list 声明。

示例：

    FUNCTION FCN()
    REAL，DIMENSION(:) ::FCN
    POINTER ::FCN

消息标识：ERROR_0571

## Error:它已被用作函数，因而不能用该属性声明。

声明的对象已被用作函数，因此不能对此对象作进一步的声明。

消息标识：ERROR_0572

## Error:它已被用作函数，因此不能以该方式声明。

声明的对象已被用作函数，因此不能对此对象作进一步的声明。

消息标识：ERROR_0573

## Error:它已被用作子例程，因而不能用该属性声明。

声明的对象已被用作子例程，因此不能对此对象作进一步的声明。

消息标识：ERROR_0574

## Error:它已被用作子例程，因此不能以该方式声明。

声明的对象已被用作子例程，因此不能对此对象作进一步的声明。

消息标识：ERROR_0575

## Error:它具有该属性，因此不能定义为变量长度字符类型。

对象不能定义为变量长度字符类型，如果对象已在先前的类型语句中已定义了类型，或已在 DATA 语句中初始化，或具有下列属性：PARAMETER、SAVE、POINTER、VFUNCTION、AUXILIARY、NOSIDE EFFECTS、EXTERNAL 或 INTRINSIC。

消息标识：ERROR_0576

## Error:它已声明，因而现在不能定义为变量长度字符类型。

编译器检测到此对象声明中有冲突。对象不能定义为变量长度字符类型，因为它已被声明为下列项目之一：

    Cray 指针
    Cray 指针对象
    模块过程
    派生类型
    通用接口
    名称列表组
    语句函数
    构造
    module
    块数据
    程序
    subroutine

消息标识：ERROR_0577

## Error:它在公共块中，因此不能定义变量长度字符类型。

在编译时间必须知道公共块中对象的字符长度。

消息标识：ERROR_0578

## Error:它已在显式接口中定义。有关该过程的所有信息必须在接口中指定。

如果已为过程声明了显式接口，则必须在此显式接口内部指定描述此过程的所有信息（除 PTIONAL、PRIVATE 和 PUBLIC 属性）。此过程可以被指定为伪参数。

消息标识：ERROR_0579

## Error:该对象的数据类型和该 PARAMETER 赋值中的数据类型不兼容。

命名常量用初始化表达式求出的值定义。这必须满足 Fortran 标准中定义的内部赋值规则。指定命名常量的类型和值的类型不满足内部赋值的规则。

消息标识：ERROR_0580

## Error:它是子例程，因而不能赋予显式类型。

此对象是子例程，因而不能赋予显式类型。

消息标识：ERROR_0581

## Error:它具有该属性，因而不能声明为带有非恒定边界的显形数组。

编译器检测到此对象声明中有冲突。对象不能声明为带有非恒定边界的显形数组，因为它已被等价、数据初始化、定义为假定长度字符类型和/或具有一个或多个下列属性：

    ALLOCATABLE
    DIMENSION
    PARAMETER
    SAVE
    PRIVATE
    PUBLIC
    POINTER
    EXTERNAL
    INTRINSIC
    VFUNCTION
    NOSIDE EFFECTS

消息标识：ERROR_0582

## Error:它已被声明，因而现在不能声明为带有非恒定边界的显形数组。

编译器检测到此对象声明中有冲突。对象不能声明为带有非恒定边界的显形数组，因为它已声明为下列项目之一：

    Cray 指针
    模块过程
    派生类型
    通用接口
    名称列表组
    语句函数
    构造
    module
    块数据
    程序

消息标识：ERROR_0583

## Log_Error：机器特性系统调用失败。

因为机器特性系统调用被赋予无效机器名称，所以调用失败。

消息标识：LOG_ERROR_0584

## Error:它在公共块中，因而不能声明为带有非恒定边界的显形数组。

在编译时间必须知道公共块中数组的长度。

消息标识：ERROR_0585

## 警告：-dp 选项不影响 REAL(KIND=16) 或 COMPLEX(KIND=16)。这些将仍为双精度。

REAL(KIND=16) 和 COMPLEX(KIND=16) 不受 -dp 命令行选项的影响。

消息标识：WARNING_0586

## Error:要将 PARAMETER 赋值用于此对象，初始化表达式必须是常量。

如果类型声明语句具有 PARAMETER 属性，或在 PARAMETER 语句中指定了初始化表达式，Fortran 标准要求初始化表达式为常量。

消息标识：ERROR_0587

## Error:它是例程，因此不能用 DIMENSION 属性声明。

子例程不能具有 DIMENSION 属性。

消息标识：ERROR_0588

## Error:它有一个属性指示其现在不能位于公共块。

编译器检测到此对象声明中有冲突。对象不能在公共块中，原因在于：

-- 它被定义为 CHARACTER*(*) 类型，
-- 它是假定大小或假定形式数组，或
-- 它具有一个或多个下列属性：

    ALLOCATABLE
    PARAMETER
    INTENT
    OPTIONAL
    SAVE
    EXTERNAL
    INTRINSIC
    VFUNCTION
    NOSIDE EFFECTS

消息标识：ERROR_0589

## Error:它已声明，因而现在不能在公共块中。

编译器检测到此对象声明中有冲突。对象不能在公共块中，因为其已声明为下列项目之一：

    Cray 指针对象
    函数结果
    伪参数
    派生类型
    通用接口
    名称列表组
    语句函数
    构造名
    procedure
    module
    块数据
    程序

消息标识：ERROR_0590

## Error:它被定义为变量长度字符类型，因而不能在公共块中。

在编译时间必须知道公共块中字符变量的长度。

消息标识：ERROR_0591

## Error:它是一个带有非恒定边界的显形数组，因而不能在公共块中。

在编译时间必须知道公共块中数组的长度。

消息标识：ERROR_0592

## Error:它已经出现在公共块中。它只能在公共块中指定一次。

一个变量只能在公共块中出现一次，并且一个变量只能在一个公共块中出现。编译器检测到：一个公共块中同一变量被多次指定，或同一变量出现在两个不同的公共块中。

消息标识：ERROR_0593

## Error:它是个过程名，因而不能在公共块中。

公共块中只允许变量。

消息标识：ERROR_0594

## Error:此程序单元中不允许该类型声明语句的属性。

尽管此程序单元应该允许类型声明语句，但不允许该特定属性。以下是不同属性的上下文约束：
-- ALLOCATABLE：块数据程序单元中不允许。
-- DIMENSION：允许类型声明语句的上下文即可。
-- EXTERNAL：块数据程序单元中不允许。
-- INTENT：仅子例程、函数和接口体允许。
-- INTRINSIC：允许类型声明语句的上下文即可。
-- OPTIONAL：仅子例程、函数和接口体允许。
-- PARAMETER：允许类型声明语句的上下文即可。
-- POINTER：允许类型声明语句的上下文即可。
-- PRIVATE：仅模块允许。
-- PUBLIC：仅模块允许。
-- SAVE：允许类型声明语句的上下文即可。
-- TARGET：允许类型声明语句的上下文即可。

消息标识：ERROR_0595

## Error:只有派生类型语句在模块的规范部分，才能指定此属性。

尽管此上下文可以允许派生类型声明语句，但只有此派生类型声明语句位于模块程序单元，才能允许 PUBLIC 和 PRIVATE 属性。

消息标识：ERROR_0596

## 限制：编译器内部开发命令行选项造成编译器在第一个 ANSI 信息上终止。

有一个开发命令行选项造成编译器在第一个 ANSI 信息后终止。

消息标识：LIMIT_0597

## Error:它不能有 PUBLIC 属性，因为它已定义为私有类型。

如果对象已定义为私有类型，则不能赋予其 PUBLIC 属性，无论用缺省还是实际声明。

消息标识：ERROR_0598

## Error:它具有%s属性，因而不能在名称列表组中。

对象不能在名称列表组中，因为它被定义为 CHARACTER*(*) 类型，它是假定大小、假定形式或延迟形式数组，或它具有一个或多个下列属性：

    ALLOCATABLE
    AUXILIARY
    PARAMETER
    POINTER
    EXTERNAL
    INTRINSIC
    VFUNCTION
    NOSIDE EFFECTS

消息标识：ERROR_0599

## Error:它的声明方式禁止其出现在名称列表组中。

对象不能在名称列表组中，因为它是下列项目之一：

    Cray 指针对象
    派生类型
    通用接口
    名称列表组
    语句函数
    构造
    module
    块数据
    程序
    函数
    subroutine

名称列表组中的对象必须是变量。

消息标识：ERROR_0600

## Error:它被定义为变量长度字符类型，因而不能在名称列表组中。

在编译时间必须知道名称列表组对象的长度。

消息标识：ERROR_0601

## Error:它是有带有非恒定边界的显形数组，因而不能在名称列表组中。

在编译时间必须知道名称列表组对象的长度。

消息标识：ERROR_0602

## Error:它是个过程名，因而不能在名称列表组中。

名称列表组中的所有对象都必须是变量。

消息标识：ERROR_0603

## Log_Warning：这是不被支持的编译器指令。

在该硬件上指定的编译器指令不被支持，或该指令将在以后版本中实现。

消息标识：LOG_WARNING_0604

## Error:要在初始化表达式中使用，它必须是常量。

若要在初始化表达式中使用，对象必须是常量。编辑器检测到下列情况之一：
-- 对象被定义为字符或带有非恒定边界的数组。
-- 对象是公用的，因而是变量。
-- 对象是一个过程。它有显式接口和/或被用作函数或子例程。
-- 对象已被用作变量。

消息标识：ERROR_0605

## 内部：I/O 控制列表内部错误。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0606

## Error:对象位于辅助存储器。它不能与主机关联。

辅助存储器中的对象不能与主机关联。辅助存储是 Fortran 标准的一个扩展。

消息标识：ERROR_0607

## Error:它的一个属性禁止其成为接口块中的过程。

如果已为过程声明了显式接口，则必须在此显式接口内部指定描述此过程的所有信息（除 PTIONAL、PRIVATE 和 PUBLIC 属性）。此过程可以被指定为伪参数。

消息标识：ERROR_0608

## Error:它的声明方式禁止其成为接口块中的函数。

如果已为过程声明了显式接口，则必须在此显式接口内部指定描述此过程的所有信息（除 PTIONAL、PRIVATE 和 PUBLIC 属性）。此过程可以被指定为伪参数。

消息标识：ERROR_0609

## Error:它被定义为变量长度字符类型，因而不能是接口块中的一个过程。

如果已为过程声明了显式接口，则必须在此显式接口内部指定描述此过程的所有信息（除 PTIONAL、PRIVATE 和 PUBLIC 属性）。此过程可以被指定为伪参数。

消息标识：ERROR_0610

## Error:它是带有非恒定边界的显形数组，因而不能是接口块中的一个过程。

如果已为过程声明了显式接口，则必须在此显式接口内部指定描述此过程的所有信息（除 PTIONAL、PRIVATE 和 PUBLIC 属性）。此过程可以被指定为伪参数。

消息标识：ERROR_0611

## Error:它是在公共块中，因而不能是过程或被用作过程。

公共块中的所有对象都是变量。编译器检测到将变量用作过程或声明为过程的企图。

消息标识：ERROR_0612

## Error:它已在显式接口中定义。不能用一个以上的显式接口定义它。

一个过程只能在一个显式接口中定义。在接口块中定义了外部过程的一个显式接口。定义过程时，为模块或内部过程定义了显式接口。

消息标识：ERROR_0613

## Error:它所需的存储大小超过了最大可用存储大小。

此项目所需的存储大小超过了本机的存储大小（以字为单位）。

消息标识：ERROR_0614

## Error:此表达式所需的存储大小超过了最大可用存储大小。

此项目所需的存储超过了本机的存储大小（以字为单位）。表达式可能包含数组构造函数，或者是函数调用的结果。

消息标识：ERROR_0615

## Error:它已被用作函数，因而不能在显式接口块中声明。

除内部函数外，函数的所有定义都必须在使用之前进行。它们可能在使用时尚未定义。

消息标识：ERROR_0616

## Error:它已被用作子例程，因而不能在显式接口块中声明。

除内部子例程外，子例程的所有定义都必须在使用之前进行。它们可能在使用时尚未定义。

消息标识：ERROR_0617

## Error:预编译的过程必须与该编译指定的双精度 (-ep/-dp) 选项相同。

如果当前编译单元使用 -dp 选项进行编译，则它使用的每个模块或试图内联的每个预编译过程都必须用 -dp 选项编译。如果当前编译单元使用 -ep 选项进行编译，则它使用的每个模块或内联的每个预编译过程都必须使用 -ep 选项编译。

消息标识：ERROR_0618

## Error:它的声明方式禁止其成为接口块中的子例程。

如果已为过程声明了显式接口，则必须在此显式接口内部指定描述此过程的所有信息（除 PTIONAL、PRIVATE 和 PUBLIC 属性）。此过程可以被指定为伪参数。

消息标识：ERROR_0619

## 警告：伪参数不是辅助数组，但此实际参数却是。

如果实际参数为辅助数组，则传递给子程序的地址将成为辅助存储器地址。如果相关伪参数不是辅助数组，则地址将被错误解释。 辅助数组是 Fortran 标准的一个扩展。

消息标识：WARNING_0620

## Error:此种类参数无效。它必须是一个标量整型常数。

种类参数的语法是 _kind-param

kind_param 是 digit_string 或 scalar_int_constant_name

无效种类参数示例如下：

        4
        8
    INTEGER, PARAMETER ::KIND_PARM=4

消息标识：ERROR_0621

## Error:伪参数具有 TARGET 属性。它需要一个带 TARGET 或 POINTER 属性的实际参数。

具有 TARGET 属性的伪参数只能与具有 TARGET 或 POINTER 属性的实际参数相关联。

消息标识：ERROR_0622

## Error:预编译过程的缺省整型类大小必须与此编译的缺省整型类大小匹配。

对于模块，必须用相同的缺省整型种类类型编译模块和正在使用的编译单元。必须用相同的 -i 命令行选项或相同的 CDIR$ INTEGER= 选项编译它们。示例如下。

    模块          编译单元
    缺省         正在使用模块
    -i64             -i64            !Legal
    -i32             -i64            !非法
    !DIR INTEGER=64  -i32            !非法
    !DIR INTEGER=64  !DIR INTEGER=64 !Legal

预编译可内联过程也是这样。调用者和被调用者应当用同样的方式编辑。

消息标识：CAUTION_0623

## 内部：留给 ptr_assign_from_target 的不良操作数。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0624

## Error:要成为 Cray 字符的指针对象，它必须在 POINTER 语句之前予以声明。

声明 Cray 字符指针时，必须在 POINTER 语句之前声明指针对象的类型为 CHARACTER*(*)，如下例所示：

    CHARACTER*(*)  EE
    POINTER(PTR, EE)   ! legal

    POINTER(PTR, EE)
    CHARACTER*(*)  EE  ! illegal

消息标识：ERROR_0625

## 内部：未获得预期的内容。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0626

## 警告：伪参数是辅助数组，实际参数不是。

如果子程序的接口已知，且伪参数是辅助数组，则子程序要求所接收地址是辅助存储器地址。如果与辅助数组伪参数关联的实际参数是表达式、非辅助数组或数组段，则没有此条件。因为辅助数组的数组段被复制到不在辅助存储器中的临时数组中，所以该数组段仍然无效。辅助存储是 Fortran 标准的一个扩展。

消息标识：WARNING_0627

## Error:它的一个属性禁止将其用作外部函数名。

编译器检测到此对象的声明和使用间的冲突。对象不能用作外部函数名，因为它已定义为假定长度字符类型，它是假定大小或假定形式数组，它已被等价或数据初始化或具有一个或多个下列属性：

    ALLOCATABLE
    AUXILIARY
    PARAMETER
    INTENT
    TARGET
    SAVE
    POINTER
    INTRINSIC

消息标识：ERROR_0628

## Error:它的声明方式禁止将其用作外部函数名。

编译器检测到此对象的声明和使用间的冲突。此对象不能用作外部函数名，因为它已被声明为下列项目之一：

    Cray 指针
    Cray 指针对象
    函数结果
    派生类型
    名称列表组
    语句函数
    构造
    variable
    module
    块数据
    程序
    subroutine
    内部过程

消息标识：ERROR_0629

## 内部：namelist_static_dv_whole_def 中的非常量字符。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0630

## Log_Error：该编译器在此硬件上没有得到许可。请与 Sun 联系。

要在此硬件上运行编译器，需要有许可。

消息标识：LOG_ERROR_0631

## Error:它已被用作子例程，因此不能用作函数。

对象是子例程，因此不能用作函数。

消息标识：ERROR_0632

## Error:它的一个属性禁止将其用作 CALL 语句中的子例程名。

子例程只能具有以下属性：

    OPTIONAL
    PUBLIC
    PRIVATE
    EXTERNAL
    INTRINSIC
    NOSIDE EFFECTS

消息标识：ERROR_0633

## Error:它的声明方式禁止将其用作 CALL 语句中的外部子例程名。

编译器检测到此对象的声明和使用间的冲突。此对象不能用作 CALL 语句的外部子例程名，因为其已被声明为下列项目之一：

    Cray 指针
    Cray 指针对象
    函数结果
    派生类型
    名称列表组
    语句函数
    构造
    variable
    module
    块数据
    程序
    函数

消息标识：ERROR_0634

## Error:它已被定义为字符类型，因而不能用作子例程。

子例程不能具有显式类型。

消息标识：ERROR_0635

## Error:它具有 DIMENSION 属性，因而不能用作子例程。

子例程不能具有 DIMENSION 属性。

消息标识：ERROR_0636

## 内部：io_list_semantics 中除列表运算符以外的部分。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0637

## Error:Cray 字符指针对象必须是假设长度字符变量。

要成为 Cray 字符指针对象，此指针对象必须声明为 CHARACTER*(*)，如下例所示：

    CHARACTER*(*)  EE
    POINTER(PT, EE)    ! legal

    CHARACTER*(I)  EE
    POINTER(PT,EE)     ! illegal

    CHARACTER*(6)  EE
    POINTER(PT,EE)     ! illegal

Cray 指针数据类型是 Fortran 标准的一个扩展。

消息标识：ERROR_0638

## Error:它被用作函数，因而不能用作子例程。

函数的引用方式不同于子例程。

消息标识：ERROR_0639

## Error:该实际参数不能为标量。

此特定参数不能是标量实体。

消息标识：ERROR_0640

## Error:它的声明方式禁止其用于表达式。

编译器检测到此名称的声明和使用间的冲突。此名称不能在表达式中使用，因为它是派生类型名、名称列表组名、构造名、模块名、块数据程序单元名或主程序名。

消息标识：ERROR_0641

## Error:它的声明方式禁止以该方式其进行重声明。

Cray 指针不能同时是 Cray 字符指针。Cray 字符指针不能同时是 Cray 指针。Cray 指针和字符指针数据类型是 Fortran 标准的扩展。

消息标识：ERROR_0642

## Error:它已被用作子例程，因而不能在表达式中引用。

子例程只能在 CALL 语句中使用。

消息标识：ERROR_0643

## Error:它的一个属性禁止将其用作派生类型名称。

用作派生类型的此对象必须是派生类型。派生类型名只能具有 PUBLIC 或 PRIVATE 属性。

消息标识：ERROR_0644

## Error:它的声明方式禁止将其用作派生类型名。

编译器检测到此对象的声明和使用间的冲突。该对象不是派生类型名，不能用作派生类型名。

消息标识：ERROR_0645

## Error:它已被定义为字符类型，因而不能用作派生类型名。

编译器检测到此对象的声明和使用间的冲突。所用对象被定义为字符类型，所以禁止用作派生类型名。

消息标识：ERROR_0646

## Error:它具有 DIMENSION 属性，因而不能用作派生类型名。

编译器检测到此对象声明中有冲突。派生类型名只能具有 PUBLIC 或 PRIVATE 属性。

消息标识：ERROR_0647

## Error:它在公共块中，从而成为变量，因此不能用作派生类型名。

编译器检测到此对象的声明和使用间的冲突。对象在公共块中，因而是变量。不能将变量用作派生类型名。

消息标识：ERROR_0648

## Error:它是个过程，因此不能用作派生类型名。

编译器检测到此对象的声明和使用间的冲突。对象是个过程，因此不能用作派生类型名。

消息标识：ERROR_0649

## Error:这是 Cray 指针对象。不能将它定义为派生类型。

Cray 指针对象不能是派生类型。Cray 指针数据类型（及其相关指针对象）是 Fortran 标准的一个扩展。

消息标识：ERROR_0650

## Error:它已被定义为派生类型，因而不能声明为 Cray 指针对象。

Cray 指针对象不能是派生类型。Cray 指针数据类型（及其相关指针对象）是 Fortran 标准的一个扩展。

消息标识：ERROR_0651

## Error:它已被用作函数，所以不能用作派生类型名。

编译器检测到此对象使用之间的冲突。声明对象被用作函数，所以禁止用作派生类型名。

消息标识：ERROR_0652

## Error:它已用作子例程，所以不能用作派生类型名。

编译器检测到此对象使用时的冲突。声明对象被用作子例程，所以不能用作派生类型名。

消息标识：ERROR_0653

## Error:这个实际参数对于此内在过程没有合法等级。

此实际参数对于正在讨论的内在过程没有合法等级。

消息标识：ERROR_0654

## 内部：fnd_semantic_err 正在检测调用例程未检测的错误。

很多例程自行检测错误，出现问题时才调用 fnd_semantic_err。如果语义表发生更改，则调用例程也需要作相应更改。通过检查该内部错误之前的错误，可以发现相关的问题。这是调用例程需要检测的错误。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0655

## Error:没有存取列表的 PUBLIC/PRIVATE 语句，只能在模块的作用单元内指定一次。

不带 access_id_list 的多个 PRIVATE 和 PUBLIC 语句是非法的。编译器检测到类似下列示例的内容：

    MODULE A
    PUBLIC
    PRIVATE  !Illegal - PUBLIC is already specified

消息标识：ERROR_0656

## Error:函数结果不能在名称列表组中，因为它不是活动函数的结果。

如果函数结果位于名称列表语句的内容范围内，则允许其位于名称列表组中，如下例所示：

    MODULE ABC
    CONTAINS
    FUNCTION XYZ()
    NAMELIST /GRP/ XYZ, RST  !RST is illegal
    END FUNCTION

    FUNCTION RST()
    END FUNCTION
    END MODULE

在 NAMELIST 语句中 RST 是非法的，因为 NAMELIST 语句在 RST 的范围之外。XYZ 是合法的名称列表组成员。

消息标识：ERROR_0657

## Error:它必须是整型常量或包含隐含 DO 的 DO 变量。

DATA 隐含 DO 的开头、结尾或增量表达式的每个操作数都必须是整型常量（文字或已命名的），或是包含隐含 DO 的 DO 变量。

消息标识：ERROR_0658

## Error:必须在同一入口点指定用在此对象长度表达式中的所有伪参数。

如果变量长度字符声明使用伪参数确定长度表达式，则必须在同一入口点指定所有的伪参数。编译器检测到以下长度表达式：其中两个伪参数位于不同的入口点。下面的示例说明此情况：

    SUBROUTINE SUBCHAR(IDX1)
    CHARACTER*(IDX1 + IDX2)  SUN_CHAR
          ...
    ENTRY SUBLATER(IDX2)
          ...
    END SUBROUTINE

此程序将接收到 SUN_CHAR 的长度表达式错误。要使此程序合法，必须在至少一个入口点处同时指定 IDX1 和 IDX2。

消息标识：ERROR_0659

## Error:必须在同一入口点指定用在此数组边界表达式中的所有伪参数。

如果变量长度数组声明使用伪参数确定其边界，则必须在同一入口点指定所有的伪参数。编译器检测到以下数组声明：它的一个伪参数与其边界表达式中的另一伪参数位于不同的入口点。下面的示例说明此情况：

    SUBROUTINE SUBDIM(IDX1)
    REAL, DIMENSION (IDX1,IDX2) ::AN_ARRAY
          ...
    ENTRY SUBLATER(IDX2)
          ...
    END SUBROUTINE

此程序将接收到 AN_ARRAY 声明的错误。要使此程序合法，必须在至少一个入口点处同时指定 IDX1 和 IDX2。

消息标识：ERROR_0660

## Error:必须在同一入口点指定用于在规范表达式中声明它的所有伪参数。

编译器检测到以下字符数组声明：在规范表达式中使用伪参数声明字符长度和数组边界。必须在至少一个公共入口点，指定用于在规范表达式中声明此对象的所有伪参数。下面的示例说明此情况：

    SUBROUTINE SUBCHAR(IDX1)
    CHARACTER*(IDX1)  CHAR_ARRAY(IDX2)
          ...
    ENTRY SUBLATER(IDX2)
          ...
    END SUBROUTINE

此程序将接收到 CHAR_ARRAY 声明的错误。要使此程序合法，必须在至少一个入口点处同时指定 IDX1 和 IDX2。

消息标识：ERROR_0661

## Error:必须在指定该对象的入口点，指定用于在表达式中声明它的所有伪参数。

编译器检测到以下伪参数声明：在规范表达式中使用伪参数声明字符长度和/或数组边界。必须在指定该伪参数的入口点，指定用于在规范表达式中声明此对象的所有伪参数。下面的示例说明此情况：

    SUBROUTINE SUBCHAR(IDX1, CHAR_ARRAY)
    CHARACTER*(IDX1)  CHAR_ARRAY(IDX2)
          ...
    ENTRY SUBLATER(IDX2)
          ...
    END SUBROUTINE

此程序将接收到 CHAR_ARRAY 声明的错误。要使此程序合法，必须在至少一个入口点处同时指定 IDX1 和 IDX2。

消息标识：ERROR_0662

## Error:它属于辅助存储器中的公共块，因而不能是名称列表组的对象。

名称列表组对象不能在辅助存储器中。 辅助存储是 Fortran 标准的一个扩展。

消息标识：ERROR_0663

## 内部：表达式语义检查没能检测出常量说明表达式中的错误。

如果语句类型是组件声明语句，则表达式分析器应捕捉到非常量表达式中的所有对象。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0664

## 内部：create_dv_type_code 出现意外基本类型。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0665

## Error:它被用作字符长度变量或函数，因此不能是函数名。

PP 编译器检测到以下内容：

    CHARACTER*(IFUN)  FUNCTION IFUN()

PP 或

    CHARACTER*(IFUN(1))  FUNCTION IFUN(I)

PP 它们都是非法的。

消息标识：ERROR_0666

## Error:需要进行初始化的实体数量超过了值的个数。

PP DATA 语句指定的要初始化的实体多于值列表中的可用值。DATA 语句有下列格式：

    DATA data_stmt_set [ [,] data_stmt_set ]

PP 其中每个 data_stmt_set 包括

    data_stmt_object_list /data_stmt_value_list/

PP data_stmt_object_list 扩展形成标量变量序列，data_stmt_value_list 扩展形成标量常量值序列。扩展后的 data_stmt_object_list 的实体数必须与扩展后的 data_stmt_value_list 的常量值数目相同。

消息标识：ERROR_0667

## Error:值的个数超过了需要进行初始化实体的数量。

PP DATA 语句在值列表中指定的值多于要初始化的实体。DATA 语句有下列格式：

    DATA data_stmt_set [ [,] data_stmt_set ]

PP 其中每个 data_stmt_set 包括

    data_stmt_object_list /data_stmt_value_list/

PP data_stmt_object_list 扩展形成标量变量序列，data_stmt_value_list 扩展形成标量常量值序列。扩展后的 data_stmt_object_list 的实体数必须与扩展后的 data_stmt_value_list 的常量值数目相同。

消息标识：ERROR_0668

## Error:匹配的 DO 语句有个构造名，因而该语句必须是具有相同构造名的 END DO。

PP 如果用构造名标识块 DO 构造的 DO 语句，则该 DO 构造的终止语句必须是 END DO 语句，且此 END DO 必须指定同一构造名。

消息标识：ERROR_0669

## 内部：列表项目数大于列表计数值。

PP 应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0670

## Error:过程已经在接口块中。不能多次指定。

PP 在同一接口块中，不能多次指定一个过程。以下是使用模块过程的示例：

    PROGRAM TEST1
    USE FOOS
    INTERFACE INT_1
    MODULE PROCEDURE FOO,FOO !FOO is illegal
    MODULE PROCEDURE FOO1
    MODULE PROCEDURE FOO1    !FOO1 is illegal
    END INTERFACE

    INTERFACE INT_2
    MODULE PROCEDURE FOO2B
    END INTERFACE

    INTERFACE INT_2
    MODULE PROCEDURE FOO2b   !FOO2B is illegal
    END INTERFACE
    END

PP 但对于模块过程，下列对象是合法的：

    MODULE TEST2
    USE FOOS
    INTERFACE INT_2
    MODULE PROCEDURE FOO2B
    END INTERFACE
    END MODULE

    MODULE TEST3
    USE FOOS
    INTERFACE INT_2
    MODULE PROCEDURE FOO2B
    END INTERFACE
    END MODULE

    PROGRAM TEST4
    USE TEST2
    USE TEST3   !This is legal, because
    ! FOO2B is coming in from
    ! two separate modules
    END

消息标识：ERROR_0671

## Error:它已被用作函数，因而不能声明为带有非恒定边界的显形数组。

PP 声明对象已用作函数，因而不能声明为带有非恒定边界的显形数组。必须在使用实体之前声明。

消息标识：ERROR_0672

## Error:这些入口点的维数属性冲突。

PP 如果带有一个或更多 ENTRY 语句的函数的某入口点的结果具有 DIMENSION 属性，那么该函数的所有入口点都必须返回具有相同 DIMENSION 属性的结果。如果是函数是值确定的数组，则所有入口点都必须返回相同等级的结果，如果函数不是假定形的，则所有入口点的形式必须一致。

消息标识：ERROR_0673

## Error:入口点都必须具有 POINTER 属性。

PP 如果带有一个或更多 ENTRY 语句的函数的某入口点的结果具有 POINTER 属性，那么该函数的所有入口点都必须返回具有 POINTER 属性的结果。

消息标识：ERROR_0674

## Error:隐含的 DO 变量必须是整数类型变量名。

PP DATA 语句或数组构造函数中的隐含 DO 列表，包含不是整型变量的隐含 DO 循环控制变量。PP DATA 语句隐含 DO 有以下格式：

    (data_i_do_object_list, data_i_do_variable =
    scalar_int_expr, scalar_int_expr
    	[, scalar_int_expr])

PP data_i_do_variable 必须是整型变量的名称。PP 数组构造函数隐含 DO 具有以下格式：

    (ac_value_list, ac_do_variable =
    scalar_int_expr, scalar_int_expr
    	[, scalar_int_expr])

PP ac_do_variable 必须是整型变量的名称。PP 作为对解释请求的反应，Fortran 标准的更正扩展了身为语句实体（I/O 隐含的 DO 变量不是语句实体）的隐含 DO 循环控制变量的规则。本质上讲，它说明在包含 DATA 语句或数组构造函数的作用单元中，语句实体名可以和公共块名或整型标量名相同。因此，statement 实体名不能和以下名称相同：外部过程、内部过程、模块过程、命名常量、构造名、通用名、派生类型名等。同样，因为它必须为整型，所以它的名称也不能和声明为非整型的实体相同。PP 解释反应也说明隐含 DO 变量必须是标量变量的名称，但通过允许作为整型数组的 data_i_do_variable 或 ac_do_variable 同名，Sun f90 扩展了标准。

消息标识：ERROR_0675

## Error:在 DATA 值列表中的标识符必须是先前声明的命名常量的名称。

PP 数据语句的值列表中的值有以下格式：

    [data_stmt_repeat *] data_stmt_constant

PP 如果重复因子或常量是标识符，则必须是命名常量的名称，且该命名常量必须已在作用单元中预先声明，或已通过使用或主机关联具有可访问性。

消息标识：ERROR_0676

## Error:如果重复因子是个标识符，它必须是标量命名常量的名称。

PP DATA 语句值列表中的值之前可以有一个重复因子，如下所示：

    [data_stmt_repeat *] data_stmt_constant

PP 如果 DATA 语句重复因子是个标识符，它必须是命名常量的名称，且此命名常量必须代表一个标量值。

消息标识：ERROR_0677

## Error:DATA 语句重复因子必须是整数类型。

PP DATA 语句值列表中的值之前可以有一个重复因子，如下所示：

    [data_stmt_repeat *] data_stmt_constant

PP DATA 语句重复因子必须是整数类型。

消息标识：ERROR_0678

## Error:DATA 语句重复因子的值必须等于或大于零。

PP DATA 语句值列表中的值之前可以有一个重复因子，如下所示：

    [data_stmt_repeat *] data_stmt_constant

PP 如果 DATA 语句重复因子是标识符，则它必须是命名常量的名称，并且该命名常量必须代表一个等于或大于零的值。

消息标识：ERROR_0679

## Error:为任务指令指定了多个 IF 条件。

PP DOALL 和 PARALLEL 编译器任务指令的 IF 条件参数仅能被指定一次。

消息标识：ERROR_0680

## Error:该语句中的字符数说明符必须为整数类型。

PP ENCODE 或 DECODE 语句正在指定一个非整数值的字符数。在以下语句中，字符数 n 必须是小于或等于 152 的非零整数表达式：

    ENCODE (n,f,dent) [elist]
    DECODE (n,f,sent) [dlist]

消息标识：ERROR_0681

## Error:该语句中的字符数说明符必须介于 1 到 152 之间。

PP ENCODE 或 DECODE 语句正在指定一个 1 to 152 范围之外的字符数的值。在以下语句中，字符数 n 必须是小于或等于 152 的非零整数表达式。

    ENCODE (n,f,dent) [elist]
    DECODE (n,f,sent) [dlist]

消息标识：ERROR_0682

## Error:该语句中的字符数说明符必须为标量整数表达式。

PP ENCODE 或 DECODE 语句正在指定一个无效表达式字符数的值。在以下语句中，字符数 n 必须是小于或等于 152 的非零整数表达式：

    ENCODE (n,f,dent) [elist]
    DECODE (n,f,sent) [dlist]

消息标识：ERROR_0683

## Error:模块过程必须具有 PRIVATE 属性，因为其函数结果为私有类型。

PP 具有伪参数的模块过程或具有私有可访问性类型的函数结果必须具有私有可访问性。PP 如果模块过程是公有的，那么，在它的任何伪参数或函数结果为派生类型时，其类型必须为公有类型。

消息标识：ERROR_0684

## Error:模块过程必须具有 PRIVATE 属性，因为伪参数为私有类型。

PP 具有伪参数的模块过程或具有私有可访问性类型的函数结果必须具有私有可访问性。PP 如果模块过程是公有的，那么，在它的任何伪参数或函数结果为派生类型时，其类型必须为公有类型。

消息标识：ERROR_0685

## Error:通用接口必须是私有类型，因为特定接口是私有类型函数。

PP 具有伪参数的模块过程或具有私有可访问性类型的函数结果必须具有私有可访问性，并且不能有公有可访问性的通用标识符。PP 如果通用标识符具有公有可访问性，那么，其所有特定过程都必须具有函数结果和声明为公有类型的伪参数。

消息标识：ERROR_0686

## Error:通用接口必须是私有类型，因为特定接口的伪参数为私有类型。

PP 具有伪参数的模块过程或具有私有可访问性类型的函数结果必须具有私有可访问性。PP 如果模块过程是公有的，那么，在它的任何伪参数或函数结果为派生类型时，其类型必须为公有类型。

消息标识：ERROR_0687

## Error:在 SAVE 语句中指定了公共块，但并未在 COMMON 语句中指定该公共块。

PP 如果在 SAVE 语句中指定了公共块，那么还必须在 COMMON 语句中声明该公共块。

消息标识：ERROR_0688

## 内部：globals.h 中的 enum 运算符与 debug.h. 中的 operator_str 不匹配。

PP 给 globals.h 添加运算符时还必须给 debug.h. 添加相应的串。PP 应避免产生此消息，它表示编译器错误或安装错误。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。

消息标识：INTERNAL_0689

## Error:在 TASK COMMON 指令中指定了公共块，因此必须在 COMMON 语句中指定该公共块。

如果在 CDIR$ (!DIR$) TASK COMMON 语句中指定了公共块，那么还必须在 COMMON 或 TASK COMMON 语句中声明该公共块。

消息标识：ERROR_0690

## Error:这是具有最终组件为指针的派生类型，因此不能是命名常量。

PP 命名常量不能赋予 POINTER 属性，而且不能是具有将指针作为一个组件的派生类型。

消息标识：ERROR_0691

## Ansi：在程序单元中而不在块数据程序单元中初始化命名公共块成员是非标准的。

PP 对象是由 DATA 语句或类型声明语句中的初始化值来初始化的。此对象是命名公共块的一个成员。如果对象是命名公共块的一个成员，那么它仅能在块数据程序单元中初始化。

消息标识：ANSI_0692

## Error:不能初始化空白公共块成员。

PP 对象是由 DATA 语句或类型声明语句中的初始化值来初始化的。该对象是空公共块的一个成员。那些为空公共块成员的对象不能初始化。

消息标识：ERROR_0693

## Error:此霍尔瑞斯常量大于一个字。

PP 表达式中正在使用含有比机器字所适合字符更多的霍尔瑞斯常量。在此上下文中，霍尔瑞斯常量被限制为适合机器字的字符数。霍尔瑞斯常量是 Fortran 标准的扩展。

消息标识：ERROR_0694

## Error:不能初始化 Cray 字符指针。

PP DATA 语句或类型声明语句试图初始化 Cray 字符指针。非字符 Cray 指针可以初始化，但 Cray 字符指针不能初始化。Cray 指针是 Fortran 标准的一个扩展。

消息标识：ERROR_0695

## Error:隐含 DO 变量已在一个内部循环中被用作隐含DO 变量。

PP DATA 语句可以包含以下形式的隐含 DO：

    (data_i_do_object_list, data_i_do_variable =
    scalar_int_expr, scalar_int_expr
    	[, scalar_int_expr])

PP 隐含 DO 嵌套中每个隐含 DO 的 data_i_do_variable 必须是唯一的名称。例如，以下隐含 DO 嵌套集与 Fortran 标准不一致，因为变量 K 用于多个循环中。

    DATA ((ARRAY(K,K), K = 1, 3), K = 1, 3)  /9*-1/

消息标识：ERROR_0696

## Error:Cray 指针和 Cray 指针对象必须都为公有类型或都为私有类型。

PP 编译器检测到以下情形之一：

    	Cray Pointer	Cray Pointee
    	PRIVATE      PUBLIC
    	PUBLIC       PRIVATE

PP 它们都必须具有 PUBLIC 或 PRIVATE 属性。Cray 指针是 Fortran 标准的一个扩展。

消息标识：ERROR_0697

## Ansi：完整数组的部分初始化是 Fortran 标准的一个扩展。

PP data_stmt_object_list 中命名的完整数组的每一个元素都必须有一个常量，但如果目标列表的最后一项是完整数组的引用，那么，Sun f90 就允许常量列表中值的数量少于目标的数量。PP 这是 Sun f90 继承的一个过时扩展。建议在现有代码中尽可能将其删除并在新代码中避免使用。

消息标识：ANSI_0698

## Error:DATA 目标是一个未声明数组的函数引用或数组元素引用。

PP DATA 目标（data_stmt_object 或 data_i_do_object）具有的形式为：

    name(list)

PP 遇到引用时，对于该名称，没有可用的附加信息；因此产生歧义。它似乎是函数引用或是数组元素引用（其中，数组不是在 DATA 语句前的当前作用单元中声明的）。PP DATA 目标不能是函数引用，因为它必须是变量。PP 如果在 DATA 语句中出现数组元素引用，那么该数组的属性必须已由当前作用单元中前一个规范语句建立。PP 示例 1：以下程序与标准不符，因为隐含 DO 目标数组是由 DATA 语句后面的规范语句声明为数组的。

    DATA (array(i), i = 1, 5) /5 * 1.0/
    DIMENSION array(5)

PP 示例 2：以下程序与标准不符，因为隐含 DO 目标数组是在内部子程序中声明的。作用单元中出现 DATA 语句，造成目标变量被显式声明为该作用单元的局部变量。因此，被包含的作用单元不能初始化在主作用单元中声明的变量。

    PROGRAM main
    REAL array(5)
        ...
    CONTAINS
    SUBROUTINE sub
    DATA (array(i), i = 1, 5) /5 * 1.0/
          ...
    END SUBROUTINE
    END PROGRAM

消息标识：ERROR_0699

## Error:对于内在调用没有特定的内在过程。

PP 调用内部过程名称的函数或子例程调用与任何特定的内部过程都不匹配。没有 OPTIONAL 属性的所有伪参数都必须在类型和等级方面严格一致。

消息标识：ERROR_0700

## Error:“%s”不是一个内在例程。

PP 用 INTRINSIC 属性声明的名称不是内在过程的名称。

消息标识：ERROR_0701

## 双精度复数类型不支持 –ep。

PP 只有在命令行中使用了 –dp（–dp 表示“禁用双精度”）时，才能支持双精度复数类型作为 Fortran 标准的一个扩展。如果 -ep 打开（启用双精度），那么就不支持双精度复数。可通过使用 COMPLEX(KIND=16) 指定不受 -dp/-ep 命令行选项影响的双精度复数类型。

消息标识：ERROR_0702

## Error:续行后只可跟带有“&”符号的行。

PP 在自由源格式中，以 & 符号开始的续行必须跟随着以 & 符号结束的行。

消息标识：ERROR_0703

## 内部：意外的 FLD 值。

PP 该代码要求特定的 FLD 值（如 AT_Tbl_Idx），却遇到了它不能处理的 FLD 值。PP 应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0704

## Error:“%s”不是常量，因此不能在初始化表达式中出现。

PP DATA 语句具有以下通用格式：

    data_stmt_object_list /data_stmt_value_list/

PP 其中 data_stmt_object 可以是变量或隐含 DO。在那些是变量的 data_stmt_object 中，每个下标、段下标、子串起始点和子串结束点都必须是初始化表达式。初始化是常量表达式，并且在幂为整数类型时允许求幂。常量表达式本质上是表达式，其中所有主项必须为常量或可分解为常量，并且每个运算必须是内部运算。

消息标识：ERROR_0705

## Error:此函数名不能在DATA 语句表达式中出现。

PP DATA 语句具有以下通用格式：

    data_stmt_object_list /data_stmt_value_list/

PP 其中 data_stmt_object 可以是变量或隐含 DO。在那些是变量的 data_stmt_object 中，每个下标、段下标、子串起始点和子串结束点都必须是初始化表达式。如果函数引用出现在初始化表达式中，它必须引用初始化表达式所允许的受限内在函数集中的一个函数。它不能用户定义函数的引用。PP DATA 语句隐含 DO 具有以下格式：

    (data_i_do_object_list, data_i_do_variable =
    scalar_int_expr, scalar_int_expr [, scalar_int_expr])

PP data_i_do_object 下标列表中下标的主项必须是常量或包含隐含 DO 的 DO 变量。这样的下标列表中的主项不能是内在函数或用户定义函数的引用。并且，每个 scalar_int_expr 循环控制中的每个主项都必须是常量或包含隐含 DO 的 DO 变量。

消息标识：ERROR_0706

## Error:模块过程在该作用单元的父单元不是一个模块过程。

PP 每个 module_procedure_name 在 MODULE PROCEDURE 语句都必须是可通过主机或使用关联进行存取的模块过程名称。PP 编译器在主机中发现模块过程名称，但它却不是模块过程的名称。它是变量、派生类型或名称列表组的名称。以下是编译器找到的一个示例：

    MODULE MOD
    DIMENSION MM(100)

    CONTAINS
    SUBROUTINE JOE()
    INTERFACE BAD
    MODULE PROCEDURE MM !MM is not a module
    ! procedure.It is
    ! an array.
    END INTERFACE
    END SUBROUTINE JOE
    END MODULE

消息标识：ERROR_0707

## 警告：对模块过程可能的递归引用。必须为递归引用指定 RECURSIVE。

PP 编译器在接口块内检测到的模块过程声明是在该过程本身范围内。以下示例可以阐明这一点：

    MODULE MM
    CONTAINS
    SUBROUTINE JOE
    INTERFACE GENERIC
    MODULE PROCEDURE JOE !This is a reference
    ! to the containing procedure
    END INTERFACE

    CALL GENERIC()   !This is a recursive reference,
    ! therefore JOE
    ! must be declared
    ! RECURSIVE SUBROUTINE JOE

    END SUBROUTINE JOE
    END MODULE

消息标识：WARNING_0708

## Error:DATA 隐含 DO 目标必须是一个数组元素或标量结构组件的引用。

PP DATA 语句隐含 DO 具有以下格式：

    (data_i_do_object_list, data_i_do_variable =
    scalar_int_expr, scalar_int_expr
    [, scalar_int_expr])

PP data_i_do_object 可以是数组元素、标量结构组件引用或另一个隐含 DO。如果 data_i_do 对象是结构组件引用，那么该结构或组件名称中至少应有一个具有和它关联的下标列表。

消息标识：ERROR_0709

## 警告：-dp 选项并不更改此类型。它将仍为双精度。

PP REAL*16、DOUBLE PRECISION*16 和 COMPLEX*32 不受 -dp 命令行选项影响。它们将仍为双精度类型。

消息标识：WARNING_0710

## 注意：通用内在函数的语句类型被忽略。

PP 通用内在函数名称出现在类型声明语句中。根据参数的数据类型，通用内在函数执行各种运算。特定数据类型不能赋给通用内在函数。该类型声明语句被忽略。

消息标识：CAUTION_0711

## Error:通用接口不能也是模块名，除非它在通用接口中是一个特定的名称。

PP 如果模块过程和通用接口名称相同，则必须在通用接口中将模块过程指定为一个特定的名称。以下是一个合法的示例：

    MODULE XYZ
    INTERFACE IN
    MODULE PROCEDURE IN
    END INTERFACE
    CONTAINS
    SUBROUTINE  IN()
    END SUBROUTINE IN
    END MODULE XYZ

PP 下面是一个非法示例：

    MODULE XYZ
    INTERFACE IN
    MODULE PROCEDURE NOT_IN
    END INTERFACE
    CONTAINS
    SUBROUTINE  IN()
    END SUBROUTINE IN

    SUBROUTINE DOIT()
    CALL IN()       !Illegal; the compiler cannot
    ! determine which IN to call.
    END SUBROUTINE DOIT

    SUBROUTINE  NOT_IN()
    END SUBROUTINE NOT_IN
    END MODULE XYZ

消息标识：ERROR_0712

## Error:通用接口也是一个外部过程或模块过程。它必须是通用接口中的一个特定名称。

PP 如果通用接口和外部过程（或模块过程）共享相同的名称，那么该过程就必须是通用接口中一个特定名称。如果模块过程和通用接口名称相同，则必须在通用接口中将模块过程指定为一个特定的名称。PP 以下是一个合法的示例：

    MODULE XYZ
    CONTAINS
    SUBROUTINE  IN()
    END SUBROUTINE IN

    SUBROUTINE DOIT()
    INTERFACE IN
    MODULE PROCEDURE IN
    END INTERFACE
    CALL IN()
    END SUBROUTINE DOIT
    END MODULE XYZ

PP 下面是一个非法示例：

    MODULE XYZ
    CONTAINS
    SUBROUTINE  IN()
    END SUBROUTINE IN

    SUBROUTINE DOIT()
    INTERFACE IN
    MODULE PROCEDURE NOT_IN
    END INTERFACE     !Illegal; IN not in interface
    CONTAINS
    SUBROUTINE B
    CALL IN()       !Illegal; compiler cannot
    END SUBROUTINE B! determine which IN to call
    END SUBROUTINE DOIT

    SUBROUTINE NOT_IN
    END SUBROUTINE NOT_IN
    END MODULE XYZ

消息标识：ERROR_0713

## Ansi：这是公共块名称并被声明为内在过程。这是非标准的。

PP 公共块名称被用作内在过程名称。这是 Fortran 标准的一个扩展。

消息标识：ANSI_0714

## Log_Warning：二进制输出（-eB 或 -b 文件名）禁用了汇编语言输出（-eS 或 -S 文件名）。已选定二进制文件。

PP 编译器不能同时打开汇编语言文件和二进制文件。禁用了汇编语言输出，因为命令行（-eB 或 -b filename）已要求二进制输出。编译器处理了与此类似的命令行：

    -eS -eB  file.f

PP 此警告指出 -eB 选项会覆盖 -eS 选项。

消息标识：LOG_WARNING_0715

## Ansi：这是一个外部过程或程序单元并且还是一个公共块名称。这是非标准的。

PP Fortran 标准禁止公共块名作为外部子程序名或者程序单元名使用。程序单元是一个块数据子程序、一个模块子程序或者是一个主程序。外部子程序是外部函数或子例程。

消息标识：ANSI_0716

## Log_Warning：-Ta 选项隐含了 -Ca。

PP 如果指定了 MPP 初级选项，将产生所有的 CIF 记录，即使用户只要求特定的 CIF 记录。

消息标识：LOG_WARNING_0717

## 内部：传递到例程 set_format_start_idx 的行号不是有效的行号。

PP 例程 set_format_start_idx 试图使输入行号与当前在该语句缓冲区中的行号相匹配。它找不到匹配。PP 应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0718

## 警告：整数转换或算术运算导致了整数溢出。

PP 试图计算常量表达式的值时，编译器遇到的整数值太大而不能表示。常量表达式是只包含常量的表达式，表达式的值是在编译时决定的，不是在执行时。此错误可能在中间计算（例如，加、减、乘、除或求幂）过程中出现，或者在计算过程中需要进行数据转换（例如，从实数转换为整数）时出现。

消息标识：WARNING_0719

## Error:常量表达式超过了有效范围。

PP 试图计算常量表达式的值时，编译器遇到的整数值或实数值太大而不能表示。常量表达式是只包含常量的表达式，表达式的值是在编译时决定的，不是在执行时。此错误可能在中间计算（例如，加、减、乘、除或求幂）过程中出现，或者在计算过程中需要进行数据转换（例如，从双精度转换为实数）时出现。

消息标识：ERROR_0720

## Error:表达式中检测出了为零的除数。

PP 试图计算常量表达式的值时，编译器遇到了除数为零的除法运算。常量表达式是只包含常量的表达式，表达式的值是在编译时决定的，不是在执行时。

消息标识：ERROR_0721

## Error:函数的此种使用是无效的。

PP 遇到了不带括号组的函数名。

消息标识：ERROR_0722

## Error:通用接口或内部函数的这种使用是无效的。

PP 指定通用接口名称或内部函数名称时，未带括号组。

消息标识：ERROR_0723

## Error:未知语句。应该是赋值语句，却找到其它内容而不是“=”或“=>”。

PP 编译器要求赋值语句，但在相应位置却找不到赋值或指针赋值运算符。

消息标识：ERROR_0724

## Error:模块必须以同一操作系统为目标进行编译。

PP USE 语句中所指定的模块必须以同一操作系统为目标进行编译。目标操作系统不能混合。

消息标识：ERROR_0725

## Error:此模块的模块信息文件有问题。

PP 编译器试图读写模块信息文件时收到读写错误。

消息标识：ERROR_0726

## Error:BOUNDARY 参数必须与 ARRAY 具有相同的类型和类型参数。

PP BOUNDARY 参数必须与 ARRAY 具有相同的类型和类型参数。

消息标识：ERROR_0727

## Error:至少存在一个此内过程的实际参数。

PP 至少要有一个实际参数传递给此内在过程。

消息标识：ERROR_0728

## Ansi：这不是整数类型，因此，使用 BOZ 文字常量对其初始化是不标准的。

PP Fortran 标准声明，BOZ 文字常量仅能在 DATA 语句中出现，并且仅能被用于初始化整数类型的变量。

消息标识：ANSI_0729

## 警告：带有 INTENT(OUT) 或 INTENT(INOUT) 的伪参数与一个不能被定义的实际参数进行了关联。

PP 那些是表达式、常量或向量定值下标数组等的实际参数已经与一个具有 INTENT(OUT) 或 INTENT(INOUT) 属性的伪参数进行了关联。警告发出，因为该实际参数不能被定义。

消息标识：WARNING_0730

## Error:这是用于程序单元的伪参数名，因此不能与该模块关联。

PP 在 USE 语句带来的模块中找到了用于程序单元的伪参数名。这造成名称冲突，因此是不允许的。PP 示例：

    MODULE NEW
    INTEGER ABC
    END MODULE

    SUBROUTINE XYZ(ABC)
    USE NEW          !ABC is illegal here
    END SUBROUTINE

消息标识：ERROR_0731

## Error:此名称不在该模块中。

PP 编译器不能在该模块中找到指定的名称。如果在 USE 语句中指定了名称，那么该名称就必须在模块中。

消息标识：ERROR_0732

## Ansi：使用单一的霍尔瑞斯或字符常量来初始化多个数组元素是不标准的。

在指定不带下标列表的数组时，霍尔瑞斯常量（包括字符文字格式“...”）可以初始化整数数组或实数数组的多个元素。例如，如果将数组声明为

    INTEGER a(2)

在 64 位机上，以下 DATA 语句具有相同的效果：

    DATA a /'1234567890123456'/

    DATA a /8H12345678, 8H90123456'/

以这种方式初始化数组元素是 Fortran 标准的一个扩展。它是一个过时的特性。建议在现有代码中尽可能将其删除并在新代码中避免使用。

消息标识：ANSI_0733

## 内部：create_loop_stmts 中的内部错误。

在 create_loop_stmts 中发现意外的中间文本。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0734

## Ansi：使用单一的END DO 作为多个 DO 循环的结束语句是到 Fortran 的一个扩展。

Fortran 标准将块 DO 构造定义为 DO 循环，该循环以 END DO 或 CONTINUE 语句终止，其中 DO 循环嵌套中的每个 DO 循环都必须有其各自的终止 END DO 或 CONTINUE 语句。通过允许多个 DO 循环共享单一标记为通用终止语句的 END DO，编译器扩展了标准。

这是一个过时的特性。建议在现有代码中尽可能将其删除并在新代码中避免使用。

消息标识：ANSI_0735

## Error:这是此程序单元的名称，因此不能与模块关联使用。

该程序单元的名称在由 USE 语句引入的模块中发现。这造成名称冲突。

示例：

    MODULE NEW
    INTEGER ABC
    END MODULE

    PROGRAM ABC
    USE NEW          !ABC is illegal here
    END PROGRAM

消息标识：ERROR_0736

## 内部：process_deferred_io_list 中出现内部编译器错误。

在 process_deferred_io_list 例程中，在下一个 stmt 中发现了没有 Br_Index_Opr 的 Alt_Return_Opr。这指出一个内部编译器错误条件。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0737

## Error:伪参数 X 为复数类型，因此不能出现伪参数 Y。

如果 CMPLX 内在函数的伪参数 X 是复数类型，那么不能出现伪参数 Y。

消息标识：ERROR_0738

## 警告：内在函数中不允许任何参数 – 参数被忽略。

不允许将实际参数传递给此内在函数。参数被忽略。

消息标识：WARNING_0739

## Error:IMPLICIT NONE 在局部范围指定，因此必须为语句函数指定显式类型。

指定 IMPLICIT NONE 时，所有语句函数必须设定为显式类型。

消息标识：ERROR_0740

## Error:在局部范围内指定了 IMPLICIT NONE。语句函数伪参数必须有具显式类型。

指定 IMPLICIT NONE 时，所有语句函数的伪参数必须设定为显式类型。

消息标识：ERROR_0741

## Error:IMPLICIT NONE 在主范围内指定，因此必须为语句函数指定显式类型。

当在主范围内指定了 IMPLICIT NONE 时，所有语句函数必须设定为显式类型，包括任何包含范围中的函数。

消息标识：ERROR_0742

## Error:在主机范围内指定了 IMPLICIT NONE。语句函数伪参数必须有具显式类型。

当在主范围内指定了 IMPLICIT NONE 时，所有语句函数伪参数必须设定为显式类型，包括任何包含范围中的函数。

消息标识：ERROR_0743

## Log_Warning：此命令行选项有不被支持的选项。

此硬件不支持此命令行选项。该选项被忽略。

消息标识：LOG_WARNING_0744

## Error:条件值与 SELECT CASE 语句中的条件表达式的类型不相同。

对于给定的 CASE 构造，每个 case_value 都必须和 SELECT CASE 语句所指定的 case_expr 具有相同的类型。对于字符类型，各 case_value 相互之间不必具有相同的长度，也不必与 SELECT CASE 语句中的 case_expr 具有相同的长度。

消息标识：ERROR_0745

## Error:条件值与 %d 行中的条件值相同。

对于给定的 CASE 构造，case_value_range 不能重迭；与多个 case_value_range 匹配的 SELECT CASE 语句 case_expr 值不能存在。

编译器遇到了已经在同一 CASE 构造的前一个 CASE 语句中指定的 case_value。示例：

    SELECT CASE (k)

    CASE (1)
               ...

    CASE (1) !Error; case_value 1 has
    ...    ! already been specified

    END SELECT

消息标识：ERROR_0746

## Error:条件值已经包含在 %d 行的条件值范围内。

对于给定的 CASE 构造，case_value_range 不能重迭；与多个 case_value_range 匹配的 SELECT CASE 语句 case_expr 值不能存在。

编译器遇到一个 case_value，它的值包含在同一 CASE 构造的前一个 CASE 语句所指定的 case_value_range 中。示例：

    SELECT CASE (k)

    CASE (1:10)
               ...

    CASE (3) !Error; case_value 3
    ! is contained in
    ...    ! range (1:10) in a
    ! previous CASE statement.

    END SELECT

消息标识：ERROR_0747

## Error:条件值范围中包含一个已经被条件值所指定的值。

对于给定的 CASE 构造，case_value_range 不能重迭；与多个 case_value_range 匹配的 SELECT CASE 语句 case_expr 值不能存在。

编译器遇到一个 case_value_range，它指定一个范围，其中包含的值已经由同一 CASE 构造的前一个 CASE 语句中的 case_value 指定。示例：

    SELECT CASE (k)

    CASE (5)
              ...

    CASE (1:)! Error; case_value 5
    ...     ! has already been specified

    END SELECT

消息标识：ERROR_0748

## Error:该条件值范围与条件值范围重叠。

对于给定的 CASE 构造，case_value_range 不能重迭；与多个 case_value_range 匹配的 SELECT CASE 语句 case_expr 值不能存在。

编译器遇到了一个 case_value_range，它与同一 CASE 构造的前一个 CASE 语句中指定的 case_value_range 重叠。示例：

    SELECT CASE (k)

    CASE (1:10)
             ...

    CASE (5:)! Error; the range 5:10
    ...     ! has already been specified

    END SELECT

消息标识：ERROR_0749

## Error:语句函数的实际参数数量不是标量。

语句函数中仅能使用标量伪参数和标量实际参数。

消息标识：ERROR_0750

## Error:实际参数的类型与关联伪参数的类型不一致。

语句函数的实际参数类型必须与其关联的伪参数类型一致。

消息标识：ERROR_0751

## Error:语句函数的实际参数与伪参数具有不同的类型。

语句函数的实际参数种类类型必须与其关联的伪参数种类类型一致。

消息标识：ERROR_0752

## Error:语句函数不能递归调用其本身。

语句函数不能调用其本身。

消息标识：ERROR_0753

## Error:语句函数被带有不正确的参数数量调用。

语句函数调用的实际参数数量必须与其伪参数数量相同。

消息标识：ERROR_0754

## Error:语句函数的表达式必须是标量表达式。

仅允许标量语句函数。

消息标识：ERROR_0755

## Error:表达式的类型和语句函数结果的赋值不兼容。

根据类型赋值一致性规则，语句函数表达式必须和语句函数结果兼容。

消息标识：ERROR_0756

## Error:运算符不是内在运算符。语句函数表达式中的所有运算必须为内在运算。

允许在语句函数表达式中指定重载或已定义的运算符。只允许内在运算。

消息标识：ERROR_0757

## 警告：冒号左边的值大于冒号右边的值。

如果 SELECT CASE 语句的 case_expr 的值为 c，且 CASE 选择符的格式为 low:high，则 case 是 selected if the 表达式 low .LE. c .AND. c .LE. high 为 true。被诊断的表达式的值永远不会为真，因为冒号左边的值 low 大于冒号右边的值 high。因此，这是“空”CASE 且永远不会执行 CASE 中的代码。

消息标识：WARNING_0758

## Error:这是一个过程。语句函数实际参数必须是标量数据对象。

语句函数的所有实际参数必须为标量数据对象。以下属性将非数据对象声明为过程。

    EXTERNAL
    INTRINSIC
    VFUNCTION
    NOSIDE EFFECTS

消息标识：ERROR_0759

## Error:这不是一个标量数据对象。语句函数实际参数必须是标量数据对象。

该对象不能用作语句函数的参数，因为它不是标量数据对象。

消息标识：ERROR_0760

## Error:这是一个过程名称，因此不能用作语句函数的实际参数。

语句函数的所有实际参数必须为标量数据对象。

消息标识：ERROR_0761

## 内部：io_ctl_list_semantics 中的内部错误。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0762

## 内部：没有创建名称列表描述符。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0763

## Error:SELECT CASE 条件表达式是逻辑类型，因此不能出现冒号。

CASE 选择器具有以下基本形式：

    CASE (case_value)
    CASE (case_value:)
    CASE (:case_value)
    CASE (case_value:case_value)

如果 SELECT CASE 语句的 case_expr 为逻辑类型，那么只允许第一种格式；即 CASE 选择器不能包含任何范围。

消息标识：ERROR_0764

## Error:SELECT CASE 条件表达式必须是标量。

SELECT CASE 语句具有以下格式：

    [case_construct_name:]SELECT CASE (case_expr)

case_expr 必须为整数、字符或逻辑等类型的标量。

消息标识：ERROR_0765

## Error:条件值必须是一个标量表达式。

CASE 语句具有以下格式：

    CASE (case_value)
    CASE (case_value:)
    CASE (:case_value)
    CASE (case_value:case_value)

case_value 必须为标量。

消息标识：ERROR_0766

## Error:SELECT CASE 条件表达式必须是整数、字符或逻辑类型。

SELECT CASE 语句具有以下格式：

    [case_construct_name:]SELECT CASE (case_expr)

case_expr 必须是整数、字符或逻辑类型。

消息标识：ERROR_0767

## Error:条件值必须是整数、字符或逻辑类型。

CASE 语句具有以下格式：

    CASE (case_value)
    CASE (case_value:)
    CASE (:case_value)
    CASE (case_value:case_value)

第一种格式中的 case_value 必须是整数、字符或逻辑类型。后三种格式中的每个 case_value 都必须是整数或字符类型。

消息标识：ERROR_0768

## Error:意外语法：要求某些关键字或 EOS 跟随在 END 关键字之后，但发现其它内容。

编译器正在查找跟 END 关键字之后的 EOS 或以下内容：BLOCK DATA、MODULE、PROGRAM、SUBROUTINE、FUNCTION、INTERFACE、TYPE、IF、DO、SELECT 或 WHERE。编译器既没有找到 EOS，也没有找到列表中的任何关键字。

消息标识：ERROR_0769

## Error:种类选择符表达式必须是一个标量整数初始化表达式。

可以出现具有数据类型属性的 kind_selector，如：

    INTEGER kind_selector

kind_selector 具有以下格式：

    ( [KIND=] expr)

其中 expr 必须是标量整数初始化表达式。初始化表达式本质上是由内在运算符、常量主项和/或对所选内在函数的引用而构成的表达式。该表达式必须是在编译时可以计算的合成值。有关将表达式化分为初始化表达式所必须满足的所有特性的完整说明，请参阅手册。

消息标识：ERROR_0770

## Ansi：在 DATA 语句外使用 BOZ 文字常量 Fortran 标准的一个扩展。

Fortran 标准只允许在 DATA 语句值列表中使用 BOZ 文字常量。编译器将它们看作布尔类型并在允许使用布尔类型的位置允许使用它们。

消息标识：ANSI_0771

## Error:该实际参数的等级必须与假定形伪参数的等级相匹配。

将伪参数声明为假定形数组时，和它关联的实际参数必须在类型、种类类型和形状上保持一致。形状一致意味着在每个等级中都具有相同的等级和范围。

消息标识：ERROR_0772

## Error:此实际参数登记与伪参数等级不匹配。

实际参数是数组表达式或指针时，仅能与同一等级中的数组伪参数关联。

消息标识：ERROR_0773

## Error:不适合的内在参数类型或不一致的类型。

实际参数类型的类型和/或种类类型无效。

消息标识：ERROR_0774

## 内部：在调用点进行边界扩充的过程中，范围暂存器出现意外 IR。

进行边界扩充的过程中，如果范围是一个暂存器，那么 IR 就被假定为 tmp = max(tmp,0)。编译器检测到与此不同的内容：

消息标识：INTERNAL_0775

## 内部：“cif_stmt_type_rec”被传递了一种非匹配的语句类型。

cif_stmt_type_rec 可能正在试图处理一个映射至 enum 值 CIF_Stmt_Type_Error 的语句。CIF 精确语句类型的数组可能与标准语句类型数组不匹配。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0776

## Error:PRESENT 内在函数的实际参数必须是一个可选的伪参数。

传递给 PRESENT 内在函数的伪参数必须是具有 OPTIONAL 属性的伪参数。

消息标识：ERROR_0777

## Ansi：此格式说明符是 Fortran 标准的一个扩展。

Fortran 标准允许格式说明符是缺省字符表达式、FORMAT 语句标签、星号 (*) 或者标量缺省整型变量。编译器允许其它格式作为扩展。包括整型及实型完整数组以及霍尔瑞斯或布尔常量。这些扩展被解释，仿佛它们包含霍尔瑞斯数据。

消息标识：ANSI_0778

## Error:LOC 函数参数必须是变量、数组或数组元素。

LOC 内在函数参数必须是变量、数组或数组元素。LOC 内在函数是 Fortran 标准的一个扩展。

消息标识：ERROR_0779

## Error:已在先前的派生类定义中定义了语句标签。

派生类型定义是一个 Fortran 作用单元。给定的语句标签仅能在作用单元中定义一次。在当前派生类型定义中发现先前的语句标签定义。

消息标识：ERROR_0780

## Error:子串的开始或结束值超过了所定义的范围。

字符子串引用的子串指示器不当。在以下字符子串引用中，子串指示器 begin 和 end 指示了子串的开始和结束字符的位置：

    CHAR ([begin]:[end])

如果子串长度大于 0，那么 begin 和 end 都必须大于 0 并小于或等于实体中字符的数量，CHAR。如果 end 小于 begin，那么子串长度为 0。

消息标识：ERROR_0781

## 内部：列表入口出现字段变量问题。

列表入口使用不正确。这可能是 IL_ARG_DESC_VARIANT 为真时使用了字段 IL_PREV_LIST_IDX 或 IL_ARG_DESC_VARIANT 为假时使用了 IL_ARG_DESC_IDX 的结果。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0782

## Error:TARGET 参数必须具有 TARGET 属性或 POINTER 属性。

ASSOCIATED 内在函数的第二个参数必须是指针或目标。

消息标识：ERROR_0783

## Error:此内在函数的第一个参数必须具有 POINTER 属性。

此参数必须是指针。

消息标识：ERROR_0784

## Error:自动任务指令只可用在由 PARALLEL/ENDPARALLEL 指令所约束的平行区域内部。

下列自动任务指令之一没有在平行区域或保护区域内。以下指令只可用在由 PARALLEL/ENDPARALLEL 指令所约束的平行区域内部。

    CASE
    ENDCASE
    DO PARALLEL
    END DO

消息标识：ERROR_0785

## Error:当与具有 INTENT(OUT) 或 INTENT(INOUT) 的伪参数关联时，实际参数必须是可定义的。

具有 INTENT(OUT) 或 INTENT(INOUT) 属性的伪参数仅能和可定义的实际参数关联。将表达式、常量、或向量下标数组段和伪参数进行关联是一个错误。将 INTENT(IN) 伪参数用作与此类伪参数关联的实际参数也是一个错误。

消息标识：ERROR_0786

## Ansi：内在过程“%s”是 Fortran 标准的一个扩展。

此内在过程是 Fortran 标准的一个扩展。

消息标识：ANSI_0787

## Log_Warning：如果指定 -G0（全调试），将关闭所有优化。

使用 -G0 调试选项要求关闭所有优化。此编译将被处理，仿佛命令行中 -O0 被指定。通过不同级别的 -G 选项打开优化调试。

消息标识：LOG_WARNING_0788

## Error:条件值范围缺少两个条件值。

当 CASE 语句 case_selector 的 case_value 范围包含冒号时，case_value_range 必须具有以下格式之一

    case_value:
    或   :case_value
    或   case_value:case_value

遇到了缺少左右 case_value 的 case_value_range。

消息标识：ERROR_0789

## 警告：未知的编译器指令或语法错误。

遇到了拼写错误或无法识别的编译器指令。

消息标识：WARNING_0790

## Error:这不是一个模块，因此不能作为模块名在 USE 语句中指定。

在此范围内，USE 语句中指定为模块名的名称已不作为模块名。module_name 仅能是模块名。以下是该错误的示例。

    PROGRAM ABC
    USE MOD_M ::BAD => R !New local variable, BAD
    USE BAD               !Illegal - BAD is a local
    !    variable in this scope.
    END PROGRAM

消息标识：ERROR_0791

## Error:这是所编译模块的名称。不能在 USE 语句中指定。

模块不能调用其自身，如同本例：

    MODULE MODULE_M
    USE MODULE_M   !This is illegal
         ...
    END MODULE

消息标识：ERROR_0792

## Error:模块在模块中没有声明公共实体，因此不能找到在唯一列表中指定的名称。

USE 语句中指定的模块为空，意味着找不到 only_list 所指定的名称。该模块似乎是空的，原因是所有的模块实体都为私有的、模块有编译错误、或者包含模块信息的文件被破坏。

消息标识：ERROR_0793

## Error:CDIR$ INTEGER= 必须在程序单元之前或必须在该程序单元内任何语句之前。

The INTEGER= 在编译器遇到声明语句或可执行语句之前编译器指令必须出现。这意味着它可以在该程序单元之前或紧跟在该程序单元标题语句之后。以下示例显示两个被允许的上下文。接口体、内部过程或模块过程中不允许 INTEGER= 编译器指令。

    CDIR$ INTEGER = 64
    integer i
    i = 10
    end

    subroutine sub
    CDIR$ INTEGER = 46
    i = 10
    end

消息标识：ERROR_0794

## 警告：只允许 CDIR$ 在程序单元内。

编译器指令处在程序单元之外。该指令必须在该程序单元内指定。

消息标识：WARNING_0795

## Error:在 IVDEP 指令中为 SAFEVL= value 指定的值必须是标量整型常量。

IVDEP 编译器指令的安全向量长度必须是标量整型常量表达式，这样编译器才能在编译时对其计算。

消息标识：ERROR_0796

## Log_Warning：命令行具有不被支持的选项。

此硬件不支持此命令行选项。该选项被忽略。

消息标识：LOG_WARNING_0797

## Error:DO ALL 指令有意外参数或工作分配。

该 DO ALL 指令允许以下参数和工作分配：

    IF(expr)
    SHARED(variable_list)
    PRIVATE(variable_list)
    AUTOSCOPE
    CONTROL(variable_list)
    SAVELAST
    MAXCPUS(n)

    SINGLE
    CHUNKSIZE(n)
    NUMCHUNKS(m)
    GUIDED [vl]
    VECTOR

消息标识：ERROR_0798

## Ansi：将此字符用作续行字符是 Fortran 标准的一个扩展。

在固定源格式中，允许将 Fortran 字符集之外的字符用作续行指示符。这是 Fortran 标准的一个扩展。

消息标识：ANSI_0799

## Error:只能在 DO ALL 指令中指定一个工作分配。

在 DO ALL 指令中有一个以上工作分配是不合法的。

消息标识：ERROR_0800

## 警告：不支持的编译器指令。

编译器遇到了一个可识别但却不支持的编译器指令。出现这种情况的原因是该编译器指令与支持的硬件不相关或者将来的版本才会支持该编译器指令。

消息标识：WARNING_0801

## Error:变量子对象不允许作为此任务编译器指令参数的参数。

任务编译器指令定义平行区域的范围或上下文时，该参数必须是全程变量，而不能是变量子对象。以下代码碎片不被允许。

    TYPE X
    INTEGER I
    ENDTYPE

    TYPE(X) ::K

    CMIC$ DO ALL SHARED(K%I)

消息标识：ERROR_0802

## Error:任务指令参数 IF 的表达式必须是一个标量逻辑表达式。

任务编译器指令 DO ALL 和 PARALLEL 的 IF 参数要求标量逻辑表达式。

消息标识：ERROR_0803

## 注意：这不是一个变量，并且在此指令的列表中将被忽略。

任务编译器指令语句中的 SHARED、PRIVATE 或 CONTROL 列表中有非变量的对象。它将被忽略。

消息标识：CAUTION_0804

## Error:对象被同时声明为 SHARED 和 PRIVATE。

在任务指令语句中，一个变量同时列在 PRIVATE 和 SHARED 变量列表中。

消息标识：ERROR_0805

## Error:任务指令的参数必须是一个标量整型表达式。

任务指令中赋给 MAXCPUS、CHUNKSIZE、NUMCHUNKS 或 GUIDED 参数或者工作分配的参数都必须为标量整型表达式。

消息标识：ERROR_0806

## Error:SHAPE 参数必须是一个恒定大小的一级数组，元素少于或等于 7 个。

RESHAPE 内在函数的 SHAPE 参数必须是一级数组，且其中的元素不能多于 7 个。

消息标识：ERROR_0807

## Error:DO PARALLEL 指令未预料的工作分配。

以下是用于 DO PARALLEL 编译器指令的允许工作分配：

    SINGLE
    CHUNKSIZE(n)
    NUMCHUNKS(m)
    GUIDED [vl]
    VECTOR

消息标识：ERROR_0808

## Error:PARALLEL 编译器指令未预料的参数。

以下是用于 PARALLEL 指令的允许参数。

    IF(expr)
    SHARED(variable_list)
    PRIVATE(variable_list)
    AUTOSCOPE
    CONTROL(variable_list)
    SAVELAST
    MAXCPUS(n)

消息标识：ERROR_0809

## 内部：这有错误线性类型。

该给定对象的线性类型为 Err_Res。这需要设置为正确的线性类型，以便能够分配存储。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0810

## Error:case-value 表达式必须为初始化表达式。

在以下格式的 CASE 语句中：

    CASE (case_value_range_list)

case_value_range 必须具有以下格式之一：

    case_value
    case_value:
    :case_value
    case_value:case_value

每个 case_value 都必须是标量整型、字符或逻辑初始化表达式。case_value 还必须与对应的 SELECT CASE 语句中的表达式具有相同的类型。字符或逻辑初始化表达式与字符或逻辑常量表达式是相同的。整型初始化表达式是其中求幂运算仅允许使用整数幂的整数常量表达式。

消息标识：ERROR_0811

## Error:此 ENDCASE 自动任务指令没有匹配的 CASE 指令。

ENDCASE 任务指令仅能用于关闭由 CASE 指令分隔的并行区域集。

消息标识：ERROR_0812

## Error:此 END DO 指令没有匹配的 DO PARALLEL 指令。

END DO 自动任务指令仅能用在 DO PARALLEL 指令之后。将两条指令置于独立的平行区域中可能会产生该错误。

消息标识：ERROR_0813

## Error:此 DO ALL 自动任务指令已经在平行区域中。

DO ALL 指令创建一个平行区域，该平行区域是下一 DO 循环体。不能将它用于另一个平行区域。

消息标识：ERROR_0814

## Error:GUARD 区域未预料的嵌套或重叠。

由 GUARD/ENDGUARD 指令对保护的区域不能重叠或嵌套。如果在 ENDGUARD 之前遇到了两个或多个 GUARD 指令就将发出此消息。

消息标识：ERROR_0815

## Error:匹配的 GUARD/ENDGUARD 指令必须都具有相同的标志参数，或者都没有参数。

如果 GUARD 或 ENDGUARD 自动任务指令提供了互斥标志，必须也为匹配的指令指定相同的值。

消息标识：ERROR_0816

## Error:此 ENDGUARD 指令没有匹配的 GUARD 指令。

遇到 ENDGUARD 自动任务指令而没有匹配的 GUARD 指令。

消息标识：ERROR_0817

## Error:PARALLEL 指令不能用于其它平行区域之内。

标记平行区域入口的 PARALLEL 自动任务指令不能用于另一平行区域之内。

消息标识：ERROR_0818

## Error:此 END PARALLEL 指令没有匹配的 PARALLEL 指令。

在同一作用单元内，END PARALLEL 自动任务指令仅能用于 PARALLEL 指令之后。

消息标识：ERROR_0819

## Error:在前一平行区域结束之前应该有 END CASE 指令。

遇到结束平行区域的 END PARALLEL 自动任务指令。此区域内有 CASE 指令，但没有 END CASE 结束指令。

消息标识：ERROR_0820

## Error:在平行区域内对内部过程的调用是非法的。

在平行区域内不能对内部函数或子例程执行调用。其中包含 PARALLEL/ENDPARALLEL 指令绑定的区域或 DO ALL 循环主体内的区域。

消息标识：ERROR_0821

## Error:应该有自动任务指令。

在进入或终止范围前，所有平行区域和保护区域必须终止。在平行区域或保护区域中，如果遇到 CONTAINS 语句或 END、END FUNCTION、END SUBROUTINE 等语句，则出错。

消息标识：ERROR_0822

## Error:两个不同的公共块相互等价。

用户已尝试通过 EQUIVALENCE 语句将两个不同的公共块覆盖。这是非法的。例如：

    PROGRAM BAD
    COMMON /ONE/ A,B,C
    COMMON /TWO/ D,E,F

    EQUIVALENCE(A,D) !非法
    END

消息标识：ERROR_0823

## 内部：属性索引的 pdcs 符号表索引为 0。它必须为有效索引。

执行了对 PDGCS 接口的调用，此调用要求有效的 PDGCS 符号表索引作为它的一个参数。它必须是有效索引，但编译程序检测到 NULL 索引。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0824

## 警告：被初始化的对象不是在此块数据程序单元中声明的任何公共块的成员。

使用块数据程序单元为命名公共块中的数据对象提供初始值。通过扩展，空白公共共中的对象也可以在块数据程序单元中初始化。

被初始化的对象不是被编译的数据块程序单元中声明的任何公共块（命名或空白）的成员。因为对象不是公共块的成员，所以其初始化在块数据子程序外无效。应该将初始化删除或使此项目成为公共块（最好是命名）的成员。

消息标识：WARNING_0825

## Error:同一公共块中的两个不同对象是相互等价的。

不能覆盖同一公共块内的两个不同对象，以避免它更改公共块的存储序列。示例：

    PROGRAM BAD
    COMMON // A,B,C
    EQUIVALENCE (A,C)  !This is illegal
    END

消息标识：ERROR_0826

## Error:在通过隐式或类型语句定义类型前，它用于表达式中，因此其类型是假定的。

在表达式中使用对象时，如果此对象是首次引用，则隐式定义其类型。只有对象与此类型相符时，接下来才能在类型声明语句中定义此对象的类型。

示例：

    DIMENSION ARRAY(K)
    REAL K          !非法

K 只能被定义为整型，因为它在 DIMENSION 语句中被隐式定义为整型。并且，如果在隐式语句前引用可能复位其类型的对象，则保留此对象的原始隐式类型。

消息标识：ERROR_0827

## 内部：folder_driver 中不支持的运算符。

内部编译器错误。已用无效运算符调用表达式文件夹的驱动程序。

消息标识：INTERNAL_0828

## Error:数组构造函数中的所有 ac 值表达式必须具有相同的类型和类型参数。

遇到与其它元素具有不同类型或种类类型的数组构造函数的元素。

消息标识：ERROR_0829

## Error:调用此内在过程时，只能存在一个参数或不能存在参数。

调用此特定内在过程时，只能存在一个参数或不能存在参数。

消息标识：ERROR_0830

## Error:此下标的值小于此声明的下界。

下标值必须大于或等于声明的相应维数下界。

消息标识：ERROR_0831

## 内部：编译器已检测到跟随范围的局部名称表。

执行 use_stmt_semantics 时，假设它工作在当前范围，并且该局部名称表创建于局部名称表的末尾。编译器检测到跟随此范围局部名称表入口的另一范围的局部名称表入口。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0832

## Error:此内在过程的参数必须是可分配数组。

此内在过程的实际参数必须是可分配数组。

消息标识：ERROR_0833

## Error:初始化表达式值的形式与命名常量的形式不匹配。

初始化表达式结果值的形式与相应命名常量的形式必须匹配。

消息标识：ERROR_0834

## Error:用值确定的数组表达式对标量命名常量初始化无效。

仅能将标量值赋予标量命名常量。

消息标识：ERROR_0835

## 内部：编译器暂存器没有分配给它的存储块。

所有的编译器暂存器被创建时必须有分配给它们的存储块。存储器偏移分配期间，编译器在 pass2 语义末尾检测到没有存储块的编译器暂存器。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0836

## Ansi：非标量的隐含 DO 变量是 Fortran 标准的一个扩展。

DATA 语句或数组构造函数中隐含 DO 列表包含一个不是标量的隐含 DO 循环控制变量。

DATA 语句隐含的 DO 具有以下格式：

    (data_i_do_object_list, data_i_do_variable =
    scalar_int_expr, scalar_int_expr
    	[, scalar_int_expr])

数组构造函数隐含 DO 具有以下格式：

    (ac_value_list, ac_do_variable =
    scalar_int_expr, scalar_int_expr
    [, scalar_int_expr])

作为对解释请求的反应，Fortran 标准的更正扩展了作为语句实体的隐含 DO 循环控制变量（I/O 隐含的 DO 变量不是语句实体）的规则。本质上讲，它说明在包含 DATA 语句或数组构造函数的作用单元中，语句实体名可以和公共块名或整型标量名相同。因此，语句实体名不能和以下名称相同：外部过程、内部过程、过程模块、命名常量、构造名、通用名、派生类型名和数组等。同样，因为它必须为整型，所以它的名称也不能和声明为非整型的实体相同。

通过允许 data_i_do_variable 或 ac_do_variable 具有和整数数组相同的名称，Sun f90 扩展了此标准。

消息标识：ANSI_0837

## Error:类型字符的数组构造函数值都必须具有相同的长度。

数组构造函数值必须都具有相同的类型和参数类型。它包括字符长度。

消息标识：ERROR_0838

## 内部：decl_semantics 的假定长度字符边界入口无效。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0839

## Error:它是子串而不是声明的字符类型，或者对象为下标对象而不具有维数。

用户尝试与未正确声明的变量等价。子串对象必须是字符类型，而且下标对象必须是数组。

消息标识：ERROR_0840

## Error:段下标三元组的开始值小于声明的下界。

在段下标三元组中，开始值必须大于或等于声明的数组下界。例如，如果数组声明如下：

    INTEGER  array(10)

引用 ARRAY 的段下标三元组的开始值必须等于或大于 1。

消息标识：ERROR_0841

## Error:类型声明语句使用的初始化表达式必须是常量表达式。

在类型声明语句中用于初始化数据对象的表达式必须计算为常量值。

消息标识：ERROR_0842

## Error:此对象的数据类型与此初始化赋值的数据类型不兼容。

结果，此变量用初始化表达式求出的值定义。这必须满足 Fortran 标准中定义的内部赋值规则。指定变量的类型和值的类型不满足内部赋值的规则。

消息标识：ERROR_0843

## Error:具有值确定的数组表达式的标量变量“%s”的初始化无效。

仅能将标量值赋予标量变量。

消息标识：ERROR_0844

## Error:初始化表达式的形式与变量的形式不匹配。

初始化表达式的形式与相应变量的形式必须匹配。

消息标识：ERROR_0845

## 内部：存储块应在局部范围的存储块表中，但是不在。

转换到 PDGCS 期间，send_stor_blk 找到和主机关联的静态存储块，而在局部范围中没有存储块。所有这些和主机关联的存储块应该在 attr_link_resolution 期间已进入局部存储块。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0846

## 内部：“%s”没有存储块。

每个非常量数据对象都应该有赋值给它的存储块。如果是接口块，必须在 decl_semantics 的末尾赋值存储块。如果不是接口块，必须在将此对象通过接口发送到 PDG 时赋值存储块。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0847

## Error:伪参数比实际参数长。

用字符类型的实际参数引用语句函数，此函数的长度比它在语句函数定义中关联伪参数的长度要短。字符类型的实际参数的长度必须大于或等于关联伪参数的长度。

消息标识：ERROR_0848

## Error:段下标三元组的开始值大于声明的上界。

在段下标三元组中，开始值必须小于或等于声明的数组上界。例如，如果数组声明如下：

    INTEGER  array(10)

引用 ARRAY 的段下标三元组的开始值必须等于或小于 10。

消息标识：ERROR_0849

## 内部：它是主机关联并且在栈中，但不在主机关联的栈存储块中。

final_decl_semantics 期间，编译器找到主机关联的对象，但此对象不是主机关联的存储块。所有主机关联的栈变量都必须在主机关联的栈存储块中。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0850

## Error:任务公共块成员不能是初始化的数据。

标明的对象被声明为 TASK COMMON 块的成员，因而不能将它初始化。

消息标识：ERROR_0851

## 内部：主机关联的对象必须由包含的过程引用或定义。

转换到 PDGCS 期间，发现主机关联的伪参数或变量没有设置 AT_REF_IN_CHILD 或 AT_DEF_IN_CHILD 标志。要成为主机关联，对象必须由包含的过程引用或定义。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0852

## Error:目标必须与指针赋值语句中的指针具有相同的字符长度。

用于指针赋值语句中的目标和指针的参数类型必须一致。如果目标和指针是字符类型，还要包括字符长度。这也适用与指针组件相对应的结构构造函数的表达式。

消息标识：ERROR_0853

## Error:编译器不能打开文件，它可能包含所用模块的有关信息。

编译器不能打开用于 USE 语句处理的指定模块文件。检查文件和目录的权限。如果是非 Cray Research 系统，编译器可能会试图打开 .M 文件。此文件在命令行上被指定为 -p x.o。

消息标识：ERROR_0854

## Error:编译器已检测到模块中有错误。将不会为此模块创建模块信息文件。

编译器检测到模块中有错误；因此将不会为此模块创建模块信息文件。这些错误可以导致模块信息文件中的信息不可靠。

消息标识：ERROR_0855

## Error:DO 循环迭代计数超过编译器的迭代限制。

DO 语句指定了超出目标机器所允许最大值的迭代计数（完成循环的次数）。

对于以下语句，计算出的迭代应为 (end - start + inc) / inc

    DO [label] [,] do_variable = start, end [, inc]

消息标识：ERROR_0856

## 内部：DO 循环迭代计数计算失败。

编译器尝试在编译时（这时开始、结束和增量值都是常量或都是常量表达式）计算 DO 循环或隐含的 DO 迭代计数。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0857

## Error:具有 SAVE 属性的对象不能与公共块中的对象等价。

用户尝试将保存的对象等价于公共块。

消息标识：ERROR_0858

## Error:变量子对象在 SUPPRESS 指令中无效。

SUPPRESS 指令中仅允许变量名。不允许结构组件、数组元素或数组段和字符子串。

消息标识：ERROR_0859

## Error:此内在过程不能作为实际参数传递。

此内在过程名不能在实际参数列表中。

消息标识：ERROR_0860

## 内部：错误的 IR。

结构不适当的内部文本。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0861

## Error:此对象的存储顺序已通过等价被改变。

通过某种方式将对象等价，用户更改了此对象的存储顺序。例如：

    DIMENSION IA(10)
    COMMON /AA/ A,B,C,D,E,F,G,H,I,J,K
    EQUIVALENCE (IA(1), A)
    EQUIVALENCE (IA(2), C) !Illegal; changes order of IA
    END

消息标识：ERROR_0862

## Error:它已被函数字符长度表达式引用，因此不能以此方式声明。

编译器检测到对象的使用和声明之间有冲突。声明的对象被函数字符长度表达式引用，这样就禁止将它声明为以下项目：

    Cray 指针
    Cray 指针对象
    Cray 字符指针对象
    函数结果
    派生类型
    名称列表组
    构造名
    交替函数入口
    subroutine

消息标识：ERROR_0863

## Error:它已被函数字符长度表达式引用，因此不能是子例程。

对象被函数字符长度表达式引用，这样就禁止它作为接口块中的子例程或将它用作子例程。

消息标识：ERROR_0864

## Log_Warning：检测到内联选项冲突。已选定非自动模式。

在命令行中既指定 -O inline[0-3] 又指定 -I 文件名后，就会发布此消息。已选定非自动内联。

消息标识：LOG_WARNING_0865

## Error:函数字符长度表达式引用“%s”，因此不能用作派生类型名称。

编译器检测到此对象使用之间的冲突。声明的对象被函数字符长度表达式引用，这样就禁止将它用作派生类型名称。

消息标识：ERROR_0866

## 警告：在模块中，此模块没有声明的公共对象，因此没有可用于与此模块关联的对象。

USE 语句中指定的模块显然为空。这可能是由以下一种原因造成的：
-- 模块在其规范部分不包含声明。
-- 模块中的一切均被声明为私有的。
-- 模块有编译错误。

消息标识：WARNING_0867

## Error:这是用于常量表达式，因此必须是常量。

此表达式必须是常量初始化表达式。表达式引用的每个标识符都必须在此表达式前声明为常量。

消息标识：ERROR_0868

## Error:它已被定义类型，但是此内在过程与某个子例程的名称相同，而此子例程不能被定义类型。

用 INTRINSIC 属性指定的名称是内在子例程。子例程不能被定义类型。示例：

    REAL, INTRINSIC ::DATE_AND_TIME

DATE_AND_TIME 是内在子例程。子例程不能被定义类型，因此这不是有效的语句。

消息标识：ERROR_0869

## Error:此内在调用在规范表达式中无效。

此规范表达式中包含对内在函数的引用，这是规范表达式不允许的。内在函数必须要有标量整数结果。

消息标识：ERROR_0870

## 内部：语句标题的字段索引到自身。

语句标题的连接出错。指定语句的标题通过 SH_NEXT_IDX 域或 SH_PREV_IDX 域索引到自身。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0871

## Error:此隐含 DO 缺少隐含 do 对象列表。

在数组构造函数内或 I/O 列表中遇到隐含 DO，而它没有对象列表。以下是不允许的隐含 DO 的示例。

    PRINT *, (I=1,10)

消息标识：ERROR_0872

## 内部：此长度暂存器仅能具有一个与之关联的语句。此语句具有多个语句标题。

此消息是从 insert_sh_after_entries 发布的。编译器试图将长度边界更改为 length = 0，但此长度边界有多个语句标题。这种情况不应发生。仅有实际边界入口才能有多个语句标题。长度和范围应该仅是一个长度语句。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0873

## Error:编译器指令标识的参数必须为字符文字。

在 CDIR$ 标识行中遇到了除字符文字常量外的内容。

消息标识：ERROR_0874

## Error:此实际参数不能为可选的伪参数。

特定的实际参数在此上下文中不能为可选的伪参数。

消息标识：ERROR_0875

## Error:它具有 AUXILIARY 属性，而且在模块的规范部分中，因此它必须在公共块中。

AUXILIARY 属性是 Fortran 标准的一个扩展。仅有辅助存储块为公共块时，才能在模块的规范部分中指定这些存储块。

消息标识：ERROR_0876

## Log_Warning：-u 选项被忽略，因为它不是编译器的 DEBUG 版本。

-u 选项用于调试编译器，而且仅有 DEBUG 编译器才有此选项。

消息标识：LOG_WARNING_0877

## 注意：此名的模块已直接或间接地使用关联到此范围内。

模块名为全局名称，并且按照定义，所有的全局名称必须是唯一的。编译器检测到在此范围内有多个具有相同名称的模块，假定它们都是同一模块。这有可能发生，因为模块可以直接或间接地使用关联到作用单元中。例如：

    MODULE ABC
    INTEGER I
    END MODULE

    MODULE CDE
    USE ABC
    END MODULE

    PROGRAM BBB
    USE CDE
    USE ABC  !ABC is already in this scope via CDE
    END MODULE

消息标识：CAUTION_0878

## Error:bloc 或 eloc 变量不能是 BUFFER I/O 语句中的派生类型。

因为 I/O 库必须在 BUFFER IN 和 BUFFER OUT 操作中进行显式类型转换，所以不支持派生类型的开始 (bloc) 和结束 (eloc) 变量。

    BUFFERIN (id,m) (bloc,eloc)
    BUFFEROUT (id,m) (bloc,eloc)

消息标识：ERROR_0879

## Error:运算符不是内在运算符。规范表达式中的所有运算都必须为内在运算。

规范表达式中的所有运算都必须为内在运算。规范表达式不能包含定义的运算符或重载运算符。

消息标识：ERROR_0880

## Error:DIM 的值必须为：1 <= DIM <=（MASK 等级）。

DIM 参数的值必须为 >= 1 或 <= MASK 的等级。

消息标识：ERROR_0881

## Error:派生类型具有私有组件，这意味着组件名称不能被引用。

在模块中声明派生类型时，组件必须声明为私有。这意味着任何使用关联此派生类型的过程都无权使用组件名称或派生类型的内部结构。

消息标识：ERROR_0882

## Error:派生类型具有私有组件，因此不能为此类型定义结构构造函数。

在模块中声明派生类型时，组件必须声明为私有。这意味着任何使用关联此派生类型的过程都无权使用组件名称或派生类型的内部结构。不能使用派生类型的结构构造函数，因为派生类型的内部结构是未知的。

消息标识：ERROR_0883

## 内部：Verify_interface 在伪参数过程列表中已找到错误的伪参数。

Verify_interface 预期伪参数都应该是 Data_Objs 或 Pgm_Units。它在列表中找到了其它内容。它替代了 printf 语句“verify_interface 中的伪参数不是数据或程序”。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0884

## Log_Warning：内联是一个延迟的执行。

今后的版本中将实现内联。

消息标识：LOG_WARNING_0885

## Log_Warning：此调试级别将在今后的版本中实现。

-G 2 和 -G 3 调试级别选项将在今后的版本中实现。

消息标识：LOG_WARNING_0886

## Log_Warning：根据调试级别，优化级别应该各不相同。

对于调试级别，优化级别设置得太高。使用 -O 命令行选项降低此优化级别。

消息标识：LOG_WARNING_0887

## Error:如果 ARRAY 参数为派生类型，则必须有 BOUNDARY 参数。

如果 ARRAY 为派生类型，则必须有 BOUNDARY 参数。

消息标识：ERROR_0888

## Error:不能请求假定大小数组的上界或范围。

不允许为假设大小的数组请求上界或最后维数的范围。

消息标识：ERROR_0889

## Error:这是具有 INTENT(IN) 的伪参数，因此不能被定义。

当用 INTENT(IN) 指定伪参数时，它或它的子对象都不能被定义。

消息标识：ERROR_0890

## 内部：属性没有 TYPE。它应有类型，因为它是一个 Data_Obj。

每个 Data_Obj 都应有类型。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0891

## 注释：H 编辑描述符是一个废弃特征。

Fortran 标准建议使用字符常量编辑描述符，而不是使用 H 编辑描述符。

废弃特征是 FORTRAN 77 的多余特征，在 Fortran 中还有更好的方法。ANSI Fortran 委员会建议程序员在新程序中使用首选方法并将现有代码转换为首选方法。如果在 Fortran 程序中废弃特征的使用已经不重要，将来的 Fortran 标准委员会考虑将其从此标准中删除。

消息标识：COMMENT_0892

## 内部：入口字段必须都设置为合法值。设置一个字段并清除其它字段。

符号表中的表索引字段取决于字段描述符，因此我们知道索引所在的表。检测到的带有 Null_Idx 字段描述符的索引。相关字段是

    ATD_FLD	ATD_CONST_IDX
    ATD_FLD	ATD_TMP_IDX
    BD_LEN_FLD	BD_LEN_IDX
    BD_LB_FLD	BD_LB_IDX
    BD_UB_FLD	BD_UB_IDX
    BD_XT_FLD	BD_XT_IDX
    BD_SM_FLD	BD_SM_IDX

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0893

## Error:模块有编译错误，因此通过 USE 语句从模块获得的声明可能不完全。

指定的模块是在此编译单元中，但它有编译时间错误。从此模块中获得的声明可能是无效的。重新编译引用模块的模块和过程。

消息标识：ERROR_0894

## 内部：常量构造函数中遇到的内在运算符没有文件夹。

此内在运算符没有文件夹，但它是在常量构造函数中。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0895

## Error:BUFFER I/O 语句中 bloc 和 eloc 的数据项长度必须相等。

对于 BUFFER IN 和 BUFFER OUT 的 bloc 和 eloc 参数，仅允许一定的数据类型组合。允许的组合如下：

    实数 - 实数
    整数 – 整数
    逻辑类型 - 逻辑类型
    整数 – 实数
    逻辑类型 – 整数
    逻辑类型 – 实数
    双精度 – 双精度
    双精度 – 复数
    复数 - 复数
    字符 – 字符

    BUFFERIN (id,m) (bloc,eloc)
    BUFFEROUT (id,m) (bloc,eloc)

消息标识：ERROR_0896

## Error:在 WHERE 块内或在 WHERE 语句中不允许调用 VFUNCTION。

在 WHERE 屏蔽下，编译器扩展 VFUNCTION 不支持调用。

消息标识：ERROR_0897

## Error:它在模块中被声明为标量变量，因此不能用作外部函数名。

在模块中已声明对象时，它的属性即完成。它的属性不能由另一个声明语句或将其用作外部函数调用来重新指定。下面的示例说明了此问题：

    MODULE M
    INTEGER I        !I is a scalar variable
    END MODULE

    SUBROUTINE P2()
    USE M
    II = I(6)        !Illegal reference of I
    END SUBROUTINE

消息标识：ERROR_0898

## Ansi：使用制表符是 Fortran 标准的一个扩展。

使用制表符允许作为 Fortran 标准的一个扩展。

消息标识：ANSI_0899

## Ansi：在标识符中使用“@”字符是 Fortran 标准的一个扩展。

使用字符 @ 允许作为 Fortran 标准的一个扩展。

消息标识：ANSI_0900

## Ansi：在标识符中使用“$”字符是 Fortran 标准的一个扩展。

在标识符中使用“@”字符是 Fortran 标准的一个扩展。

消息标识：ANSI_0901

## 内部：char_len.fld 在 create_runtime_array_constructor 中为 Null_Idx。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0902

## Ansi：具有不同长度的定长字符数组构造函数值是非标准的。

作为 Fortran 标准的一个扩展，允许字符类型数组构造函数具有不同长度的字符值。仅在长度为常量时才允许。最长的定长长度被选为数组构造函数元素的长度。所有短的 ac_values 都被填充到此长度。

消息标识：ANSI_0903

## 内部：常量构造函数中的 Call_Opr 不是一个内在过程。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0904

## Error:段下标三元组产生了一个大于所声明上界的下标值。

在一个下标为三元组下标的段中，每个下标值都必须大于或等于数组声明的下界，或者小于或等于数组声明的上界。例如，如果数组声明如下：

    INTEGER  array(10)

每个引用 ARRAY 的段下标三元组的下标值必须等于或大于 1 并且等于或小于 10。

消息标识：ERROR_0905

## Error:DATA 语句值列表中的结构构造函数必须代表常量值。

在DATA 语句值列表中，每个结构构造函数的组件必须是初始化表达式。

通常，初始表达式的每个主项必须为常量（命名常量或文字常量）或常量的子对象。同时，对于主项必须为特定内在函数或常量表达式的数组构造函数的情况进行限制。

因为 DATA 语句值是结构构造函数，所以它的每个组件必须服从初始化表达式的规则。因此，例如，在 DATA 语句值列表中，包含变量的结构构造函数不能是常量值，从而不能是初始化表达式。

消息标识：ERROR_0906

## Error:所有边界和种类选择器规范表达式都必须是标量。

在边界表达式或种类选择符表达式中，检编译器测到非标量表达式。边界表达式用于声明数组维数大小和字符长度，并且必须始终为标量和整数类型。种类选择符表达式必须始终是标量整型常量，并且用于声明类型的种类。

消息标识：ERROR_0907

## 注意：此整型常量太大而不能用于 46 位乘除。

如果在编译器中隐藏了此值，在 46 位的乘或除中使用此值可能产生浮点异常。当常量或超过 46 位最大值的变量，作为实际参数传递到尝试执行乘除的子例程或函数时，它就可能出现。为了防止出现此情况，请用 –i64 选项编译。-i46 选项为缺省选项。

消息标识：CAUTION_0908

## Error:没有足够可用的寄存器进行此 vfunction 调用。

调用 VFUNCTION 最多可传递七个单字项或三个双字项。它们最多用七个字就可以采用任何顺序混合。这次调用 VFUNCTION 传递了多于七个的参数字。 被分类为 VFUNCTION 的函数是 Fortran 标准的一个扩展。

消息标识：ERROR_0909

## Error:派生类型的参数或类型字符不允许进行 vfunction 调用。

VFUNCTION 的所有参数必须适合七个寄存器。仅允许整数、实数、复数或逻辑类型的表达式，而且总字数不能大于七。 被分类为 VFUNCTION 的函数是 Fortran 标准的一个扩展。

消息标识：ERROR_0910

## Log_Warning：汇编语言文件（-eS 或 -S 文件名）禁用了汇编语言列表 (-rg)。已选定输出文件。

编译器不能同时创建汇编语言列表和汇编语言输出文件。最后指定的选项是选定的选项。

消息标识：LOG_WARNING_0911

## Log_Summary：f90-912：在命令行中找到 %d ERRORS。编译中止。

此消息给出命令行处理期间生成的错误消息之汇总。如果在命令行处理期间找到任何错误，编译即中断。

消息标识：LOG_SUMMARY_0912

## Log_Warning：必须启用二进制输出文件才能获得汇编语言列表。(-rg)

必须启用二进制（-eB 或 -b 文件名或缺省）输出文件，才能获得汇编语言列表。例如：

    -dB -er  file.f

它将收到警告消息。

消息标识：LOG_WARNING_0913

## Error:它具有 DIMENSION 属性，因而必须具有一个用作函数的显式接口。

如果函数具有值确定的数组结果，它必须具有显式接口。显式接口可以通过接口块或将函数指定为内部函数或模块子程序来提供。

消息标识：ERROR_0914

## Error:它具有 POINTER 属性，因而必须具有一个用作函数的显式接口。

如果函数具有值确定的指针结果，它必须要具有显式接口。显式接口可以通过接口块或将函数指定为内部函数或模块子程序来提供。

消息标识：ERROR_0915

## Error:它具有可变长度字符结果，因此必须具有显式接口。

如果函数具有可变长度字符结果，那么它必须具有显式接口。显式接口可以通过接口块或将函数指定为内部函数或模块子程序来提供。指定 EXTERNAL 属性并不给出显式接口。

消息标识：ERROR_0916

## Log_Error：CIF 选项具有非法参数。

-C 命令行选项正在被传递无效参数。

消息标识：LOG_ERROR_0917

## 警告：函数“%s”有指针结果，但结果还没未被指针赋值或分配。

在引用指针前必须将它关联。此函数具有指针结果，但结果未在指针赋值语句或 ALLOCATE 语句中指定。

消息标识：WARNING_0918

## Error:它已与主机关联并用作命名常量，因此不能重新声明为内部过程。

此对象在主机范围内被声明为命名常量。不能将对象声明为内部过程，因为它在主机范围内与主机关联，并且在局部范围内的初始化表达式中被用作命名常量。

消息标识：ERROR_0919

## Error:它是主机关联，因此不能用此属性重新声明。

如果在主范围内声明对象并在局部范围内使用，那么该对象是主关联的。对象在某个范围内主机关联之后，就不能重新声明。编译器检测到一些与此类似的内容：

    PROGRAM ABC
    INTEGER I
       ...
    CONTAINS
    SUBROUTINE SUBR(A)
    DIMENSION A(I)

    SAVE I  !Illegal; I used in DIMENSION statement
    END SUBROUTINE
    END PROGRAM

消息标识：ERROR_0920

## Error:它是主机关联，因此不能以此方式重新声明。

如果在主范围内声明对象并在局部范围内使用，那么该对象是主关联的。对象主关联到某个范围内之后，就不能重声明。

消息标识：ERROR_0921

## Error:它已使用关联，因此不能用此属性重新声明。

对象已使用关联之后，就不能在任何规范语句中指定。

消息标识：ERROR_0922

## Error:它已使用关联，因此不能以此方式重新声明。

项目已使用关联之后，除了赋值给它 PUBLIC 或 PRIVATE 属性以外，就不能在任何规范语句中指定。

消息标识：ERROR_0923

## Error:它是此范围内的主机关联，因此不能重新声明为可变长度字符。

如果在主范围内声明对象并在局部范围内使用，那么该对象是主关联的。对象在某个范围内主机关联之后，就不能重新声明。

消息标识：ERROR_0924

## Error:它已使用关联，因此不能重新声明为可变长度字符。

项目已使用关联之后，除了赋值给它 PUBLIC 或 PRIVATE 属性以外，就不能在任何规范语句中指定。

消息标识：ERROR_0925

## Error:它是主机关联，因此不能用 DIMENSION 属性重新声明。

如果在主范围内声明对象并在局部范围内使用，那么该对象是主关联的。对象在某个范围内主机关联之后，就不能赋值给它 DIMENSION 属性。

消息标识：ERROR_0926

## Error:它已使用关联，因此不能用 DIMENSION 属性重新声明。

项目已使用关联之后，除了赋值给它 PUBLIC 或 PRIVATE 属性以外，就不能在任何规范语句中指定。

消息标识：ERROR_0927

## Error:它是主机关联，因此不能在公共块中重新声明。

如果在主范围内声明对象并在局部范围内使用，那么该对象是主关联的。对象在某个范围内主机关联之后，就不能重新声明。

消息标识：ERROR_0928

## Error:它已使用关联，因此不能在公共块中重新声明。

项目已使用关联之后，除了赋值给它 PUBLIC 或 PRIVATE 属性以外，就不能在任何规范语句中指定。

消息标识：ERROR_0929

## Error:它是主机关联，因此不能重新声明为函数。

如果在主范围内声明对象并在局部范围内使用，那么该对象是主关联的。对象在某个范围内主机关联之后，就不能重新声明。

消息标识：ERROR_0930

## Error:它已使用关联，因此不能重新声明为函数。

项目已使用关联之后，就不能重新声明。

消息标识：ERROR_0931

## Error:它是主机关联，因此不能重新声明为子例程。

如果在主范围内声明对象并在局部范围内使用，那么该对象是主关联的。对象在某个范围内主机关联之后，就不能重新声明。

消息标识：ERROR_0932

## Error:它已使用关联，因此不能重新声明为子例程。

项目已使用关联之后，就不能重新声明。

消息标识：ERROR_0933

## Error:模块在模块中没有声明公共实体，因此不能找到在重命名列表中指定的名称。

USE 语句中指定的模块明显为空，因此找不到 rename_list 指定的名称。此模块可能为空的原因之一：
-- 模块在其规范部分不包含声明。
-- 模块中的一切均被声明为私有的。
-- 模块有编译错误。

消息标识：ERROR_0934

## 警告：整型算术表达式超过 46 位最大值。将尝试 64 位整型算术。

尝试计算常量表达式的值时，编译器遇到的整数值太大而不能用 46 位整数格式表示。此值被处理为 64 位值，并执行了 64 位整型算术。常量表达式仅包含常量，表达式的值是在编译时而不是在执行决定的。计算过程中（如从实数转换到整数）需要数据类型转换时出现此错误。

消息标识：WARNING_0935

## Error:DATA 隐含的 DO 循环控制表达式必须为标量整型表达式。

DATA 语句中隐含的 DO 具有以下格式：

    (data_i_do_object_list, data_i_do_variable =
    scalar_int_expr, scalar_int_expr
    	[, scalar_int_expr])

三个 scalar_int_expr 表示隐含 DO 变量的开始、结束和增量值。这些表达式的每一个都必须是标量，并且每个都必须是整型。

消息标识：ERROR_0936

## 内部：编译器尝试使用内在 enum 调用内在处理器，但是 enum 为 Unknown_Intrinsic。

有一个内在 enum 的列表，它用于调用内处理的语义例程。enum 设置为 Uknown_Intrinsic，并且正在调用 unkown_intrinsic 例程。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0937

## 注意：在转换为整型的表达式中遇到与实数相除。

正在使用赋值语句，它等号左边的操作数是整型，等号右边的操作数是实数或双精度类型的表达式，包含除法运算。此消息是一个警告，提示在本机上除法是通过倒数近似完成的，在这些情形中可能产生意外的答案。例如，在以下语句中，X 是 27.0 并且 Y = 9.0，X/Y 将得到 2.9999...：

    I = X/Y

当 2.9999... 被赋值给 I（转换为整数）时，其结果将是 2 而不是 3。

消息标识：CAUTION_0938

## Error:函数被定义为假定长度字符类型。它必须具有要调用的已知字符长度。

如果调用了字符函数，必须知道此字符函数的长度。

消息标识：ERROR_0939

## Ansi：它是一个语句函数伪参数和一个变量。类型必须一致。

如果语句函数伪参数与变量具有相同的名称，可以在语句函数定义后定义此变量的类型，但仅能定义确定的类型。

消息标识：ANSI_0940

## Error:公共块被定义和/或关联为同一范围中的标准和任务公共块。

通过声明、使用关联或主机关联可以将公共块定义在某个范围内。此范围中出错的公共块被多次定义，但在某些地方它是标准公共块，而在其它地方则是任务公共块。以下是如何在某个范围内定义公共块的示例：

    MODULE CC
    COMMON /BB/ M,N   !Common block BB is declared
    END MODULE        ! in CC's scope

    PROGRAM ZZ
    USE CC            !Common block BB is use
    CONTAINS          !  associated into ZZ's scope
    SUBROUTINE YY()
    N = M           !Common block BB is host
    END SUBROUTINE  ! associated into YY's scope
    END PROGRAM

以下是此问题的一个示例：

    MODULE CC
    COMMON /BB/ M,N   !Common block BB declared
    END MODULE        ! in CC's scope

    MODULE DD
    TASK COMMON /BB/ M,N !Common block BB declared
    END MODULE           ! in DD's scope

    PROGRAM QQ
    USE CC            !Common block BB comes in
    USE DD               !Common block BB comes in
    ! but it is TASK COMMON
    END PROGRAM

任务公共块是 Fortran 标准的一个扩展。

消息标识：ERROR_0941

## Error:公共块“%s”在此范围内被定义和/或关联为标准和辅助存储块。

通过声明、使用关联或主机关联可以将公共块定义在某个范围内。此范围中出错的公共块被多次定义，但在某些地方它是标准公共块，而在其它地方则是辅助存储中的公共块。以下是如何在某个范围内定义公共块的示例：

    MODULE CC
    COMMON /BB/ M,N   !Common block BB is declared
    END MODULE        ! in CC's scope

    PROGRAM ZZ
    USE CC            !Common block BB is use
    CONTAINS          !  associated into ZZ's scope
    SUBROUTINE YY()
    N = M           !Common block BB is host
    END SUBROUTINE  ! associated into YY's scope
    END PROGRAM

辅助存储是 Fortran 标准的一个扩展。

消息标识：ERROR_0942

## 注释：在 io 隐含的 do 控制中使用缺省实数或双精度实数表达式类型是一个废弃特征。

每个 io_implied_do_control 中的 scalar_numeric_expr 都必须为整数、缺省实数或双精度实数类型。Fortran 标准认为缺省实数和双精度实数类型表达式是废弃的。废弃特征是 FORTRAN 77 的多余特征，在 Fortran 中还有更好的方法。将整型表达式用作隐含 DO 表达式而不是缺省实数或双精度类型。

消息标识：COMMENT_0943

## 注释：对缺省实数或双精度实数 DO 变量类型的使用是一个废弃特征。

在io_implied_do 中的 DO 变量必须是整数、缺省实数或双精度实数类型的标量。Fortran 标准认为缺省实数和双精度实数类型的变量是废弃的。废弃特征是 FORTRAN 77 的多余特征，在 Fortran 中还有更好的方法。使用整型的 DO 变量而不是缺省实数或双精度类型。

消息标识：COMMENT_0944

## Error:辅助变量不能用在 I/O 语句中。

通过使用 AUXILIARY 编译器指令，分配给 SSD 的实体名称出现在 I/O 语句中。不允许将 I/O 传输进或传输出辅助变量。

辅助存储是 Fortran 标准的一个扩展。

消息标识：ERROR_0945

## Error:如果在 I/O 控制列表中出现 SIZE= 说明符，则也必须出现 ADVANCE= 说明符。

SIZE= 说明符出现在没有 ADVANCE= 说明符的 READ 或 WRITE 语句中。

消息标识：ERROR_0946

## Error:数组实际参数在此上下文中不是可选的。

调用基本内在函数时，如果正在传递可选数组实际参数，那么也必须传递与其一致的非可选实际参数。如果两个对象的每个维数都具有相同的等级和范围，它们就是一致的。

    DIMENSION A(10), B(10)
    MAX (A3=A, A1=B, A2=4)        !Legal
    MAX (A3=A, A1=5, A2=4)        !非法

调用 MAX 时，A3 是可选参数。因为指定了 A3，所以必须指定 A1 或A2 两个非可选参数中的至少一个参数，并且非可选参数中至少有一个必须与 A3 一致。

消息标识：ERROR_0947

## 限制：指定了此选项，因此在出现第一个错误时中止编译。

如果启用 -ea 选项，则遇到第一个错误时编译终止。

消息标识：LIMIT_0948

## Error:通用接口不能有显式类型。

通用接口不能被定义类型。

消息标识：ERROR_0949

## Error:它是一个通用接口或内名称。不能对其定义类型，因为它已经被引用。

不能将属性类型赋值给不是内在名称的通用接口名称。倘若先前没有引用过通用接口，可以将属性类型赋值给是内在属性的通用接口。

消息标识：ERROR_0950

## Error:此维数的范围对于数组而言太大。

计算范围对本机而言太大。数组必须小一些。

消息标识：ERROR_0951

## Ansi：它是主机范围内局部变量的名称，因此不能是外部过程的名称。

Fortran 标准将外部过程定义为全局实体。在任何范围内，全局实体都不允许与局部实体具有相同的名称。

消息标识：ANSI_0952

## Ansi：它是主机范围内局部实体的名称，因此不能是 USE 语句中模块的名称。

Fortran 标准将模块定义为全局实体。在任何范围内，全局实体都不允许与局部实体具有相同的名称。

消息标识：ANSI_0953

## Log_Summary：Cray CF90 版本 %s (%s) %s

这确定了正在使用哪一个版本的编译器。指定 -V 时使用它。

消息标识：LOG_SUMMARY_0954

## Error:程序缺少 END 语句。

编译器检测到文件提前结束。主程序单元必须由 END [PROGRAM] 语句终止。

消息标识：ERROR_0955

## Error:它是主机关联到此范围内，但不是派生类型，因此不能用作派生类型。

如果实体在某个范围内被主机关联为变量、常量或过程，它就不能用作派生类型。

消息标识：ERROR_0956

## Ansi：允许带符号的 BOZ 常量是 Fortran 标准的一个扩展。

DATA 语句 data_stmt_value_list 中值的允许格式是：

    scalar_constant
    signed_int_literal_constant
    signed_real_literal_constant
    structure_constructor
    boz_literal_constant

仅有整型文字常量或实型文字常量才能使用符号。允许带符号的 BOZ 文字常量是 Fortran 标准的一个扩展。

消息标识：ANSI_0957

## Error:仅允许整型文字常量或实型文字常量使用符号。

DATA 语句 data_stmt_value_list 中值的允许格式是：

    scalar_constant
    signed_int_literal_constant
    signed_real-literal-constant
    structure_constructor
    boz_literal_constant

仅允许整型文字常量或实型文字常量使用符号（通过扩展，BOZ 文字常量可以使用符号）。

消息标识：ERROR_0958

## 警告：还不支持 PARALLEL 或 DOALL 编译器指令中的 AUTOSCOPE 参数。

本 f90 版本不支持 DOALL 或 PARALLEL 任务指令的 AUTOSCOPE 参数。因此，所有用于平行区域中的变量都必须在 PARALLEL 或 DOALL 指令行中指定私有或共享属性。

消息标识：WARNING_0959

## Error:如果没有指定自动范围，变量在平行区域中，并且必须在共享或私有的列表中。

如果没有指定自动范围，所有用于平行区域或 DOALL 循环的用户变量必须在共享或私有的列表中。在此 f90 版本中不支持自动范围，因而必须显式指定所有范围。

消息标识：ERROR_0960

## Error:DO 控制变量在 DOALL 循环中不能是 SHARED。

DOALL 循环的 DO 变量不能用 SHARED 属性指定。

消息标识：ERROR_0961

## Error:数组构造函数隐含的 DO 控制表达式必须为标量整型表达式。

数组构造函数中隐含的 DO 具有以下格式：

    (ac_value_list, ac_do_variable =
    scalar_int_expr, scalar_int_expr
    	[, scalar_int_expr])

三个 scalar_int_expr 表示隐含 DO 变量的开始、结束和增量值。这些表达式的每一个都必须是标量，并且每个都必须是整型。

消息标识：ERROR_0962

## 内部：在 cmp_ref_trees 中遇到 SH_Tbl_Idx。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0963

## 内部：gen_static_dv_whole_def 中的非常量字符。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0964

## 内部：process_deferred_functions 中的问题。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0965

## 内部：非恒定形式的 create_bd_ntry_for_const。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0966

## 内部：create_bd_ntry_for_const 中的非恒定字符长度。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0967

## 内部：set_shape_for_deferred_funcs 中的 Assumed_Size 函数结果。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0968

## 内部：gen_internal_dope_vector 中的非常量字符。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0969

## 内部：call_list_semantics 中没有函数类型信息。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0970

## 内部：尝试更改 call_list_semantics 中的数据对象。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0971

## 内部：call_list_semantics 中错误的伪参数。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0972

## 内部：ptr 赋值的左边有不适当的 ir。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0973

## 内部：assignment_stmt_semantics 中有错误的语句标题。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0974

## 内部：expr_semantics 中有不适当的 ir 树。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0975

## 内部：从 ptr_assign_from_pointer 要求 Dv_Deref_Opr。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0976

## 内部：从 ptr_assign_from_pointer 要求 ir。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0977

## 内部：array_construct_semantics 中除列表运算符外的部分。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0978

## 内部：fold_aggragate_expression 中错误的假定。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0979

## 内部：interpret_constructor 中 lcv 常量未预料的类型。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0980

## 内部：interpret_constructor 中无常量。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0981

## 内部：interpret_constructor 中没有 lcv 常量。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0982

## 内部：interpret_constructor 中无效的位置索引。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0983

## 内部：解释器 ref 的数组语法部分中的结构。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0984

## 内部：create_array_constructor_asg 中的错误，不是 ir 索引。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0985

## 内部：create_array_constructor_asg 中的错误，意外运算符。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0986

## 内部：create_struct_constructor_asg 中的问题。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0987

## Error:这是一个函数的结果名，因此它不能是一个模块的使用关联。

该函数的结果名在由 USE 语句引入的模块中发现。这造成了名称冲突，如下例所示：

    MODULE NEW
    INTEGER ABC
    END MODULE

    FUNCTION X RESULT(ABC)
    USE NEW          !ABC is illegal here
    END FUNCTION

消息标识：ERROR_0988

## 内部：在使用处理过程以检查不可见对象时，编译器在 attr 表中找到未预料的实体。

在例程 attr_is_visible 里，编译器在 attr 表中发现一个未预料的属性。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0989

## Error:非法将 LOC 作为辅助数组。

在 LOC 内在函数中，辅助数组不能是实际参数。辅助存储和 LOC 内在函数都是 Fortran 标准的扩展。

消息标识：ERROR_0990

## Error:存在多个特定接口，产生歧义。这造成该接口不明确。

存在多个产生歧义的特定接口。在同一通用或定义接口中指定这些（接口）。如果引用这个通用接口，编译器将不能分辨特定的接口，因为编译器不知道分辨哪一个。在一个作用单元内，同一通用或定义接口中的两个过程通过其无选择的伪参数加以区分。一种区分特定接口的方法是按其伪参数的个数。如果特定接口具有相同的伪参数个数，则伪参数必须在类型、种类类型或者等级上有所不同。在一个定义接口里的多个特定接口必须具有不同类型、种类类型或等级的伪参数。

消息标识：ERROR_0991

## Log_Error：已指定“-O”，因此不能指定冲突的“-O”。

如果在命令行中使用 -O 参数指定优化级别，则所有以下选项都不能在此命令行中指定：

    -O scalar0  -O vector0  -O task0
    -O scalar1  -O vector1  -O task1
    -O scalar2  -O vector2  -O task2
    -O scalar3  -O vector3  -O task3

消息标识：LOG_ERROR_0992

## 内部：运算符内部文本没有有效的类型表索引。

运算符 ir 节点有一个零型表索引。生成此错误消息的例程要求该运算符有一个有效类型的索引。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_0993

## Error:对 ASSOCIATED 内在过程的实际参数只在它们都是指针时，才可以都是伪参数。

如果它们都是指针的话，与内在过程相关的实参数可以都是伪参数。

消息标识：ERROR_0994

## 内部：尝试打印缓冲消息 - %s时遇到不可恢复的错误。

应避免产生此消息。编译器无法输出它已经产生的消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。

消息标识：INTERNAL_0995

## Error:此下标的值大于声明的上界。

下标必须小于或等于声明的相应维数上界。

消息标识：ERROR_0996

## Error:段下标三元组产生了一个小于所声明下界的下标值。

在一个下标为三元组下标的段中，每个下标值都必须大于或等于数组声明的下界，或者小于或等于数组声明的上界。例如，如果数组声明如下： INTEGER array(10) 每个引用 ARRAY 的段下标三元组的下标值必须等于或大于 1 并且等于或小于 10。

消息标识：ERROR_0997

## Error:段下标三元组的跨度值不能为零。

一个段下标三元组由一个开始值、一个结束值和一个跨度值组成，跨度值由冒号分开，如下所示： [start-value] :[end-value] [ :stride] 跨度值不能为零。

消息标识：ERROR_0998

## Error:CHAR 内函数的参数在有效的整理序列外。

CHAR 内函数的参数在有效的整理序列外。

消息标识：ERROR_0999

## 注释：保留

-- f90 安装过程使用“Explanation 1000”。
-- “Explanation 1000”必须是非格式化的，因此用 $EXP 代替 $NEXP。
-- Explanation 1000 必须是 USM VID 字符串而绝不能是别的。1000 90.43\n

消息标识：COMMENT_1000

## Error:数组下标三元组的跨度不能为零。

在其下标三元组里遇到了一个具有零跨度值的数组段。

消息标识：ERROR_1001

## Error:这在列表组中指定，因此其类型是假定的。

当在一个名称列表组中指定了一个对象时，如果它是该对象的第一个引用，则隐式定义其类型。只有对象与此类型相符时，接下来才能在类型声明语句中定义此对象的类型。

示例：

    IMPLICIT INTEGER(A-Z)
    NAMELIST /GROUP/ R
    REAL R           !非法

R 只可定义为整数类型，因为在 NAMELIST 语句中它已隐式定义为整型。

消息标识：ERROR_1002

## 警告：该编译单元包含多个未命名程序单元。

一个编译单元仅能有一个未命名的程序单元。

消息标识：WARNING_1003

## 内部：存在负偏移。

当前端用一个数据对象完成时，其偏移必须为零或者是正数。

消息标识：INTERNAL_1004

## Error:它是个公共块名且还被声明为内在过程。

Fortran 标准禁止公共块名用作内在过程名。

消息标识：ERROR_1005

## Ansi：全局名正在作为公共块名以及外部子程序或程序单元名使用。

Fortran 标准禁止公共块名作为外部子程序名或者程序单元名使用。程序单元是一个块数据子程序、一个模块子程序或者是一个主程序。外部子程序是外部函数或子例程。外部子程序名也可在 ENTRY 语句、CALL 语句、EXTERNAL 语句、接口体中定义或者在表达式中作为函数调用。

消息标识：ANSI_1006

## Error:全局名称被使用两次。

全局名称的使用范围是整个编译单元，因此全局（或外部）名称只能声明一次。

消息标识：ERROR_1007

## 注意：因为等价对齐，所以不能双精度对齐。

-a dalign 选项在命令行里指定，所以编译器试图双精度对齐所有的东西。该变量不能双精度对齐，因为它等价于另一在双精度字上不对齐的变量。

下面是一个示例：

    DOUBLE PRECISION ::B, C
    REAL, DIMENSION(10) ::A
    EQUIVALENCE(A(1), B)
    EQUIVALENCE(A(2), C)

如果 B 在双精度字上对齐，则 C 不能双精度对齐，反之亦然。

消息标识：CAUTION_1008

## 警告：该编译单元包含多个主程序单元。

一个编译单元仅能有一个程序单元。

消息标识：WARNING_1009

## 警告：全局名称已在使用。

全局名称的使用范围是整个编译单元，因此全局（或外部）名称只能声明一次。

消息标识：WARNING_1010

## Error:过程和该编译必须都使用 -a dalign 或都不使用 -a dalign 编译。

如果当前编译单元使用 –a dalign 选项进行编译，则它使用的每个模块或它内联的每个预编译程序必须用 –a dalign 选项编译。如果当前编译单元不使用 –a dalign 选项进行编译，则它使用的每个模块或它内联的每个预编译程序也不能用 –a dalign 选项编译。

消息标识：ERROR_1011

## Error:LBOUND、UBOUND 或 SIZE 内在过程的 DIM 参数必须是在 1 和 ARRAY 参数的等级之间的值。

当为 LBOUND、UBOUND 或 SIZE 内在函数指定维数参数时，\ 其值必须在数组 参数的维数范围内。其范围是 1 <= 维数 <= 数组等级。

消息标识：ERROR_1012

## 警告：-a dalign 命令行选项在此公共块中强行插入填充。

-a dalign 选项强制双精度字项在双精度字边界上对齐。公共块中的对象是双精度字对象。为在双精度字边界上得到该对象，在公共块中，在对象前面插入一些填充。

消息标识：WARNING_1013

## Error:字符对象具有非恒定范围。仅能在函数、子程序或接口体中声明。

定义为具有非恒定长度的字符对象仅能在子例程、函数或接口体（描述子例程和函数）中声明。编译器检测到非恒定长度的字符对象，但是，子例程、接口体或函数中没有声明。

消息标识：ERROR_1014

## Error:在该范围中局部名称只能在重命名列表中引用一次。

重命名列表的 BNF 是：局部名 => 使用名

编译器在多于一个的重命名中检测到同一局部名称。在一个范围内每个局部名称必须唯一。

消息标识：ERROR_1015

## 内部：将无效类型发送到算术输入转换。

内部编译器错误。遇到了一个 arith.a 输入转换例程不支持的类型。

消息标识：INTERNAL_1016

## Error:DIM 参数不在有效范围内。

用户试图为维数传递非法值。

消息标识：ERROR_1017

## 内部：没有为 create_tmp_asg 中的字符表达式设置 char_len 字段。

内部编译器错误。对于一个内部数据结构来说，字符长度信息无效。

消息标识：INTERNAL_1018

## 内部：它在等价组中，但没将 ATD_EQUIV 设置为 TRUE。

等价组中的任何内容都必须将 ATD_EQUIV 设置为 TRUE。

消息标识：INTERNAL_1019

## 内部：process_variable_size_func 中出现内部编译器错误。

内部编译器错误。

消息标识：INTERNAL_1020

## 注意：将隐含的 DO 转换成完整数组或数组段初始状态。

使用隐含DO 初始化整个数组或数组段时是一种低效的办法。通过隐含 DO 初始化一个大数组可能占用巨大的编译时资源。只要有可能，这种隐含DO 应当被类型声明语句中的初始化（适用于整个数组初始化）、或是 DATA 语句中的整个数组或数组段初始化替代。 例如， INTEGER array(100,100) DATA ((array(i,j), i = 1, 100), j = 1, 100) /10000 * -1/ 应当被替换为 INTEGER ::array(100,100) = -1 或 INTEGER array(100,100) DATA array /10000 * -1/ 数组的一部分之初始化应当尽可能用数组段初始化来替代（并不是所有的这种初始化都可以在数组段表示法里重写）。 例如， INTEGER array(100,100) DATA ((array(i,j), i = 1, 100), j = 1, 50) /4999 * -1, 0/ 应当被替换为 INTEGER array(100,100) DATA array(:, 1:50) /4999 * -1, 0/

消息标识：NOTE_1021

## 内部：create_io_call_descriptor 中期望的字符子串。

内部编译器错误。

消息标识：INTERNAL_1022

## 内部：fei_new_stmt 上传递的行号必须非零。

fei_new_stmt 需要一个非零的行号。

消息标识：INTERNAL_1023

## 内部：表达式求值失败。

编译器试图在编译期间对表达式求值并遇到了一个未预料的结果或条件。 应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。您可以修改代码以使编译器不再试图生成这条消息。

消息标识：INTERNAL_1024

## 内部：create_scalar_type_tbl 中的非恒定字符长度。

内部编译器错误。

消息标识：INTERNAL_1025

## Error:不能为模块“%s”打开模块信息表的输出文件。请检查目录权限。

编译器无法打开一个文件以写出模块信息表。请检查当前目录的写入权限。

消息标识：ERROR_1026

## Error:USE 语句指定的模块是当前正在编译的模块。模块自身不能使用它自己。

模块自身不能使用它自己，任何模块包含的程序也不能使用该模块。编译器检测到一些与此类似的内容：

    MODULE M
               ...
    CONTAINS
    SUBROUTINE S()
    USE M	    ! 非法
    END SUBROUTINE
    END MODULE

消息标识：ERROR_1027

## Ansi：这是主机关联的公共块名且为内在过程。这是非标准的。

一个主机关联的公共块名被用作内在过程名。这是 Fortran 标准的一个扩展。如果任何公共块成员主机关联到一个范围，则公共块名也主机关联到该范围。

消息标识：ANSI_1028

## Ansi：这是使用关联的公共块名且为内在过程。这是非标准的。

一个使用关联的公共块被用作内程序名。这是 Fortran 标准的一个扩展。如果任何公共块成员使用关联到一个范围，则公共块名也使用关联到该范围。

消息标识：ANSI_1029

## Error:这是个主机关联的公共块名且还被声明为内在过程。

Fortran 标准禁止主机关联的公共块名用作内在过程名。如果任何公共块成员主机关联到一个范围，则公共块名也主机关联到该范围。

消息标识：ERROR_1030

## Error:这是个使用关联的公共块名且还被声明为内在过程。

Fortran 标准禁止使用关联的公共块名用作内在过程名。如果任何公共块成员使用关联到一个范围，则公共块名也使用关联到该范围。

消息标识：ERROR_1031

## Ansi：这是命名常量并且还是主机关联的公共块名称。这是非标准的。

Fortran 标准禁止命名常量和一个主机关联的公共块使用同一名称。如果任何公共块成员主机关联到一个范围，则公共块名也主机关联到该范围。

消息标识：ANSI_1032

## Ansi：这是命名常量并且还是使用关联的公共块名称。这是非标准的。

Fortran 标准禁止命名常量和一个使用关联的公共块使用同一名称。如果任何公共块成员使用关联到一个范围，则公共块名也使用关联到该范围。

消息标识：ANSI_1033

## Error:编译器不能打开此文件，它可能包含所用模块的有关信息。

编译器不能打开用于 USE 语句处理的指定模块文件。检查文件和目录的权限。如果是非 Cray 系统，编译器可能会试图打开 .M 文件。这个文件在命令行上被指定为 -p x.o。

消息标识：ERROR_1034

## Error:递归地使用字符对象声明自己的长度。

一个设定为字符类型的对象不能做为声明其自身长度的表达式的一部分。下面是一个非法声明的示例：CHARACTER*(CH) ::CH

消息标识：ERROR_1035

## Error:递归地使用数组声明自己的范围。

数组不能在声明其自身范围中递归使用。下面是一个非法声明的示例：DIMENSION ::IARR(IARR)

消息标识：ERROR_1036

## Error:它已作为伪参数声明和使用，因此再不能作为过程声明和使用。

对象声明为伪参数并被引用或定义后，则该对象不能再作为过程声明或者作为过程而引用。

消息标识：ERROR_1037

## Error:它被作为一个伪参数声明和使用，因此它不能用这种方法声明。

被声明的对象是一个被引用或定义的伪参数，伪参数禁止被下列任何项声明：

    	Cray 指针
    	Cray 指针对象
    	函数结果
    	派生类型
    	通用接口
    	名称列表组
    	语句函数
    	构造名
    	函数
    	subroutine

消息标识：ERROR_1038

## Error:它已被作为一个伪参数声明和使用，因此不能用那种属性声明。

被声明的对象是一个被引用或定义的伪参数，伪参数禁止被赋予下列任何一种属性：

    	DIMENSION
    	ALLOCATABLE
    	PARAMETER
    	INTRINSIC
    	VFUNCTION
    	NOSIDE EFFECTS

消息标识：ERROR_1039

## Error:它已作为伪参数声明和使用，因此不能用作派生类型名。

编译器检测到此对象使用时的冲突。该对象是伪参数，禁止在派生类名中使用伪参数。

消息标识：ERROR_1040

## Error:在平行区域中调用伪过程“%s”，并且如果没有指定自动范围，则它必须在共享列表中。

所有在一个并行区域中或者在 DOALL循环里调用的伪过程，如果没有指定自动范围则必须在共享列表里。在此 f90 版本中不支持自动范围，因而必须显式指定所有范围。

消息标识：ERROR_1041

## Error:编译器不能成功地写入中间文件。

编译器无法完成写入中间文件的任务，很可能是由于可用磁盘空间不足。

消息标识：ERROR_1042

## Error:编译器无法打开中间文件。

编译器无法打开用于输出的指定中间文件。

消息标识：ERROR_1043

## 内部：内部：%s

中间文件生成器检测到一个内部错误条件。

消息标识：INTERNAL_1044

## Log_Summary：f90：Cray CF90 版本%s (cft90:%s mif:%03d) %s

这确定了正在使用哪一个版本的编译器。

消息标识：LOG_SUMMARY_1045

## 注意：自动变量需要的范围在所有入口点不可用。

自动变量的范围可以包含伪参数。编译器发现一处或者多处没有指定伪参数的入口点，以至于不能确定所有入口点自动变量的长度。一个长度无法确定的入口点，将分配一个零长度变量。

消息标识：CAUTION_1046

## Error:因为 DO 变量是 DOUBLE PRECISION 类型，所以不允许无类型或 BOZ 常量。

当在一个算术上下文环境中使用时，无类型或 BOZ 常量被限制为一个字。不允许将这种无类型或 BOZ 常量分配给 DOUBLE PRECISION 类型的变量。类似的，当 DO 变量是 DOUBLE PRECISION类型时，这种常量不能是 DO 循环表达式。

消息标识：ERROR_1047

## 内部：change_to_base_and_offset 中遇到无效的运算符。

内部编译器错误。

消息标识：INTERNAL_1048

## 内部：cvrt_exp_to_pdg 中发现运算符 Init_Reloc_Opr 的无效格式。

内部编译器错误。

消息标识：INTERNAL_1049

## 内部：expand_io_list 中的 Implied_Do_Opr 的无效格式。

内部编译器错误。

消息标识：INTERNAL_1050

## 内部：对象是已经初始化的数据，但是没有静态或公共的存储类型。

编译假设数据初始化的对象必须是静态的或公共的存储类型。此对象不是静态的或公共的存储类型。

消息标识：INTERNAL_1051

## Log_Error：没有设置 TARGET 环境变量。

当在一个分布式编程环境中编译时，TARGET 环境变量必须设置为目标机器的名称。例如： % setenv TARGET cray-ymp

消息标识：LOG_ERROR_1052

## Error:它既是一个 USE 语句指定的 MODULE 名称，又是从一个 MODULE 使用关联的一个对象。

该指定对象从一个模块使用关联到此范围。同时也是在 USE 语句中指定的模块名。每一个在 USE 语句中指定的模块名必须唯一。

消息标识：ERROR_1053

## Error:32 位整数对于该内在过程是无效参数。

从该内在过程返回的信息不适合 32 位字。参数必须是一个 64 位字。

消息标识：ERROR_1054

## Error:模块文件与该编译系统不兼容。请使用该编译系统重新编译模块。

编译器试图读取一个用不兼容编译器创建的模块文件。为确保兼容，请使用当前编译器和命令行选项重新编译该模块文件。

消息标识：ERROR_1055

## Error:对于 NCOPIES 参数这是无效值。

该参数是负值，这是无效的。

消息标识：ERROR_1056

## Error:对象已从同一模块被 USE 语句关联两次，但它不是 sma 对象。

相关内容以后添加。

消息标识：ERROR_1057

## 内部：在使用语句语义期间 set_merge_link 例程遇到未预料的输入。

set_mod_link 例程假定同一源模块的所有重复属性将合并为一个属性。编译器发现有三种不同的属性索引，而不仅仅是两种。

消息标识：INTERNAL_1058

## Error:通用接口同时具有子例程和函数特定接口。

一个通用接口里的所有特定过程必须是函数或子例程。函数和子例程不能在一个通用接口里混合使用。此通用接口同时具有子例程和函数特定过程。

消息标识：ERROR_1059

## 内部：转换消息文件；libcif 返回错误状态：%s

应避免产生此消息。编译器无法输出它已经产生的消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。

消息标识：INTERNAL_1060

## 警告：该硬件不支持这种整数长度。该指令被忽略。

在 32 位硬件上不支持整数长度 46 和64。

消息标识：WARNING_1061

## Error:该参数不在此内在过程的有效范围内。

当为这个内在过程输入值时，用户选择了无效的数值。

消息标识：ERROR_1062

## 内部：索引不是表的有效索引。

这是一个内部错误，仅在特别的建立调试范围检查编译器内生成。存在一个对符号表或 IR 表的边界溢出表引用。

消息标识：INTERNAL_1063

## Log_Warning：在命令行中指定了两个优化级别。这些导致重新设置缺省值。

用户指定了一些优化级别，这些优化级别需要编译器改变缺省的优化级别以达到兼容的目的。

消息标识：LOG_WARNING_1064

## Error:对象已经在 CACHE_ALIGN 指令中指定。

变量或公共块不允许在多于一个的 CACHE_ALIGN 编译器指令里指定。

消息标识：ERROR_1065

## Error:CACHE_ALIGN 编译器指令不允许变量子对象。

在 CACHE_ALIGN 编译器命令列表中仅允许变量名和公共块。不允许出现变量子对象。

消息标识：ERROR_1066

## Error:CACHE_ALIGN 编译器指令不允许该对象。

在 CACHE_ALIGN 编译器指令中仅允许变量和公共块。同时，CACHE_ALIGN 指令中不允许出现公共块中的变量。

消息标识：ERROR_1067

## Log_Warning：在命令行上指定了优化级别。这些导致重新设置缺省值。

用户指定了一个优化级别，该优化级别要求编译器改变缺省优化级别以达到兼容的目的。

消息标识：LOG_WARNING_1068

## 警告：在这个调试级别下，将忽略优化选项。

当指定该级别的调试时，将忽略优化。要启用优化，需要更佳的调试级别。

消息标识：WARNING_1069

## Error:此内在过程的引用必须有在规范表达式中指定的整数标量结果。

仅当内在过程有整数标量结果的时候才允许在特定表达式里有内在过程。

消息标识：ERROR_1070

## Error:接口包含具有伪参数的过程。该伪参数不能为 OPTIONAL。

一个伪参数有 OPTIONAL 属性，但声明该伪参数的特定接口是定义运算符接口块或是定义赋值接口块。

消息标识：ERROR_1071

## Error:接口OPERATOR() 包含具有伪参数的过程。该伪参数必须有 INTENT(IN)。

在一个定义运算符接口块中，伪参数的 intent 必须用特定的值来指定。该伪参数必须有 INTENT(IN)。

消息标识：ERROR_1072

## Error:接口包含具有伪过程的过程。不允许有伪过程。

在定义赋值接口块或定义运算符接口块内的特定接口必须具有是数据对象的伪参数。不允许出现伪过程。

消息标识：ERROR_1073

## Error:接口ASSIGNMENT(=) 包含具有伪参数的过程。伪参数必须有正确的 INTENT。

在一个定义赋值接口块中，伪参数的 intent 必须用特定的值来指定。第一个伪参数必须有 INTENT(OUT) 或 INTENT(INOUT)。第二个伪参数必须有 INTENT(IN)。

消息标识：ERROR_1074

## Error:该参数不能是 ALLOCATABLE 或 POINTER。

该参数不能有 POINTER 或 ALLOCATABLE 属性。

消息标识：ERROR_1075

## Ansi：具有 TYPELESS 类型的参数是非标准的。

在该上下文中不允许 TYPELESS。

消息标识：ANSI_1076

## Ansi：未使用的

消息标识：ANSI_1077

## Error:通用接口的此种使用是无效的。

编译程序检测到一处本应为数据对象或函数调用的通用接口引用。这也许是一个没有实际参数列表的通用接口名的结果。

消息标识：ERROR_1078

## 内部：发送到 arith.a 简化例程的无效类型。

内部编译器错误。

消息标识：INTERNAL_1079

## Error:PRESENT 内在函数的参数必须为非限定名。

Fortran 标准的解释中，将 PRESENT 内在函数的参数描述措辞变为如下所示： A 必须是一个可选的伪参数的名称，该伪参数在 PRESENT 函数引用出现的过程中可以存取。 在 Fortran 标准中“name”是一个技术术语，它被定义为一个可以后跟最多 30 个文字数字字符的字母。因此“name”不允许包含下标列表、子字串表达式、结构组件分隔符 (%) 等等。所以，PRESENT 内在函数的参数不能包含任何限定。

消息标识：ERROR_1080

## Error:在该上下文中不允许名称限定。

在此上下文中（例如在一个 DATA 语句值列表里的值），可能会出现一个命名常量，但不是一个命名常量的子对象。例如： DATA (a(i), i = 1, t%i) / p(i) * t%i / 在上面的 DATA 语句中，假设 T 是一个命名常量结构而 P 是一个命名常量数组。上述 DATA 语句示例所有对 T 和 P 的子对象的引用都被禁止，因为在每个这种上下文里的标识符必须是一个命名常量名。不能由下标列表或结构组件名限定该名称。

消息标识：ERROR_1081

## Error:迭代计数太大。

迭代计数按如下方式计算： MAX( INT( (end-value - start-value + inc-value) / inc-value), 0) 循环控制表达式的值是这样的一些值，这些数表示的迭代计数大于能够表示的最大整数。

消息标识：ERROR_1082

## 警告：DO 变量终值的量级太大。

如果循环执行完毕，在所声明的种类类型值的整型 DO 变量中，DO 变量的终值的大小将比所能表示的最大整数还要大（如果增量值是正数的话），或者比所能表示的最小负整数还要小（如果增量值是负数的话）。 DO 变量的终值通过下面的式子来计算： 开始值 + 迭代计数 * 增量值 这条消息是为字长是 32 位的机器上的以下格式的 DO 语句生成的，因为 DO 变量的最终值是 2147483648（假设 DO 变量是缺省的整数类型）。这个值大于能够表示的最大值。 DO i = 1, 2147483647 如果 DO 变量是一个非缺省整数类型而且其终值超出 DO 变量种类类型参数的位大小的范围，也将生成此消息。例如： INTEGER(KIND=1) i DO i = 1, 1000 KIND 类型参数值为 1，表示变量 i 只能包含 –127 到 +127 之间的整数值。DO 变量的终值是 1001，它超出了这个范围。

消息标识：WARNING_1083

## Error:不允许隐含 DO 增量值为 0。

隐含 DO 增量值不能为 0 。如果在 I/O 隐含 DO、在数组构造函数隐含 DO 或在 DATA 隐含 DO内检测到 0 增量值，将生成该错误。同时，当外层循环迭代时，一个倚赖于外部隐含 DO 变量值的增量值不能求值到 0。

消息标识：ERROR_1084

## Error:名称列表组具有 PUBLIC 属性，因此名称列表组对象不能具有 PRIVATE 组件。

如果名称列表组具有 PUBLIC 属性，那么在名称列表组对象列表中的任何项目都不能具有 PRIVATE 属性。同时，派生类型的名称列表组项不能有具有 PRIVATE 属性的组件。

消息标识：ERROR_1085

## 警告：为此内在函数的参数指定了多于一个的实际参数。

编译器发现为一个特定的伪参数指定了多于一个的实际参数。这可能是由两个相同参数关键字导致，或者由同一伪参数的一个参数关键字和一个位置参数导致。

消息标识：WARNING_1086

## Error:该内在函数的参数有错误的等级。

检测到此内在函数的伪参数等级与实际参数等级有差异。

消息标识：ERROR_1087

## Error:该内在函数的参数有错误的类型。

检测到此内在函数的伪参数类型与实际参数类型有差异。

消息标识：ERROR_1088

## Error:该内在函数的参数有错误的种类类型。

检测到此内在函数的伪参数种类类型参数与实际参数种类类型参数有差异。

消息标识：ERROR_1089

## Error:没有指定内在函数所需的参数。

内在函数所需的参数没有指定。

消息标识：ERROR_1090

## Error:该 POINTER 实际参数的等级和 POINTER 伪参数的等级不匹配。

如果伪参数是 POINTER，实参数也必须是 POINTER。而且，类型、类型参数和等级必须一致。

消息标识：ERROR_1091

## Error:CRI 指针具有多个指针对象，这些指针对象具有不同的数值长度类型。

一个 CRI 指针可以有多个指针对象，但是如果这样，所有的指针对象必须设定为具有相同数值长度的类型。例如： real(kind=4) ::A real(kind=8) ::B pointer(PA,A) pointer(PA,B) This is illegal, because the length of a real(kind=4) type is shorter than the length of a real(kind=8) type. 备注：CRI 字符指针允许有具有不同字符长度的多个指针对象。

消息标识：ERROR_1092

## Error:该内在过程的输出参数与其他实际参数不一致。

内在子例程的输出参数必须与其它内在函数的参数一致。

消息标识：ERROR_1093

## Error:它已声明为语句函数伪参数，因此不能作为外部函数名使用。

一个语句函数伪参数必须是一个标量数据对象，而且必须用作标量数据对象。下面的示例说明了此问题：在示例中，X 是语句函数伪参数，但是在语句函数表达式里对 X 的引用是作为函数引用的。 PROGRAM P G(X) = X(3) END SUBROUTINE

消息标识：ERROR_1094

## 内部：预分析的格式常量具有无效的形式。

这是一个内部编译器错误。用于 FORMAT 语句的预分析器返回一个无效的结果。

消息标识：INTERNAL_1095

## Error:在该上下文中假定大小数组是非法的。

转换内在函数的数组参数不允许是假定大小数组。

消息标识：ERROR_1096

## Ansi：如果组中所有对象都是非缺省数值类型，则在等价组中混合种类类型是非标准的。

如果 equivalence_object 的内在类型不是缺省整数、缺省实数、双精度实数、缺省复数、或缺省逻辑，则此等价集中的所有对象都必须是具有相同种类类型参数值的相同类型。

消息标识：ANSI_1097

## Error:它是 USE 语句指定的 MODULE 名称，因此它不能作为重命名或唯一名称指定。

编译器发现在重命名或唯一名列表中指定了该模块名。必须重命名模块名称。下面的示例说明了此问题： MODULE ABC integer one END MODULE PROGRAM P USE ABC, NEW_ABC => ABC !Illegal to rename module name END PROGRAM

消息标识：ERROR_1098

## Error:INTEGER 变量用作 FORMAT 说明符，但是它没在 ASSIGN 语句中指定。

如果 INTEGER 变量在 ASSIGN 语句中用有效的 FORMAT 语句标记使用过时，才允许 INTEGER 变量作为 FORMAT 说明符使用。编译器检测到没有遇到这有此变量的 ASSIGN 语句。

消息标识：ERROR_1099

## Error:具有 PRIVATE 组件的派生类型的 I/O 列表项目是不允许的。

如果最终包含在派生对象内的任何组件在包含输入/输出语句的作用单元内无法存取的话，则该派生类对象不能作为输入/输出列表项显示。当一个派生类对象是与一个模块（派生类型定义包含私有组件）关联使用时，将发生这种情况。

消息标识：ERROR_1100

## Error:在 DATA 值列表中的标识符必须是标量命名常量的名称。

在 DATA 语句的值列表中的值可以是文字常量或是命名常量。如果出现命名常量，则它必须是一个标量命名常量名（而不是一个是数组的数组常量）。例如，下面程序是错误的： INTEGER, PARAMETER ::f(2) = (/ 1, 2 /) INTEGER ::array(2) DATA array /f/ F 是一个命名常量名，该命名常量是一个数组，因此不能在一个 DATA 语句值列表中出现。

消息标识：ERROR_1101

## 注意：CRI 指针有多个不同类型的指针对象。这可能是不可移植的。

一个 CRI 指针可以有多个指针对象，但是为了可移植，所有的指针对象应用被设定为具有同样数值长度的类型。例如： real(kind=4) ::A real(kind=8) ::B pointer(PA,A) pointer(PA,B) 这在 PVP 上合法，但是如果将此代码移植到 32 位系统上，则 A 按 32 位存储而 B 按 64 位存储。这意味着指针 PA 指向 2 个具有不同存储大小的项。这在 32 位系统上将标记为非法。 备注：CRI 字符指针允许有具有不同字符长度的多个指针对象。

消息标识：CAUTION_1102

## 注意：过程有 RECURSIVE 属性，因此对于此过程将忽略 -ev（保存所有选项）。

-ev 选项告诉编译器在编译单元里静态分配所有局部变量。如果一个过程是递归的，则静态分配局部变量有可能引起编译器无法预料的行为。因此，对于所有递归过程以及包含在递归过程中任何过程，编译器将忽略 -ev 选项。如果递归过程需要 saveall 选项，则在该过程以及任何包含的过程里指定 SAVE 语句。

消息标识：CAUTION_1103

## Log_Warning：-eR 选项覆盖 -ev 选项。

-eR 选项是指在编译单元的所有过程里的隐含递归。-ev 选项是指对于编译单元里的所有过程中，应用 saveall。为一个递归过程指定saveall 可能会在执行时引起不确定或者不想要的结果。因此，编译器不允许在命令行里指定 –ev 和 –eR 选项。如果需要 saveall 选项，则可以在编译单元的每一个过程里指定 SAVE 语句。

消息标识：LOG_WARNING_1104

## Error:解开指令之后必须是 EOS 或用于解开数的正整数值。

UNROLL 指令的语法是： UNROLL[n] 其中 n 是一个可选的正整数初始化表达式，该表达式用作解开计数。

消息标识：ERROR_1105

## Error:SHAPE 参数必须有恒定大小并且必须小于 8。

RESHAPE 内在函数的 SHAPE 参数必须是具有恒定大小的一维数组。

消息标识：ERROR_1106

## Error:函数必须是当前正在编译的函数或假定大小字符类型的伪过程。

如果函数是假定大小字符，则它必须是正在编译的当前函数或者是一个伪过程。调用者决定函数的字符长度。

消息标识：ERROR_1107

## Error:实际参数类型与伪参数类型不匹配。

检测到被调用例程的显式接口中提供的实际参数的类型和伪参数的类型之间有差异。

消息标识：ERROR_1108

## Ansi：初始化空白公共区成员是非标准的。

对象是由 DATA 语句或类型声明语句中的初始化值来初始化的。该对象是空公共块的一个成员。初始化一个空公共块成员是非标准的。如果希望初始化一个公共块成员，请用命名公共块。

消息标识：ANSI_1109

## 警告：在此平台上不支持 DOUBLE PRECISION。将使用 REAL。

在此平台上不支持 DOUBLE PRECISION。编译器将使用 REAL 精度。

消息标识：WARNING_1110

## Error:编译器指令 NAME 上等号后面的外部名称必须是字符文字。

CDIR$ NAME 行的等号后遇到了除字符文字常量外的内容。

消息标识：ERROR_1111

## Error:ENCODE 和 DECODE 的目的和源无效。它必须是变量、数组元素或者整个数组的引用。

ENCODE 和 DECODE 语句尚未扩展到包含 Fortran 90/95 的特定功能。这意味着仅有变量、数组元素或者整个数组能够在目的或源中使用。不允许使用字符子串、数组段、派生类型组件、Fortran 指针和可分配数组。当这些对象是 CHARACTER 类型时，推荐使用内部文件 I/O 。

消息标识：ERROR_1112

## Error:说明符必须是标量。

IO 控制项说明符必须是标量表达式、变量或者数组元素。

消息标识：ERROR_1113

## 内部：定义不一致。该编译器没有正确建立。

这是一条仅在调试模式下出现的内部消息。在 defines.h 中设置的 # defines已经在一个不正确的组合里设置过了。为找出问题，请检查 defines.h 。

消息标识：INTERNAL_1114

## 限制：超出一个范围的交替项目的最大编号。

出现内部错误条件，因为内部数对于其字段大小来说变得太大。

请通知您的产品支持机构。可以将代码分割为多个程序单元，这样就可以成功地完成编译。

消息标识：LIMIT_1115

## 内部：定义必须在适当的建立段下面的 defines.h 里指定。

编译器未正确地建立。所列定义的一个或其它定义必须在 defines.h 内描述正在建立的编译器的段下面设置。这是一个内部错误，仅在建立编译器时出现。

消息标识：INTERNAL_1116

## 内部：create_struct_argchck_tbl 中出现内部错误。

内部编译器错误。

消息标识：INTERNAL_1117

## Error:在此平台上不支持 TASK COMMON 语句。

在此平台上不支持任务公共块。

消息标识：ERROR_1118

## 内部：内部编译器错误。实际参数数量与伪参数数量不匹配。

此内部编译器错误消息指出,用户调用点处理或者内在调用遇到了不正确的内部信息，该内部信息与被调用程序单元的接口有关。

消息标识：INTERNAL_1119

## Error:这不是 DIM 参数的合法值。

用户选择了一个值，而编译器确定该值对于此内在函数的 DIM 参数是无效。请检查 DIM 参数值的正确范围的标准。

消息标识：ERROR_1120

## Error:在平行区域中不允许有此 NUMCPUS 任务指令。

f90 任务实现不允许在并行区域里指定 \*NUMCPUS 任务指令。平行区域既可能是 DOALL 循环，也可能是由 PARALLEL/ENDPARALLEL 对限制的代码区域。

消息标识：ERROR_1121

## 警告：NUMCPUS 任务指令中的指定值无效。其范围必须是 1 到 64，因此它被重置。

NUMCPUS 任务指令中的定值必须大于零并且小于或等于 64 。

消息标识：WARNING_1122

## 注意：忽略 CNCALL 任务指令的参数。

编译器将忽略在 CNCALL 任务指令行中指定的参数。

消息标识：CAUTION_1123

## Error:NUMCPUS 任务指令必须有指定值，该值的取值范围是 1 到 64。

NUMCPUS 任务指令的值必须是 1 到 64 之间。NUMCPUSS 指令的语法是：NUMCPUS(value) 其中 value 从 1 到 64 之间取值，包括 1 和 64。

消息标识：ERROR_1124

## Error:VAL 内在过程参数的无效类型。

%VAL 内在函数仅支持标量 INTEGER、LOGICAL 和 REAL 变量及表达式。如果程序单元是参数，则 %val 内在函数没有影响。传递程序单元的地址，就好像没有使用 %val 内在函数一样。

消息标识：ERROR_1125

## Error:PERMUTATION 任务指令上指定的对象必须是整型数组。

PERMUTATION 任务指令要求指令中指定的所有对象是整数数组。

消息标识：ERROR_1126

## 注意：转换中截断位值。

在表达式或赋值中使用了无类型的常量，而且转换导致截断位值。将应用下面的规则。 如果它是数值无类型常量 (BOZ 或布尔型) 而且大于运算的结果类型，则位值在左侧被截断。如果它是一个霍尔瑞斯常量，“H”霍尔瑞斯常量在右侧截断，“L”常量在右侧截断，而“R”常量在左侧截断。无类型的字符文字常量（一个 CRI 扩展）在右侧截断。

消息标识：CAUTION_1127

## Error:公共块是在 COMMON 指令中指定的，因而必须在 COMMON 语句中指定。

如果在 CDIR$ (!DIR$) COMMON 语句中指定了公共块，还必须在 COMMON 语句中声明该公共块。

消息标识：ERROR_1128

## Error:公共块可以在 COMMON 指令中指定，或者作为 TASK COMMON 指定，但是不要同时作为两者指定。

不能同时在 TASK COMMON 指令和 COMMON 指令中指定公共块。不能同时在 TASK COMMON 语句和 COMMON 指令中指定公共块。

消息标识：ERROR_1129

## 警告：在下一版本中，将删除 INTEGER(KIND=6) 和 INTEGER*6 声明。

从编译器的下一个版本开始，将不再支持 INTEGER(KIND=6) 和 INTEGER*6 声明格式。 在 INTEGER(KIND=6) 缺省值为 6 的64 位平台上，新的缺省值将是 INTEGER(KIND=8)。从这些平台的下一个版本开始，结合了缺省整数的命令行选项 "-O fastint" 将为缺省整数的当前行为提供等价行为。 在 32 位平台上，INTEGER(KIND=6) 和 INTEGER*6 目前被映射到 INTEGER(KIND=4) 和 INTEGER*4 上。对于更大的整数类型，请用能够提供 64位整数类型的 INTEGER(KIND=8) 。

消息标识：WARNING_1130

## Log_Warning：在 f90 的下一版本中将删除“-i 46”选项。使用“-O fastint”代替。

“-i 46”选项不再适用，因为，为了快速的整数运算，在不同的体系结构上使用不同的位长。因此，已引入了更通用的“-O fastint”选项。在 f90 的下一版本中将删除“-i 46”选项。使用“-O fastint”选项代替。

消息标识：LOG_WARNING_1131

## Log_Warning：编译器尝试打开该文件搜索模块。

编译器试图打开一个在 -p 命令行上指定的文件。打开例程返回了指定的错误。编译器也许试图打开一个先前在此编译过程中创建的临时文件，该文件包含在此编译期间编译的某模块的信息。

消息标识：LOG_WARNING_1132

## Error:该霍尔瑞斯常数大于 256 位。

用作数值常量的霍尔瑞斯常量不能大于 256 位。

消息标识：ERROR_1133

## Error:它已经是个符号常量了，因此不能赋予那种属性。

N$PES 是特殊符号常量。编译器将它定义为 INTEGER 型，并且不可以更改类型。不可以对 N$PES 指定任何属性。它可以在合法使用符号常量的地方用作符号常量。N$PES 的值由编译器命令行选项、装入时选项或运行时选项设置。

消息标识：ERROR_1134

## Error:它已经是个符号常量了，因此不能使用该方式声明。

N$PES 是特殊符号常量。编译器将它定义为 INTEGER 型，并且不可以更改类型。不可以对 N$PES 指定任何属性。它可以在合法使用符号常量的地方用作符号常量。N$PES 的值由编译器命令行选项、装入时选项或运行时选项设置。

消息标识：ERROR_1135

## Error:它是符号常量，因此不能将其声明为过程或作为派生类型使用。

N$PES 是特殊符号常量。编译器将它定义为 INTEGER 型，并且不可以更改类型。不可以对 N$PES 指定任何属性。它可以在合法使用符号常量的地方用作符号常量。N$PES 的值由编译器命令行选项、装入时选项或运行时选项设置。

消息标识：ERROR_1136

## Error:它是标量整型符号常量，因此不能是数组、字符类型或在公共区中。

N$PES 是特殊符号常量。编译器将它定义为 INTEGER 型，并且不可以更改类型。不可以对 N$PES 指定任何属性。它可以在合法使用符号常量的地方用作符号常量。N$PES 的值由编译器命令行选项、装入时选项或运行时选项设置。

消息标识：ERROR_1137

## Error:它是符号常量，因而不能是名称列表组中的对象。

N$PES 是特殊符号常量。编译器将它定义为 INTEGER 型，并且不可以更改类型。不可以对 N$PES 指定任何属性。它可以在合法使用符号常量的地方用作符号常量。N$PES 的值由编译器命令行选项、装入时选项或运行时选项设置。

消息标识：ERROR_1138

## Error:只能在 DO PARALLEL 指令中指定一个工作分配。

在 DO PARALLEL 指令中有一个以上工作分配是不合法的。

消息标识：ERROR_1139

## 警告：在此平台上不支持工作分配参数 NCPUS_CHUNKS。

在此平台上不支持工作分配参数 NCPUS_CHUNKS。缺省值是 SINGLE，如果未指定其它工作分配，将使用缺省值。

消息标识：WARNING_1140

## Error:在此编译器指令中仅允许变量名称。

在 BOUNDS 或 NOBOUNDS 编译器指令中遇到不是变量名或伪参数名的名称。

消息标识：ERROR_1141

## Error:在 MODULE 的规范部件中不能指定 STACK 指令。

在 MODULE 的规范部件中不能指定 STACK 指令。在 MODULE 的规范部件中，缺省的存储总是静态存储，不能用 STACK 指令更改。

消息标识：ERROR_1142

## Error:在接口体或接口块内不能指定 STACK 指令。

在接口体或接口块内不能指定 STACK 指令。该指令在此处没有意义。

消息标识：ERROR_1143

## 警告：在同一范围中指定了没有保存实体列表的 SAVE 语句和一个 %s 指令。优先执行 SAVE。

编译器在同一范围检测到一条未保存实体列表的 SAVE 语句和一个 STACK 或 SYMMETRIC 指令。SAVE 语句的优先级超过该指令。STACK 指令指示编译器将所有局部变量放在栈中，但 SAVE 语句指示编译器将所有局部变量放在静态存储器中。SAVE 占先，因为它是 Fortran 语言的标准部分。在MPP 平台上有效的 SYMMETRIC 指令也表示局部变量使用栈存储器。由于相同的原因，SAVE 优先于 SYMMETRIC。

消息标识：WARNING_1144

## 警告：128 位浮点运算的结果当前可能精度较低。

128 位浮点运算的结果当前可能精度较低。这包括任何类型为DOUBLE PRECISION、DOUBLE PRECISION*16、REAL (kind=16)、REAL*16 和 DOUBLE COMPLEX 的内容。

消息标识：WARNING_1145

## 警告：在下一版本中将删除 !DIR$ INTEGER=46 指令；“-O fastint”将提供等效操作。

f90 在下一版本不再支持 !DIR$ INTEGER=46 指令。f90 命令行选项 “-O fastint”将提供等效的操作。 备注：仍接受 !DIR$ INTEGER=32 和 !DIR$ INTEGER=64。

消息标识：WARNING_1146

## Error:为此对象同时指定了 INLINE ALWAYS 和 INLINE NEVER 指令。仅可指定一个。

编译器发现为同一个对象指定了 INLINE ALWAYS 和 INLINE NEVER 指令。对一个对象只能指定二者之一。

消息标识：ERROR_1147

## 内部：不能建立消息文件。

应避免产生此消息。编译器在建立消息文件时遇到错误或意外。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。

消息标识：INTERNAL_1148

## 警告：引用了 N$PES，但未用 -X 选项提供值。N$PES 的使用值将为 0。

目前，F90_M 仅支持编译时 N$PES。任何引用 N$PES 的程序必须用 –X 命令行选项为 N$PES 提供编译时值。如果在命令行中未提供值，编译器将为 N$PES 使用的值为 0。

消息标识：WARNING_1149

## 内部：行号无效。

内部编译器错误。运算符中的行号信息是无效号码。这表示它未正确设置。

消息标识：INTERNAL_1150

## Error:已在 USE 语句中引用了模块。不能使用 MODULE 语句重新定义它。

Fortran 标准规定：两个全局名称相同是不合法的。这使得以下情况不合法： m.f:module m integer ::i=2 end module m1.f:program p use m ... end program module m ! This is illegal because a module m has been ! previously referenced. integer ::i=4 end module subroutine s() use m ... end subroutine

消息标识：ERROR_1151

## Error:MATRIX_B 的第一维（或唯一）大小必须等于 MATRIX_A 的最后一维（或唯一）大小。

MATRIX_B 的第一维（或唯一）大小必须等于 MATRIX_A 的最后一维（或唯一）大小。

消息标识：ERROR_1152

## Error:PACK 内在函数存在无效参数。

PACK 内在函数的 VECTOR 的参数必须与 ARRAY参数有相同的类型和种类类型参数。另外，VECTOR 参数必须是一级。

消息标识：ERROR_1153

## Error:UNPACK 内在函数的 FIELD 参数无效。

FIELD 参数必须与 VECTOR 参数有相同的类型和种类类型参数。

消息标识：ERROR_1154

## Error:MASK 参数必须与 ARRAY 一致。

PACK 内在函数的 MASK 参数必须与 ARRAY 参数一致。

消息标识：ERROR_1155

## Error:POS 参数的值非法。

POS 参数必须非负，并且小于 BIT_SIZE(I)。

消息标识：ERROR_1156

## 警告：模块文件是用前一编译器版本创建的。在下一主要版本中，将不支持它。

模块文件是用此编译器的前一主要版本创建的。我们保证向上兼容一个主要版本，因此在下一主要版本，此模块文件需要重建。

消息标识：WARNING_1157

## Error:ELSE IF 块不能跟随 ELSE 块。

如果 IF 构造包含 ELSE 块，ELSE WHERE 一定是构造中的最后一块。因此，ELSE IF 块不能跟随 ELSE 块。

消息标识：ERROR_1158

## 内部：库格式解析器生成编译器不能识别的消息编号。

库格式分析器与编译器不同步。

消息标识：INTERNAL_1159

## Ansi：NULL 编辑描述符是 Fortran 标准的一个扩展。

编译器在格式规范中检测到“,,”。Fortran 标准在格式规范中不允许逗号与逗号相连。

消息标识：ANSI_1160

## 注意：变量对齐通常可能引起性能降低。

在 32 位体系结构中，如果多字项按 64 位边界（而不是 32 位边界）对齐，可以获得性能优势。正在讨论的对象因为其在公共块中的位置，未按双字边界对齐。在公共块声明中，可以在此对象之前插入 32 位（缺省整数）大小的对象。这将使该对象按 64 位边界对齐。第二种方法是在命令行中指定 -a dalign。这将使编译器在对象之前插入 32 位填充。无论何时插入此填充，都将发出警告。

消息标识：CAUTION_1161

## Log_Warning：在此平台上 -i 46 即是 -i 32 或 -i64。在该编译器的下一版本中将删除 -i 46。

-i 46 命令行选项将被视为在命令行中指定了 -i 32 或 -i64（取决于平台）。在此编译器的下一版本中，将删除 -i 46 命令行选项。

消息标识：LOG_WARNING_1162

## 警告：在此平台上 !DIR$ INTEGER=46 即是 INTEGER=32 或 INTEGER=64。在下一版本中将删除 !DIR INTEGER=46 指令。

视不同的平台而定，!DIR$ INTEGER=46 视为 !DIR$ INTEGER=32 或 !DIR$ INTEGER=64。在此版本之后，不再支持 !DIR$ INTEGER=46。

消息标识：WARNING_1163

## 内部：条件编译例程中出现内部编译器错误。

在支持条件编译的例程中发生内部编译器错误。

消息标识：INTERNAL_1164

## Error:条件编译遇到未预料的语法。

在分析条件编译指令时遇到语法错误。

消息标识：ERROR_1165

## Error:条件编译块错误。

遇到意外的条件编译指令。这是块错误，其中类似 ENDIF、ELSE 或 ELIF 的条件编译指令没有相应的 IF、IFDEF 或 IFNDEF 指令。

消息标识：ERROR_1166

## Error:条件编译错误。引用了标识符，但未定义它。

在条件编译指令的表达式中遇到以前未用 # define 语句定义的标识符。

消息标识：ERROR_1167

## Error:公共块是在 CACHE ALIGN 指令中指定的，因而必须在 COMMON 语句中指定它。

如果在 CDIR$ (!DIR$) CACHE ALIGN 语句中指定了公共块，还必须用 COMMON 或 TASK COMMON 语句声明该公共块。

消息标识：ERROR_1168

## 警告：必须在模块范围内指定 !DIR$ [NO]MODINLINE。

编译器在PROGRAM、BLOCKDATA、外部 SUBROUTINE 或外部 FUNCTION 范围内检测到 MODINLINE 或 NOMODINLINE 指令。该指令只能在模块或该模块包含的过程内指定。

消息标识：WARNING_1169

## 警告：已指定 –eS（全部保存）命令行选项。将忽略 !DIR$ SYMMETRIC 指令。

-eS 命令行选项导致所有局部变量保存在静态存储器中。!DIR$ SYMMETRIC 指令仅影响局部栈变量。由于 –eS 选项，没有变量放在栈中，因此，!DIR$ SYMMETRIC 指令不执行任何操作。

消息标识：WARNING_1170

## Error:因为指定了 -eI, IMPLICIT NONE 命令行选项，必须为此对象指定一个显式类型。

-eI 命令行选项要求在编译的每个过程中指定一个 IMPLICIT NONE。对于此编译该命令行已生效。列出的对象需要指定显式类型。

消息标识：ERROR_1171

## Log_Warning：-s cf77 类型仅限 FORTRAN 77 程序。如果和 Fortran 90 程序一起使用，可能产生无法预料的后果。

-s cf77types 选项是为了使在非字符型声明中使用星号（如 INTEGER*8）的FORTRAN 77 程序能够继续以 CF77 编译器的工作方式工作。f90 编译器将使用星号的声明视为使用种类类型参数值的声明；例如，INTEGER*8 与 INTEGER(KIND=8) 的意义相同。编写所有新 Fortran 程序时都应记住这一点。 注意：-s cf77types 将替代 -si 选项，因为它是更具描述性的名称。

消息标识：LOG_WARNING_1172

## 内部：目标字位大小使用了无效值。仅 32 和 64 是有效的位大小。

许多实用例程将字位大小用作输入。此编译器目前仅支持 32 和 64 位字。必须向实用例程传递 32 或 64。

消息标识：INTERNAL_1173

## Error:虚拟向量元素长度超出了最大长度。

超出了虚拟向量元素长度。

消息标识：ERROR_1174

## Error:当计算数组边界、字符长度或偏移时发生整数溢出。

编译器执行内部简化，以计算如数组长度、数组元素间跨度、结构大小、组件大小、对象大小、存储器分配偏移等项目。在尝试计算一项时，产生整数溢出。

消息标识：ERROR_1175

## Error:RESHAPE 内在函数的 SHAPE 数组包含负数值。

用于 RESHAPE 内在函数调用的 SHAPE 数组不能包含任何负值元素。

消息标识：ERROR_1176

## Error:条件编译错误 (#error)。

遇到 #error 条件编译指令。此错误消息中包含指令文本。

消息标识：ERROR_1177

## Error:不能继续条件编译 ERROR 指令。

条件编译 ERROR 指令使用的消息文本必须适合一行长度。行的长度为 Fortran 源代码行的长度，这取决于源代码格式和 -N 命令行选项。

消息标识：ERROR_1178

## 内部：内部编译器错误。folder_driver 调用中的类型无效。

调用 folder_driver 例程时所用的运算符结果类型不正确，或者参数类型不正确。

消息标识：INTERNAL_1179

## Error:它在 POINTER 语句中已被命名为指针对象。现在不能指定字符类型。

字符型指针对象必须声明为假定大小字符变量。字符型指针对象数组无效。

消息标识：ERROR_1180

## Error:必须重新编译模块文件。不支持它的格式。

指定的模块文件是用先前版本的编译器或已不再支持的旧编译器编译的。（我们承诺支持当前版本的前一个主要版本。）当前版本编译器已更改模块格式，而模块文件有不支持的格式。

消息标识：ERROR_1181

## Log_Error：已指定“-O taskinner”，因此必须指定“-O task2”或“-O task3”。

已指定了优化选项“taskinner”。因此，还必须指定优化选项“task2”或“task3”。

消息标识：LOG_ERROR_1182

## Error:必须重新编译模块文件。它由 f90 以后的版本创建。

指定的模块文件是用比此编译器版本更高的编译器编译的。其中有此编译器不支持的格式，必须重新编译。

消息标识：ERROR_1183

## 警告：该常量表达式的求值产生了 NaN 或其它异常值。

当计算常量表达式的值时，编译器遇到异常值，如 NaN。常量表达式是仅包含常量的表达式。表达式的值在编译时确定，而不是在运行时确定。此警告可能在中间计算（例如，加、减、乘、除或求幂）过程中出现，或者在计算过程中需要数据转换（例如，从双精度转换为实型）时出现。

消息标识：WARNING_1184

## Log_Warning：“-O pattern”选项暂时禁用。

libsci 尚不可用，因此暂时禁用“-O pattern”选项。如果指定，将被忽略。

消息标识：LOG_WARNING_1185

## Error:IACHAR 和 ICHAR 的实际参数必须具有一个字符的长度。

IACHAR 和 ICHAR 的实际参数必须是长度等于 1。

消息标识：ERROR_1186

## Error:对于提供的 SOURCE 参数，指定的 SHAPE 参数无效。

为 SOURCE 参数提供的数组构造函数中元素的数量不等于 SHAPE 参数指定的范围的乘积。

消息标识：ERROR_1187

## Error:该按位内在过程或运算符的参数必须有相同大小。

按位内在运算（如 AND 和 OR）的参数必须有相同的字长。在 Solaris 上，不允许： integer * 8 i real * 4 x print *, or(i,x) 在 Solaris 上也不允许： print *, i.or.x

消息标识：ERROR_1188

## 警告：此数值常量超出范围。

发现数值实型常量超出指定数据类型的范围。此警告指出发生了上溢/下溢，并且为常量保存了适当的 IEEE 值 (Inf, -Inf)。

消息标识：WARNING_1189

## 内部：内部编译器错误。发送到 cvrt_str_to_cn 的类型或常量无效。

这是一个内部编译器错误。

消息标识：INTERNAL_1190

## 内部：expr_sem 中存在不支持的运算符。

内部编译器错误。

消息标识：INTERNAL_1191

## Log_Warning：两选项冲突，因此忽略第一个选项。

两个选项冲突。在 f90 命令行上，消息中提及的第一个选项在消息中提及的第二个选项之前指定。将忽略第一个选项（第二个选项覆盖它）。例如，如果在 f90 命令行中指定“-O fastint”，然后指定“-i 64”，则忽略“-O fastint”选项（“-i 64”覆盖它）。

消息标识：LOG_WARNING_1192

## 注意：另一个模块间接使用已不存在的一个文件中的模块。

使用模块时，用来查找该已编译模块的路径和文件名信息保存在模块信息中。载入程序使用该保存信息查找已编译模块，以进行装载。（模块可能包含模块过程和/或装入步骤中需要的初始化数据。） 间接使用模块是指模块 B 使用模块 A，而模块 C 使用模块B。则模块 A 由模块 C 间接引用。间接使用模块时，编译器检查该已编译模块文件是否可用。如果编译器不能检测到该已编译模块文件，将生成此“注意”消息。编译将成功完成，而不依赖于该编译模块文件。装入步骤确实需要该编译模块文件，因此在装载行中必须指定文件的当前位置。

消息标识：CAUTION_1193

## Ansi：Dw.dEe 编辑描述符的使用是 Fortran 标准的一个扩展。

Dw.dEe 编辑描述符是非标准的。Dw.d 是有效的 Fortran 编辑描述符。附加的 Ee 使它成为非标准的。

消息标识：ANSI_1194

## 警告：可能函数结果类型冲突。-i32 将类型更改为半字整数。

此编译使用了命令行选项 -i32。在 MPP 上，此选项对声明为缺省整型的项仅分配半个字存储器。在此函数中，一个或多个结果是缺省整型的，并且一个或多个结果是缺省整型外的其它类型。使用 -i32，缺省整型结果现在仅分配半个字，而不是整个字存储器。不更改其它结果类型。使用 -s default32 可以将所有缺省类型更改为半字。

消息标识：WARNING_1195

## Log_Warning：一个命令行选项将被另一选项替代。前者在下一版本中不再有效。

在第 3 版中将删除的第 2 版命令行选项有：命令行选项 -O unroll 与 -O unroll2 相同。选项 -O nounroll 与 -O unroll0 相同。将删除 -O unroll 和 -O nounroll，以避免重复。 在第 3 版中将删除的第 3 版命令行选项有：命令行选项 -si 与 -scf77types 相同。将 -si 重命名为 -s cf77types，以使用更具描述性的名称。

消息标识：LOG_WARNING_1196

## Error:下标越界。

在下标超出数组边界时，遇到数组引用。如果指定 -RM 并且下标和边界值是常量，编译器在编译时将检查数组边界。

消息标识：ERROR_1197

## 注意：数值序列结构中的组件对齐可能引起性能降低。

在 32 位体系结构中，如果多字项按 64 位边界（而不是 32 位边界）对齐，可以获得性能优势。正在讨论的组件因为其在派生类型中的位置，未按双字边界对齐。在派生类型声明中，可以在此组件之前插入 32 位（缺省整型）大小的组件。这将使组件按 64 位边界对齐。第二种方法是在命令行中指定 -a dalign。这将使编译器在组件之前插入 32 位填充。无论何时插入此填充，都将发出警告。以下是这种情况的两个示例： .... TYPE X SEQUENCE INTEGER ::A COMPLEX ::B END TYPE TYPE(X) ::Q TYPE(X) ::R SAVE Q,R 在上面的示例中，假定 Q 位于局部静态存储块中偏移 0，而 R 位于偏移 96。这意味着 Q%B 不按双字边界对齐，但 R%B 按双字边界对齐。 .... TYPE A SEQUENCE COMPLEX ::X INTEGER ::Y COMPLEX ::Z END TYPE 在此示例中，如果不在组件 Z 之前插入 32 位填充，X 组件和 Z 组件将无法同时实现双字对齐。

消息标识：CAUTION_1198

## Log_Warning：内联不能与调试结合使用。内联已被关闭。

内联不能与调试配合使用。

消息标识：LOG_WARNING_1199

## 内部：名称表中输入了无效名称。名称不能为 NULL 并且长度必须大于 1。

输入名称表的名称必须是有效名称。它不能是 NULL，并且长度必须大于 0。

消息标识：INTERNAL_1200

## 内部：块或对象的偏移或长度必须是常量。它不是。

对于公共块、静态块和其它用户声明区域，偏移和块长度可能基于 N$PE。编译器检测到在需要使用真常量的地方使用了 N$PE 常量。

消息标识：INTERNAL_1201

## 内联：未内联例程。

有些条件禁止内联例程。例如：不能内联包含 ASSIGN 语句的例程。

消息标识：INLINE_1202

## 内部：create_constructor_constant 中的错误假定。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_1203

## 内联：内联该调用

该例程原地扩展。不再存在调用开销。

消息标识：INLINE_1204

## Error:伪参数比实际参数长。

字符型实际参数的相关伪参数的长度比该实参长。字符类型的实际参数的长度必须大于或等于关联伪参数的长度。

消息标识：ERROR_1205

## Error:对于此语句，星号不允许作为 UNIT 控制项说明符。

仅当用于 WRITE、PRINT 或 READ 语句时，UNIT= 说明符才可以是星号。

消息标识：ERROR_1206

## Error:对于无格式的 I/O，星号不能用作 UNIT 控制项说明符。

在 READ、WRITE 或 PRINT I/O 语句中，如果 I/O 未格式化，则 UNIT 说明符不能是星号。

消息标识：ERROR_1207

## Ansi：在给定关键字的 UNIT 说明符之后使用没有关键字的 FMT 或 NML 说明符，是 Fortran 标准的一个扩展。

当第一个说明符是格式为“UNIT= 关键字”的 UNIT 说明符，而第二个参数没有关键字时，F90 允许 IO 控制列表违反关键字参数规则。通常，这将导致出错，因为没有关键字编译器不知道说明符是什么。在且仅在此情况下，编译器假定第二个说明符是 FORMAT 或 NAMELIST 说明符。 WRITE ( UNIT = 10, *) I

消息标识：ANSI_1208

## 内联：例程被有条件地扩展内联。

在数组映射中检测到非常量跨度乘数。生成条件测试，以确定应该执行调用还是应该执行内联例程。

消息标识：INLINE_1209

## Error:包含指定 GOTO 语句的子程序不能包含自动任务指令。

在子程序中遇到包含自动任务指令的指定 GOTO 语句。不允许分支转入或转出平行区域，而赋值 GOTO 语句有此能力。

消息标识：ERROR_1210

## Error:字符长度依赖于运行时 N$PES 符号常量。这是不允许的。

运行时 N$PES 只能用于数组边界。它不能用于声明字符长度。

消息标识：ERROR_1211

## Error:初始化表达式不能包含符号常量。

在初始化表达式中不允许有符号常量。它们必须是真常量。不允许有符号常量的示例还包括组件边界和种类类型。

消息标识：ERROR_1212

## 内部：它必须是常量或符号常量暂存器。

ATD_OFFSET_IDX 和 SB_LEN_IDX 必须是由编译器临时表示的常量值或符号常量。

消息标识：INTERNAL_1213

## Error:INTENT OUT 伪参数不能有按实际参数传递的常量。

用户试图将常量实际参数映射到 INTENT OUT 伪参数。

消息标识：ERROR_1214

## Log_Warning：命令行选项“-du”不能用“-O ieeeconform”指定。“-eu”已生效。

IEEE 平台上可用的 -O ieeeconform 选项使所得到的可执行代码更符合 IEEE 浮点标准。 IEEE 平台上的 -du 选项导致使用更快速的除法序列，这在将结果转换为整数值时，或将结果与从其它支持 IEEE 浮点算法的系统获得的结果进行比较时，可能影响结果。IEEE 平台上的 -eu 选项导致生成真正的 IEEE 除法序列。 因此，由于 -O ieeeconform 需要可执行代码更符合 IEEE 浮点标准，应该使用 –eu，以生成真正的 IEEE 除法序列。

消息标识：LOG_WARNING_1215

## Log_Warning：命令行选项“-O ieeeconform”将缺省选项“-du”转换为“-eu”。

IEEE 平台上可用的 -O ieeeconform 选项使所得到的可执行代码更符合 IEEE 浮点标准。 IEEE 平台上的 -du 选项导致使用更快速的除法序列，这在将结果转换为整数值时，或将结果与从其它支持 IEEE 浮点算法的系统获得的结果进行比较时，可能影响结果。IEEE 平台上的 -eu 选项导致生成真正的 IEEE 除法序列。 因此，由于 -O ieeeconform 需要可执行代码更符合 IEEE 浮点标准，应该使用 –eu，以生成真正的 IEEE 除法序列。

消息标识：LOG_WARNING_1216

## Error:缺少用于此指令的自动任务指令。

在进入或终止范围或块前，所有平行区域和保护区域必须终止。在平行区域或保护区域中，如果遇到 CONTAINS 语句或 END、END FUNCTION、END SUBROUTINE 等语句，则出错。另外，平行区域或保护区域必须正确嵌入或完整包含类似于 IF、DO、CASE 或 WHERE 等结构代码块。

消息标识：ERROR_1217

## Log_Warning：命令行选项将在以后版本中实现。

指定的命令行选项的实现延迟到将来的修订版本或发行版本。

消息标识：LOG_WARNING_1218

## Error:此指令不在 DO 循环构造之前。

未找到 DO 循环结构的地方出现 DO PARALLEL 或 DO ALL 自动任务指令。DO PARALLEL 指令只能在平行区域内指定，并且必须在 DO 循环之前。DO ALL 不能在平行区域内指定，并且必须在 DO 循环之前。

消息标识：ERROR_1219

## Error:非法分支转移进或分支转移出自动任务区域。

分支转入/转出 PARALLEL、DOALL、CASE 或 GUARD 自动任务区域是不合法的。这包括 GOTO 语句以及 ERR=、EOF= 或 EOR= IO 语句的分支和子例程调用交替返回的分支。

消息标识：ERROR_1220

## Log_Warning：没有带参数指定 -O 命令行选项。它将被忽略。

-O 命令行选项指定编译优化选项。如果指定时不带参数，则被忽略，而不更改任何优化级别。

消息标识：LOG_WARNING_1221

## Error:UNPACK 内在函数的 FIELD 参数与 MASK 不一致。

UNPACK 内在函数的 MASK 和 FIELD 参数必须一致。

消息标识：ERROR_1222

## Error:它具有属性，因此不能是由符号常量表达式确定边界的数组。

编译器检测到此对象声明中有冲突。该对象不能声明为由符号常量表达式确定边界的数组，因为它被等价、数据初始化为、类型设定为假定长度字符，并且/或者有以下一个或多个属性： ALLOCATABLE DIMENSION PARAMETER SAVE PRIVATE PUBLIC POINTER EXTERNAL INTRINSIC VFUNCTION NOSIDE EFFECTS

消息标识：ERROR_1223

## Error:声明方式规定它不能是由符号常量表达式确定边界的数组。

编译器检测到此对象声明中有冲突。该对象不能是由符号常量表达式确定边界的数组，因为它已声明为以下项之一： Cray 指针 模块过程 派生类型 通用接口 名称列表组 语句 函数 结构 模块 块 数据 程序

消息标识：ERROR_1224

## 警告：字符常量内在参数已被转换为霍尔瑞斯变量。

字符常量用作内在函数的实际参数，但该函数不接受字符参数，而是接受布尔（或霍尔瑞斯）参数。在字符常量无效、而霍尔瑞斯常量合法的上下文环境中，F90 将字符常量视为霍尔瑞斯常量。

消息标识：WARNING_1225

## 限制：指定“-ea”选项以便在出现第一个错误时中止编译。

如果启用 -ea 选项，则遇到第一个错误时编译终止。

消息标识：LIMIT_1226

## Error:此公共块成员不能被初始化，因为块长度依赖于符号常量。

如果公共块中有长度基于符号常量的数组，则不能用数据初始化该公共块的任何成员，因为块的偏移和长度依赖于符号常量。

消息标识：ERROR_1227

## Error:公共块成员不能被等价，因为块长度依赖于符号常量。

如果公共块包含长度依赖于符号常量的数组，则该公共块中任何项都不能被等价。公共块中对象的偏移和块长度依赖于符号常量。

消息标识：ERROR_1228

## Ansi：符号常量的使用是非标准的。

使用符号常量（值在载入或运行时才确定的常量）不是 Fortran 标准的一部分。

消息标识：ANSI_1229

## Error:入口点是一个基于符号常量的数组。存在多个入口点，因此是不允许的。

如果函数有交替入口点，则该函数及其入口点一起被等价。由符号常量表达式确定长度的数组不允许等价，因此如果函数有多个入口点，任何入口点都不可以有长度基于符号常量表达式的数组。没有交替入口点的值确定的数组函数可以有长度基于符号常量表达式的数组。

消息标识：ERROR_1230

## Log_Warning：命令行选项 -Xm 和 -X # （此处 # 是 N$PES 数量）相互之间排它。最后一个 -X 占先。

命令行选项 -Xm 和 -X# 是相互排斥的。-Xm 表示可延展性。程序中不应该指定 N$PES。-X # 表示使用 # 个 pe 编译此程序。编译器使用命令行中最后一个指定的 -X 选项。

消息标识：LOG_WARNING_1231

## Error:已指定命令行选项 –Xm，所以不能在声明语句中使用N$PES。

-Xm 表示正编译的程序是可延展的，因此在程序单元声明段不应该指定 N$PES。只能在可执行代码中使用 N$PES。当指定了 -Xm 时，它不能用于声明数组边界。如果编译器发现在数组边界声明中引用了 N$PES，将生成错误消息。

消息标识：ERROR_1232

## Error:MODULE 的规范部件中不能指定此指令。

在 MODULE 的规范部件中不允许以下指令。 SYMMETRIC：此指令使基于栈的变量放在共享栈中。MODULE 的规范部件没有基于栈的变量，因此在 MODULE 中 SYMMETRIC 指令无意义。

消息标识：ERROR_1233

## 注意：SYMMETRIC 指令不适用于有冲突属性的变量。

指定不带变量名的 !DIR$ SYMMETRIC 将导致保存在栈中的所有变量保存在共享栈中。以下属性防止变量保存在共享栈中： TARGET AUXILIARY 变量将保存在非共享栈中。

消息标识：CAUTION_1234

## Error:不能用 !DIR$ SYMMETRIC 指令指定变量“%s”，因为该变量是主机关联的。

不能用 SYMMETRIC 指令指定主机关联变量。

消息标识：ERROR_1235

## 注意：SYMMETRIC 适用于变量“%s”，因为它是主机关联。

此时，主机关联的栈变量可以不保存在共享栈中。

消息标识：CAUTION_1236

## 内部：模块处理中的 I/O 问题。

模块处理遇到意外 I/O 问题。strerror 用于提供有关问题的更多提示。

消息标识：INTERNAL_1237

## Log_Error：这是 -X 命令行选项的无效参数。-X 的参数必须为 m 或范围为 1 到 2048。

-X npes 指定运行过程中使用的 npes 的数量。npes 必须是 m（可延展）或 1 到 2048 之间的一个整数。

消息标识：LOG_ERROR_1238

## Error:此等价集中的所有对象都必须是缺省数字或数字序列派生类型。但它不是。

以下自 Fortran 标准：“如果等价对象是缺省整型、缺省实型、双精度实型、缺省复型、缺省逻辑型或数值序列型，则该等价集中的所有对象都必须是这些类型。” 此编译器允许扩展，即可以在等价集中混合使用缺省数值类型和缺省字符类型。不允许将数值序列派生类型和缺省字符或字符序列派生类型混合使用。

消息标识：ERROR_1239

## Error:此等价集中的所有对象都必须是缺省字符或字符序列派生类型。但它不是。

以下自 Fortran 标准：“如果等价对象是缺省字符或字符序列派生类型，则该等价集中的所有对象都必须是这些类型。” 此编译器允许扩展，即可以混合使用缺省数值类型和缺省字符类型。不允许字符序列派生类型与缺省数值类型混用。

消息标识：ERROR_1240

## Error:对象是非缺省的内在类型。此等价集中的所有对象都必须为同一类型和种类类型。

以下自 Fortran 标准：“如果一个等价对象是内类型，而不是缺省整型、缺省实型、双精度实型、缺省复型、缺省逻辑型或缺省字符型，则该等价集中的所有对象都必须是种类类型参数值相同的同一类型。”

消息标识：ERROR_1241

## Error:它不是字符或数字序列派生类型，因此等价集中的所有对象都必须为同一类型。

以下自 Fortran 标准：“如果一个等价对象不是数值序列或字符序列类型的派生类型，则该等价集中的所有对象都必须是同一类型。”

消息标识：ERROR_1242

## Ansi：.LG. 运算符是 Fortran 标准的一个扩展。

IEEE 浮点标准<> 定义了 .LG. 或 运算符，但未在 Fortran 标准中定义。支持该运算符是 Fortran 标准的一个扩展。

消息标识：ANSI_1243

## 警告：它是一个派生类型，其组件用 -s default32 指定类型。等价存储关联可能不是预期的结果。

-s default32 使所有缺省类型成为基于 32 位的类型，而不是基于 64 位的类型。在派生类型中，所有组件必须为整字边界，因此用一个 64位填充分隔两个声明为 32 位类型的组件。

消息标识：WARNING_1244

## Error:对象没有用处理器维数声明。

遇到使用 [..] 处理器维数语法的引用，但该对象未用处理器维数声明。以下示例将产生此错误。 integer i(10) i(1)[3,4] = 1 end

消息标识：ERROR_1245

## Error:预编译过程与此编译系统不兼容。用此编译系统重新编译。

编译器试图读取预编译过程进行内联。该预编译过程是用不兼容的编译器创建的。为确保兼容，请使用当前编译器和命令行选项重新编译该过程。

消息标识：ERROR_1246

## Error:预编译过程必须以与此编译相同的操作系统为目标。

内联的预编译过程必须以与此编译相同的操作系统为目标。目标操作系统不能混合。

消息标识：ERROR_1247

## Error:过程和此编译都必须用编译，或都必须在没有选项的情况下进行编译。

如果当前编译单元使用了所列选项进行编译，则它所使用的每个模块或它内联的每个预编译过程都必须用相同的选项进行编译。如果当前编译单元未使用所列选项进行编译，则它所使用的每个模块或它内联的每个编译过程都不能使用该选项进行编译。

消息标识：ERROR_1248

## 限制：模块在此编译中编译，但是编译器不再能找到模块。

编译模块时，编译器在编译过程临时文件中保存模块信息表。当在 USE 语句中指定该模块，编译器尝试从临时文件读取模块信息表。该临时文件出现问题，编译器不能读取该模块。

消息标识：LIMIT_1249

## 内部：期望在全局名称表中找到它，但是 srch_global_name_tbl 返回结果为没有找到。

在编译中的某些地方，将搜索全局名称表，以查找编译过程中早先放入的名称。当未找到想要的名称时，生成此错误。此错误决不应发生。

消息标识：INTERNAL_1250

## Log_Error：在 -apad[n] 命令行选项中指定的可选填充量必须在 0 和 4096 之间。

可在 -apad[n] 命令行选项中指定可选的填充量。此数必须是大于零小于 4096 的整型文字常量。指定的数字不在此范围内。

消息标识：LOG_ERROR_1251

## Log_Error：二进制输出文件与为了从文件“%s”内联而创建的二进制输出文件相同。

内联信息保存在二进制输出文件中。当用 -Oinlinefrom=x.f 指定 x.f 时，编译器创建一个称为 x.o 的文件，用于存放内联信息。如果指定命令行 -Oinlinefrom=x.f x.f，则在 inlinefrom 编译器调用过程中创建的 x.o 被实际的 x.f 编译调用覆盖。避开此问题的一个方法是使用 -b file.o 指定一个替代二进制文件。例如： -Oinlinefrom=x.f -b out.o x.f

消息标识：LOG_ERROR_1252

## Ansi：此语句是 Fortran 标准的一个扩展。

AUTOMATIC 语句是 Fortran 标准的一个扩展。

消息标识：ANSI_1253

## Ansi：此属性是 Fortran 标准的一个扩展。

AUTOMATIC 属性是 Fortran 标准的一个扩展。

消息标识：ANSI_1254

## Error:它是数组、指针、字符或派生类型函数结果时，不能具有 AUTOMATIC 属性。

AUTOMATIC 属性不能被赋予数组定值、指针定值、字符或派生类型函数结果。

消息标识：ERROR_1255

## Error:对象的一个属性要求它不能与公共块中的对象等价。

用户试图将保存的对象等价于公共块或将具有 AUTOMATIC 属性的对象等价于公共块。

消息标识：ERROR_1256

## Error:对象的一个属性要求此等价组中的所有对象都必须具有 %s 属性。

如果等价组中的一个对象有 AUTOMATIC 属性，则该等价组中的所有对象都必须具有 AUTOMATIC 对象。

消息标识：ERROR_1257

## Error:模块包含类型为 integer(kind=6) 或 integer*6 的对象。不再被支持。

先前版本会发出警告，通知用户编译器将不再支持 integer*6 和 integer(kind=6) 类型。正在使用的模块中发现此类对象。必须更改 integer*6 和/或 integer(kind=6) 声明，并重新编译模块。

消息标识：ERROR_1258

## Ansi：它被多次指定同一属性。这是非标准的。

多次声明一个对象有同一属性是非标准的。

消息标识：ANSI_1259

## Error:对于此子程序，前缀说明被两次指定。

不能对一个子程序多次指定相同的前缀说明。前缀说明可能是 RECURSIVE、PURE、ELEMENTAL 和/或类型说明。类型说明是指有效的类型指定，如 INTEGER、CHARACTER*(10) 或 TYPE (derived_type_name)。

消息标识：ERROR_1260

## Error:不能为同一子程序指定 RECURSIVE 和 ELEMENTAL。

在 Fortran 95 标准中，对 R1219 的约束禁止为同一程序单元指定 RECURSIVE 和 ELEMENTAL 前缀说明。

消息标识：ERROR_1261

## Error:PURE 子程序中不允许此语句。

PURE 子程序中不允许使用以下语句。 print 语句 open 语句 close 语句 backspace 语句 endfile 语句 rewind 语句 inquire 语句 stop 语句 pause 语句 这是对纯过程的约束 (12.6)。根据定义，基本过程是纯过程，因此这些约束也适用于基本过程。

消息标识：ERROR_1262

## Error:一个%s语句其 io-unit 是外部文件单元或 * 时，不允许用在纯子程序中。

纯过程约束 (12.6) 禁止在纯子程序中指定 io-unit 为外部文件名或 * 的读写语句。根据定义，基本过程是纯过程，因此此约束也适用于基本过程。

消息标识：ERROR_1263

## Error:子程序变量不能赋予此属性。

纯子程序中的变量不能赋予 SAVE 或数据初始化属性。根据定义，基本过程是纯过程，因此此约束也适用于基本过程。

消息标识：ERROR_1264

## Error:必须为纯 FUNCTION 的非指针伪参数指定 INTENT(IN)。

纯 FUNCTION 的规范部分应该指定除了过程参数（伪过程）和具有 POINTER 属性的参数之外所有伪参数都具有 INTENT(IN)。 根据定义，所有基本 FUNCTION 都是纯过程，因此这也适用于基本 FUNCTION。

消息标识：ERROR_1265

## Error:必须为纯 SUBROUTINE 的非指针伪参数指定 intent。

纯子例程的规范部分应该指定除了过程参数（伪过程）、替代返回指示符和具有 POINTER 属性的参数之外所有伪参数的 intent。 根据定义，基本过程是纯过程，因此这也适用于基本子例程。

消息标识：ERROR_1266

## Error:这是一个基本子程序伪参数，因此它必须是一个非指针标量伪参数。

Fortran 标准中的 12.7.1 约束要求所有基本子程序伪参数都是非指针标量。伪参数也不能是伪过程。

消息标识：ERROR_1267

## Error:这是一个基本函数，因此其函数结果必须是标量而且不能是指针。

12.7.1 约束要求基本函数的函数结果是标量。它们不能是指针。

消息标识：ERROR_1268

## Error:交替返回说明符不允许作为基本 SUBROUTINE 的伪参数。

Fortran 标准中的 12.7.1 约束指出基本子例程的伪参数不能是 *。* 是替代返回说明符。

消息标识：ERROR_1269

## Error:这不能在纯子程序内部定义。它在公共、伪参数或主机或使用关联中。

对 12.6 纯子程序的约束禁止在纯子程序内定义以下伪参数：函数子程序的所有伪参数和子程序内具有 INTENT(IN) 属性的所有伪参数。 对 12.6 的约束也禁止公共名称、主机关联或使用关联变量出现在可能更改变量值的语句中。可以使用此变量，但不能在纯子程序内重新定义。 根据定义，基本子程序是纯子程序，因此上述约束也适用于基本子程序内的伪参数和变量。

消息标识：ERROR_1270

## Error:这是纯子程序的伪过程。必须用 PURE 前缀说明指定。

对 12.6 纯过程的约束规定：纯子程序的规范部分应该指定所有作为过程参数的伪参数都是纯伪参数。即，如果为纯子程序指定了伪过程，则该伪过程必须具有显式接口，该接口必须指定伪过程为纯过程。 不能在基本子程序中指定伪过程。

消息标识：ERROR_1271

## Error:这是纯子程序的内部子程序。必须赋予纯前缀说明。

在 Fortran 标准中，对 12.6 纯过程的约束规定纯子程序中的所有内部子程序都应该是纯子程序。即，如果外部子程序是纯子程序，则它的所有内部子程序也必须声明为纯子程序。 按照定义，基本子程序是纯子程序，因此上述约束也适用于基本子程序。

消息标识：ERROR_1272

## Error:这在纯子程序中不能以此方式成为参数关联的。

12.6 纯过程的约束禁止将函数子程序的所有伪参数和子例程子程序的所有具有 INTENT(IN) 属性的伪参数，以及公共、主关联或使用关联变量被用作与具有 INTENT(out) 或 INTENT(inout) 属性或具有 POINTER 属性的伪参数相关联的实际参数。 根据定义，基本子程序是纯子程序，因此上述约束也适用于基本子程序内的所有伪参数。

消息标识：ERROR_1273

## Error:过程必须是纯过程，因为它在纯子程序中被引用。

12.6 纯过程的约束规定纯子程序中引用的任何过程都应该是纯过程，包括通过已定义操作或指定引用的过程。相关的约束规定：对于任何既不是内在过程、也不是语句函数的过程，如果在要求它是纯过程的上下文中引用，则它必须有一个显式接口并且与引用在相同的范围内。 根据定义，基本过程也是纯过程，因此适用于纯过程的所有约束也适用于基本过程。

消息标识：ERROR_1274

## 警告：公共块被用在多个程序单元中，并且在不同程序单元中具有不同的长度。

在交叉编译语义过程中，编译器检测到同一公共块用于多个程序单元。在这些程序单元中公共块的长度不同。

消息标识：WARNING_1275

## 警告：公共块用于多个程序单元。在所有使用中，它必须在相同存储块中。

在交叉编译语义过程中，公共块用于多个程序单元。如果在一个程序单元中公共块在 AUXILIARY 存储块中，则在所有程序单元中它都必须在 AUXILIARY 存储块中。如果在一个程序单元中公共块在 TASK COMMON 存储块中，则在所有程序单元中它都必须在 TASK COMMON 存储块中。

消息标识：WARNING_1276

## Error:过程已定义，但必须为它指定一个显式接口。

Fortran 标准中的 12.3.1.1 显式接口指出： 语句函数之外的过程将会具有显式接口，前提是该过程是基本过程，或该过程具有：(a) 可选的伪参数；(b) 是假定形数组、指针或目标的伪参数；(c) 数组值结构（仅限函数）；(d) 是指针的结果（仅限函数）；(e) 其字符长度参数值未假设且不是常量的结果 在全局语义过程中，编译器检测到外部过程的调用，并且编译过程中在另一个程序单元发现该外部过程的一个显式接口。该外部过程的显式接口描述该过程具有一个或多个上述特性。这些特性要求在引用此过程的所有程序单元中为此程序单元指定一个显式接口。

消息标识：ERROR_1277

## 警告：过程已定义，但存在数组实际参数和标量伪参数之间的非法关联。

全局语义检测到定义和在另一程序单元中的引用之间存在差异。 标量伪参数不能具有与其相关联的值确定的数组实际参数。

消息标识：WARNING_1278

## 警告：过程已定义，但实际参数类型与伪参数类型不一致。

全局语义检测到定义和在另一程序单元中的引用之间存在差异。 与伪参数相关联的实际参数类型必须一致。

消息标识：WARNING_1279

## 警告：指令将被替换。在下一版本中将不再可用。

指令 MODINLINE 与指令 INLINABLE 相同。指令 NOMODINLINE 与指令 NOININABLE 相同。正在删除 !DIR$ MODINLINE 和 !DIR$ NOMODINLINE，因为 !DIR$ INLINABLE/NOINLINABLE 更具普遍性。MODINLINE/NOMODINLINE 仅适用于模块过程。INLINABLE/NOINLINABLE 可以适用于所有外部过程。

消息标识：WARNING_1280

## Error:不允许 COPY_ASSUMED_SHAPE 指令的这种用法。

可以用两种方式使用 COPY_ASSUMED_SHAPE 指令。有参数列表时，它指定一组一致的假定形伪参数，这些伪参数将复制到相邻数组中。没有列表知，所有假定形伪参数都假定为一致的。不允许使用既有带列表的指令、又有不带列表的指令。

消息标识：ERROR_1281

## Error:全局名称在先前行中以一种方式定义，而在程序单元中以另一种方式定义。

全局名称的使用范围是整个编译单元，因此全局（或外部）名称只能声明一次。 此编译过程中，编译器发现此对象的两个独立程序单元定义。 发现与以下相似的内容： function f() f = 2.0 end function ... subroutine f() !A message is issued because f is both a function and ! a subroutine. end subroutine

消息标识：ERROR_1282

## Error:全局名称已在接口块中声明，但在此程序单元中有不同的定义。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与此程序单元的接口块不符。它们应当相同。

消息标识：ERROR_1283

## 警告：过程已定义并且具有一定数量的伪参数。此接口指定了不同数量的伪参数。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与此程序单元的接口块不符。它们应当相同。 实际程序单元定义和此程序单元的接口块之间的伪参数数量不同。

消息标识：WARNING_1284

## Error:属性在程序单元或接口块定义中指定，但不能在两者中同时指定。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与此程序单元的接口块不符。它们应当相同。 经过检查的属性包括 vfunction、nosideeffects、pure、elemental 和 recursive。

消息标识：ERROR_1285

## 警告：在先前行定义的类型和/或等级与此接口块不符。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与此程序单元的接口块不符。它们应当相同。 所有伪参数的类型和等级必须一致。

消息标识：WARNING_1286

## 警告：在先前行定义的函数结果之类型和/或等级与此接口块不符。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与此程序单元的接口块不符。它们应当相同。 函数结果的类型和等级应该相同。

消息标识：WARNING_1287

## 警告：全局名称已在先前行中定义，但在此接口块中又以不同方式定义。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与此程序单元的接口块不符。它们应当相同。

消息标识：WARNING_1288

## Error:不能在 DO PARALLEL 循环中指定此指令。

不允许在指定为 DO PARALLEL 循环的 DO 循环内嵌套另一个 DO PARALLEL 指令。在上下文中也不允许 CASE 指令。

消息标识：ERROR_1289

## 警告：先前行接口块中的函数结果类型和/或等级与此定义不同。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与此程序单元的接口块不符。它们应当相同。 函数结果的类型和等级应该相同。

消息标识：WARNING_1290

## 警告：先前行接口块中的伪参数类型和/或等级与此定义不同。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与此程序单元的接口块不符。它们应当相同。 所有伪参数的类型和等级必须一致。

消息标识：WARNING_1291

## 警告：此过程的接口块在前一行有一定数量的伪参数。该定义具有不同数量的伪参数。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与此程序单元的接口块不符。它们应当相同。 实际程序单元定义和此程序单元的接口块之间的伪参数数量不同。

消息标识：WARNING_1292

## 警告：在前一行以一种方法定义全局名称，但在此程序单元中却使用不同的方法进行引用。

全局名称的范围是一完整的编译单元。对此全局名称的任何引用必须正确，并与此名称的定义相匹配。 编译器找到了与其引用不匹配的程序单元定义。 发现与以下相似的内容： program f ... end program ... subroutine f() call p() !A message will be issued because p is a program in ! this compilation. end subroutine

消息标识：WARNING_1293

## 警告：在前一行定义的函数的结果之类型和/或等级与此函数引用不符。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与一项对该函数的引用不符。函数结果的类型和等级应该相同。

消息标识：WARNING_1294

## 警告：过程已在前一行定义并且具有一定数量的伪参数。此引用指定了不同数量的实际参数。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与一项对该过程的引用不符。 实际程序单元定义的伪参数数量和此引用中指定的实际参数的数量不同。 如果该定义具有可选参数，应在此程序单元中指定该引用的显式接口。

消息标识：WARNING_1295

## 警告：在前一行定义的子例程具有交替返回的伪参数，因此该实际参数必须为用户标签。

全局语义检测到定义和在另一程序单元中的引用之间存在差异。 显式接口将此伪参数定义为交替返回参数 (*)，但是调用点不提供作为相应的实际参数的用户标签。

消息标识：WARNING_1296

## 警告：在伪参数作为数据对象的条件下在前一行定义了过程。实际参数是一个过程。

在全局语义分析过程中，编译器发现伪参数和实际参数之间的不匹配。如果伪参数为数据对象，那么实际参数必须为数据对象。如果伪参数是伪过程，那么实际参数必须为过程。

消息标识：WARNING_1297

## 警告：过程已在前一行定义。伪函数的类型与实际参数类型不符。

全局语义检测到定义和在另一程序单元中的引用之间存在差异。 与伪参数相关联的实际参数类型必须一致。这种情况下，伪参数和实际参数均为函数。函数的类型和种类类型必须一致。

消息标识：WARNING_1298

## 警告：过程已在前一行定义。实际参数必须是与伪参数相同的过程类型。

在全局语义分析过程中，编译器发现伪参数和实际参数之间的不匹配。如果伪参数为数据对象，那么实际参数必须为数据对象。如果伪过程是伪函数，那么实际参数必须是函数。如果伪过程是子例程，那么实际参数必须是子例程。

消息标识：WARNING_1299

## 警告：在伪参数作为过程的条件下在前一行定义了过程。实际参数是一个数据对象。

在全局语义分析过程中，编译器发现伪参数和实际参数之间的不匹配。如果伪参数为数据对象，那么实际参数必须为数据对象。如果伪参数是伪过程，那么实际参数必须为过程。

消息标识：WARNING_1300

## 警告：过程已在前一行定义。标量实际参数与数组伪参数非法关联。

全局语义检测到定义和在另一程序单元中的引用之间存在差异。 数组伪参数不能具有与其相关联的标量实际参数。此处允许数组元素。

消息标识：WARNING_1301

## Ansi：将假定大小字符数组用作内部文件是 Fortran 标准的一个扩展。

Fortran 标准仅允许引用假定大小数组的整个数组，作为无需上界的过程的参数或作为 LBOUND 的参数。作为该标准一个扩展，F90 允许 WRITE 或 READ 语句中的内部文件为假定大小字符数组。

消息标识：ANSI_1302

## Error:COPY_ASSUMED_SHAPE 指令中只允许假定形伪参数。

在 COPY_ASSUMED_SHAPE 指令中指定了不是假定形伪参数的对象。通常，在指令中遇到标量变量时编译器会产生此消息。

消息标识：ERROR_1303

## 注意：遇到 COPY_ASSUMED_SHAPE 指令，但是没有假定形伪参数。

不带参数列表的 COPY_ASSUMED_SHAPE 指令请求，将所有假定形伪参数复制到临时数组中，以有助于循环优化。由于没有任何假定形伪参数，所以发布此消息。

消息标识：CAUTION_1304

## 注意：此字符文字被空白填充为伪参数的长度。

编译器测定出短于关联的伪参数的字符文字实际参数。文字被空白填充到必要长度。

消息标识：CAUTION_1305

## Ansi：字符文字实际参数的空白填充是 Fortran 标准的一个扩展。

编译器测定出短于关联的伪参数的字符文字实际参数。文字被空白填充到必要长度。这是 Fortran 标准的一个扩展。

消息标识：ANSI_1306

## Error:此实际参数的种类和与其相关联伪参数种类不匹配。

检测到被调用例程的显式接口中提供的伪参数的种类类型参数和实际参数的种类类型参数之间有差异。

消息标识：ERROR_1307

## Error:在十进制字段之后带有 D、E 或 Q 的实常量中，D、E 或 Q 之后必须跟有指数。

编译器检测到实常量中缺少指数字段。实常量的语法是 [sign] real_literal_constant real_literal_constant 是尾数 [exponent_letter exponent] [_kind_param] 或 digit_string exponent_letter exponent [_kind_param] 尾数是 digit_string.[digit_string] 或 digit_string exponent_letter 是 E 或指数是 signed_digit_string

消息标识：ERROR_1308

## Error:种类参数后缀在双精度或四精度实常量格式中无效。

编译器检测到跟随 D 或 Q 指数的种类参数。 实常量的语法是 [digit_str].digit_str[exponent_letter exponent] [_kind_param] exponent_letter 是 D、E 或 Q；指数是带有以下约束的 signed_digit_string：如果 kind_param 和 exponent_letter 都出现，那么 exponent_letter 必须为 E。

消息标识：ERROR_1309

## Log_Summary：f90：编译时间%s秒

此消息报告程序编译过程所用的时间（以秒为单位）。

消息标识：LOG_SUMMARY_1310

## Error:ELEMENTAL 调用的数组参数与其它参数不一致。

根据标准 12.7.2 的 ELEMENTAL 的定义“对于那些具有一个以上参数的基本函数，所有实际参数应该一致”。子例程有相同的语句。

消息标识：ERROR_1311

## Error:此 DO PARALLEL 指令不允许用在平行 CASE 区域中。

DO PARALLEL 指令仅能用在由 PARALLEL/ENDPARALLEL 指令限制的平行区域内。不能在 CASE 平行区域内指定它们。

消息标识：ERROR_1312

## Log_Warning：一个命令行选项覆盖了另一个。

两个指定的命令行选项相互冲突，不应在同一命令行中指定。 -ei 和 -e0 冲突。编译器选择指定的最后一个选项。（最右边者符合规则。）

消息标识：LOG_WARNING_1313

## Error:在多个域列表中声明对象。

在任务指令语句中，变量在多个域列表中列出。域列表为 PRIVATE、GETFIRST 和 SHARED。

消息标识：ERROR_1314

## 内部：内部内联数据结构溢出。编译不能继续。

内部数据结构溢出。把它报告给现场分析员。可能可以增加数据结构的大小。

消息标识：INTERNAL_1315

## 内部：符号表字段为 NULL，并且不能在此位置。

内部符号表出现问题。请通知您的系统支持人员。

消息标识：INTERNAL_1316

## 警告：在此平台上的 IVDEP 指令中不允许 SAFEVL。此 IVDEP 指令将被忽略。

在此平台上的 IVDEP 指令中不允许 SAFEVL 子句。此 IVDEP 指令将被忽略。即：当作注释。

消息标识：WARNING_1317

## Error:在 CACHE_BYPASS 指令中指定它。它必须具有维数属性。

在 CACHE_BYPASS 指令中指定的所有对象，必须声明为同一作用单元中的数组，或者成为主机或使用关联到该范围的数组。

消息标识：ERROR_1318

## Error:必须在 CACHE_BYPASS 指令中指定数组名。不允许子对象或表达式。

CACHE_BYPASS 指令要求数组名称。编译器检测到后跟下标或子串引用的表达式或数组名。这是不允许的。

消息标识：ERROR_1319

## Error:在 CACHE_BYPASS 指令中指定它。其类型必须是种类类型为 8 的整型、逻辑或实型。

目前，CACHE_BYPASS 指令受支持的数组类型仅有 64 位整数、实数和逻辑。

消息标识：ERROR_1320

## 内部：属性列表入口 %d 占据属性入口 %d，它已被压缩出表。

这种情况决不应发生。请将此情况报告给您的系统支持人员。

消息标识：INTERNAL_1321

## Error:编译器已检测到过程中有错误。将不会为此过程创建内联信息文件。

编译器检测到过程中有错误；因而将不会为该过程创建内联信息文件。错误可造成内联信息文件中的信息不可靠。

消息标识：ERROR_1322

## Ansi：内在过程所有参数的种类类型不相同。

标准要求 MIN/MAX 的所有参数必须具有相同的类型和种类类型。编译器将允许不同种类类型，并将较小的种类类型参数提升为最大的种类类型参数。

消息标识：ANSI_1323

## 内部：已超过为给定行指定的最大循环数量。

当前 DO 循环的 BLK_LOOP_NUM 已经是最大值。较大的值将溢出分配给“块栈”中 BLK_LOOP_NUM 的空间。 应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。您可以更改代码以使编译器不再试图生成这条消息。

消息标识：INTERNAL_1324

## 内联：由于将出现存储到常量，所以例程没有内联。

用户正在试图内联具有无效参数映射的调用点。实际参数是一个常量，并且被调用者会存储到与该常量相关联的伪参数。 例如 subroutine sam(i) j = 4 i = j !this will create a store into a constant when inlined end program nono call sam(3) end

消息标识：INLINE_1325

## 内联：由于例程包含交替 RETURN，所以例程没有内联。

被内联的例程包含交替 RETURN。因此，此例程无法扩展内联。 例如： subroutine boo(*) print *, 'in boo' return 1 end program b call boo(*3) !this call will not get inlined print *, 'should never print this' 3 continue end

消息标识：INLINE_1326

## 内联：由于例程调用 PRESENT 内在过程，所以例程没有内联。

无法内联含有 PRESENT 内在过程调用的例程。 例如： program tt call sam(i) !This call will not be inlined. end subroutine sam(j) print *, present(j) end

消息标识：INLINE_1327

## 内联：由于相应的实际参数和伪参数没有相同的类型和种类类型，所以例程没有内联。

每个相应的实际参数和伪参数必须具有相同类型和种类类型。否则，调用点将不扩展内联。 例如： subroutine sam(i) integer (8) i print *, i end program nono integer (4) j call sam(j) ! will not get expanded inlined end

消息标识：INLINE_1328

## 内联：由于例程调用 NUMARG 内在过程，所以例程没有内联。

无法扩展内联含有 NUMARG 内在过程调用的例程。 例如： program boo call sam(3,i) !this call site will not be expanded inline end subroutine sam(j,k) print *, NUMARG() end

消息标识：INLINE_1329

## 内联：由于标量实际参数被映射到数组伪参数，所以例程没有内联。

如果内联函数遇到正在被传递到数组伪参数的标量实际参数，那么将不会内联调用点。 例如： program boo call sam(a) !this call site will not be expanded inline end subroutine sam(b) dimension b(10) print *, b(1) end

消息标识：INLINE_1330

## 内联：由于例程包含 ASSIGN 语句，所以例程没有内联。

如果例程含有 ASSIGN 语句，那么将不会扩展内联。 例如： program boo call sam() !this call site will not be inlined end subroutine sam() assign 10 to L j = k if (j .eq.1) goto L r = q 10 continue r = s end

消息标识：INLINE_1331

## 内联：由于例程是 ASSIGN，所以例程没有内联。

如果声明例程为 RECURSIVE，那么内联函数不会试图内联该例程。 例如： subroutine sam() call joe() !this call site will not be inlined end RECURSIVE subroutine joe() if call joe() end

消息标识：INLINE_1332

## 内联：因为正在调用的例程是伪过程，所以没有内联例程。

如果内联函数遇到对伪过程的调用，那么将不会试图内联此伪过程调用。 例如： subroutine boo(bubble) external bubble call bubble() !this call site will not be inlined end subroutine bil() external tank call boo(tank) end

消息标识：INLINE_1333

## 内联：由于其具有 OPTIONAL 伪参数，所以例程没有内联。

如果例程含有 OPTIONAL 伪参数，那么内联函数决不会扩展该例程内联。 例如： subroutine slug(a,b) OPTIONAL ::b print *, b end program boo call slug(x,y) !slug can never be expanded inline end

消息标识：INLINE_1334

## 内联：由于 INLINE 指令未生效，所以例程没有内联。

只有 -Oinline1 在命令行时才能发布此消息。在内联的一级，指令是使内联发生的唯一方法。能够在此级别促成内联的两个指令为： !dir$ INLINE 和 !dir$ INLINEALWAYS

消息标识：INLINE_1335

## 注意：由于调用不在循环内，所以例程没有内联。

只有 -Oinline2 在命令行时才能发布此消息。调用点只有位于 DO 循环内才能内联。

消息标识：NOTE_1336

## 内联：由于在静态存储中包含 Fortran 指针，所以例程没有内联。

如果例程在静态存储器中的任何位置都含有 Fortran 指针，那么内联函数将不会内联该例程。 例如： subroutine boo() common // a pointer a print *, 'in boo' end subroutine bo() save a pointer a print *, 'in bo' end program nono call boo() !this call site will not be inlined call bo() !this call site will not be inlined end

消息标识：INLINE_1337

## 内联：由于 NOINLINE 指令已生效，所以例程没有内联。

用户已经将 !dir$ NOINLINE 指令放入它们的源中，所以不会内联此调用点。 例如： program this dimension a(10) !dir$ NOINLINE call sam() !this call site will not be inlined end subroutine sam() print *, 'in sam' end

消息标识：INLINE_1338

## 内联：由于已经指定 INLINENEVER 指令，所以例程没有内联。

因为名称出现在 INLINENEVER 指令中，此例程将不会扩展内联。如果 INLINENEVER 指令出现在“名称”在此指令中指定的例程的定义中，那么决不会扩展内联该例程的调用。如果 INLINENEVER 指令未出现在例程定义中，那么将不会内联对在 INLINENEVER 指令中指定的“名称”的调用。 例如： subroutine this() !dir$ INLINENEVER this print *, 'in this' end subroutine that() print *, 'in that' call this() ! call site will not be inlined end program boo !dir$ INLINENEVER that call this() ! call site will not be inlined call that() ! call site will not be inlined end

消息标识：INLINE_1339

## 内联：由于被内联的例程的伪参数是一个伪过程，所以例程没有内联。

被内联例程的伪参数是一个伪过程。内联函数将不会内联此例程。 例如： subroutine boo(b) external b print *, b(3.0) end program big intrinsic tan call boo(tan) !this call site will not be inlined end

消息标识：INLINE_1340

## 内联：由于例程具有在子例程中引用的伪参数，所以例程没有内联。

无法内联具有在子例程中引用的伪参数的例程。 例如： subroutine boo(i) call sam() !this call site will not be expanded inline contains subroutine sam() print *, i end subroutine end subroutine

消息标识：INLINE_1341

## 内联：由于有不同数量的实际和伪参数，所以例程没有内联。

实际参数和伪参数的数量必须相等，以便内联调用点。 例如： subroutine boo(a) print *, a end program this call boo(x,y) !this call site will not be inlined end

消息标识：INLINE_1342

## 内联：由于在调用列表中可以最多有 64 个实际参数，所以例程没有内联。

在此调用点，用户编码的实际参数已超过 64 个。无法内联该调用点。

消息标识：INLINE_1343

## 内联：由于编译器不能查找例程从而加以内联扩展，所以例程没有内联。

编译器无法查找被调用例程的模板从而进行内联扩展。出现此情况的原因为： 1) 创建模板时，该例程中有编译错误。2) 用户没有将编译指引到查找此内联例程的位置。3) 用户实际上从未为该例程创建模板。

消息标识：INLINE_1344

## 内联：由于例程引用了不是来自所采用 ENTRY 的伪参数，所以例程没有内联。

用户已在例程中采用了一个入口点，而在该例程的某处引用了来自其它入口点的伪参数。这是非法的，编译器将不会内联此类调用。 例如： subroutine boo() common // a print *, a if (a .gt.0.0) goto 10 entry alt(b) 10 continue print *, b end program nono common // a call boo() ! this call site will not be inlined end

消息标识：INLINE_1345

## 内联：由于存在还未定义的模块的 USE 语句，所以例程没有内联。

如果例程已内联，那么该例程含有 USE 语句。正在使用的模块已经被编译并且可用。 例如： program boo call s() ! this call site will not get inlined end subroutine s() use z print *, i end module z integer i end

消息标识：INLINE_1346

## 内联：由于太大而不能扩展内联，所以例程没有内联。

此特定例程文本太多，无法进行扩展内联。

消息标识：INLINE_1347

## 注意：在此平台上不支持 QUAD PRECISION。将使用 DOUBLE PRECISION。

此机器不能支持高于 DOUBLE PRECISION 的 REAL 精度。

消息标识：CAUTION_1348

## 内部：常量表入口有一个为零的 CN_POOL_IDX。

这种情况决不应发生。这说明在常量表中有无效入口。

消息标识：INTERNAL_1349

## 警告：该指令已废弃。在下一主要版本中，将不再支持。

在以后版本中将不再支持列出的指令。请从您的代码中删除对此指令的引用。

消息标识：WARNING_1350

## 警告：存储块将不会被填充 (-a pad)，因为存储块中的一个或多个对象等价。

-a pad 特征可在公共和静态存储块对象之间进行填充。如果所有对象等价，那么将不会进行填充，因为这样可能会破坏等价。

消息标识：WARNING_1351

## 警告：静态存储块将不会被填充 (-a pad)，因为存储块中的一个或多个对象等价。

-a pad 特征可在公共和静态存储块对象之间进行填充。如果所有对象等价，那么将不会进行填充，因为这样可能会破坏等价。

消息标识：WARNING_1352

## Log_Warning：检测出命令行选项冲突。编译器已经选择了其中一个选项。

在命令行上指定的两个选项之间存在冲突，所以编译器选择了其中一个选项。该消息详细说明选择了哪个选项。

消息标识：LOG_WARNING_1353

## 警告：未实现的编译器指令。

临时消息。不应接收到此消息。

消息标识：WARNING_1354

## 内联：由于具有 CRI 指针伪参数，所以例程没有内联。

因为一个伪参数是 CRI 指针，所以没有内联此例程。

消息标识：INLINE_1355

## 警告：应该是一个有效的编译器指令。

在编译器指令行的分析过程中，该编译器找到未知字符。该行已刷新。

消息标识：WARNING_1356

## 内联：由于子例程引用此函数的结果，所以例程没有内联。

如果在子例程中引用了函数“FUNC”结果，那么将无法内联“FUNC”。 例如： program start j = if(10) ! this call will not get inlined print *, "j should be 10 ", j end program function if(i) integer if if = i call z() contains subroutine z() print *, "if should be 10 ", if ! hosted function result end subroutine end function

消息标识：INLINE_1357

## 内联：由于在 COMMON 中包含变量的 LOC，所以例程没有内联。

无法内联扩展此例程，因为其包含将 COMMON 块变量作为参数的 LOC 内在过程。LANL 要求在每个调用点将所有的 CRI 指针强制到内存，不论 CRI 指针是否在调用列表中。这使得在某些情况下含有 CRI 指针的例程的内联不安全。

消息标识：INLINE_1358

## 内联：由于包含 COMMON 中的 CRI 指针，所以例程没有内联。

将不会内联含有 COMMON 块中的 CRI 指针的例程。

消息标识：INLINE_1359

## Error:为此指令指定了多个子句。

C$ 和 C$PAR 编译器指令的许多子句仅能指定一次。 C$DOACROSS IF、CHUNK（或 BLOCKED）、MP_SCHEDTYPE、AFFINITY、NEST 和 ONTO 可能仅能指定一次。

消息标识：ERROR_1360

## Error:此指令不允许有 ONTO 子句，除非首先有 NEST 子句。

对于 DOACROSS、PDO 和 PARALLEL DO 指令，必须在 ONTO 子句之前指定 NEST 子句。

消息标识：ERROR_1361

## Error:在多个域列表中指定对象。

只能用一种方法限定平行区域内对象的范围。以下示例中，对象“A”位于 SHARE 和 LASTLOCAL 两个列表中。这是不允许的。 C$DOACROSS SHARE(A,B), LASTLOCAL(A) do 100 B = 1,10 A = B 100 continue

消息标识：ERROR_1362

## Error:REDUCTION 子句中的对象必须是标量引用。

在 DOACROSS 指令的 REDUCTION 列表中仅允许标量变量或数组元素。

消息标识：ERROR_1363

## Error:CHUNK 子句的参数必须是一个标量 INTEGER 表达式。

DOACROSS 指令的 CHUNK（或 BLOCKED）表达式必须为标量 INTEGER 表达式。

消息标识：ERROR_1364

## Error:变量必须在 COMMON 块中声明，以便使用 PE 维数。

F-- 原型仅支持 COMMON 块对象的 pe 维数语法。

消息标识：ERROR_1365

## Error:PE 维数引用不允许作为实际参数。

F-- 原型不支持将 PE 维数引用为用户或内调用的参数。

消息标识：ERROR_1366

## 内部：边界入口出现字段变量问题。

编译器检测到变量问题。在边界表中存取字段，但是使用了错误的变量。边界表变量为正规数组入口和分发入口。 应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_1367

## Error:ONTO 子句的参数必须是大于零的 INTEGER 常量。

DOACROSS、PDO、PARALLEL DO 指令的 ONTO 子句仅能含有整型常量或字符“*”。整型常量必须大于零。

消息标识：ERROR_1368

## Error:ONTO 常量的数量必须等于 NEST 变量的数量。

对于 DOACROSS、PDO 和 PARALLEL DO 指令，整型常量或“*”说明符的数量必须等于在关联 NEST 子句中指定的循环控制变量的数量。

消息标识：ERROR_1369

## Error:mp 指令不允许此子句。

遇到的子句在指定的 mp 指令中不被支持。

消息标识：ERROR_1370

## Error:THREAD 子句的参数必须是一个标量 INTEGER 表达式。

与 DOACROSS、PDO 和 PARALLEL DO 指令一起使用的 THREAD 子句，仅能具有一个标量 INTEGER 表达式参数。

消息标识：ERROR_1371

## Error:DATA 子句的参数必须是数组元素。

待提供。

消息标识：ERROR_1372

## Error:THREAD 子句的参数必须是常量。

待提供。

消息标识：ERROR_1373

## Error:在此上下文中不允许子对象引用。

有许多不允许子对象引用的上下文。即，正在引用的变量必须作为非限定名称被引用，例如 X 或 ARRAY。特别地，该名称不能具有任何附加的下标表也不能包含结构组件 (%) 符号。 此类上下文的一些示例为 DO 变量并且在编译器指令中。例如，任务编译器指令定义平行区域的范围或上下文时，该参数必须是全程变量，而不能是变量子对象。以下代码碎片不被允许。 TYPE X INTEGER I END TYPE TYPE(X) ::K CMIC$ DO ALL SHARED(K%I)

消息标识：ERROR_1374

## 警告：变量名列表必须至少包含两个名称。

标明的名称列表必须至少包含两个名称。

消息标识：WARNING_1375

## Error:LASTTHREAD 子句中的对象必须是简单标量变量。

仅标量变量名能够用于 DOACROSS、PARALLEL DO 和 PDO 指令的 LASTTHREAD 子句中。

消息标识：ERROR_1376

## Error:只有 NEST 子句中对象的计数大于 1 时，才能指定 ONTO 子句。

ONTO 子句要与嵌套循环一起使用。如果 NEST 子句仅具有一个对象，那么不允许 ONTO 子句。

消息标识：ERROR_1377

## Error:此指令的无效参数。

允许某些整数值用于 PREFETCH 和 PREFETCH_MANUAL 指令。 C*$* PREFETCH (n1, [, n2] ) n1 和 n2 必须为 0 - 预取关闭 1 - 保守预取 2 - 主动预取 C*$* PREFETCH_MANUAL (n) n 必须为 0 - 忽略手动指令 1 - 遵守手动指令

消息标识：ERROR_1378

## Error:在此循环嵌套前%s列表中没有指定 DO 变量。

INTERCHANGE 指令的格式为： C*$* INTERCHANGE( DO-variable-list ) 而 BLOCKABLE 指令的格式为： C*$* BLOCKABLE( DO-variable-list ) 其中，DO-variable-list 中的每个名称必须为该指令之后循环嵌套中的 DO 变量名称。DO-variable-list 必须至少包含 2 个 DO 变量名。跟随指示性 INTERCHANGE 指令的循环嵌套必须完全嵌套。 INTERCHANGE 或 BLOCKABL 指令位于含有当前迭代 DO 循环的循环嵌套之前，当其 DO-variable-list 中未包含标明的 DO 变量名时，发出此消息。

消息标识：ERROR_1379

## Error:这些循环未完全嵌套。

应该完全嵌套迭代 DO 循环的当前嵌套，因为该嵌套是 INTERCHANGE 指令的主题。要完全嵌套，在循环嵌套的开头，DO 循环集必须具有顺序 DO 语句（即，在任何 DO 语句之间不出现其它语句）并且循环结束语句必须也有顺序。只要 DO 语句有顺序，在单个语句中结束的多循环仍然被看作完全嵌套。 在循环嵌套开头的两个 DO 语句之间或在循环嵌套结尾的循环结束语句之间出现语句时，发出此消息。

消息标识：ERROR_1380

## Error:语句不能出现在此指令和随后的 DO 循环之间。

命名指令之后必须紧跟着 DO 循环。语句不能出现在此指令和随后的 DO 循环之间。由于 DO 语句之外的语句跟随在命名指令之后，因此发出此消息。

消息标识：ERROR_1381

## Error:PREFETCH_REF_DISABLE 指令的参数必须为数组名。

PREFETCH_REF_DISABLE 指令用于禁用预取该指令中指定的所有数组引用。遇到无效数组名。

消息标识：ERROR_1382

## Error:此指令的 SIZE 参数必须为常量。

编译器将 PREFETCH_REF_DISABLE 和 PREFETCH_REF 指令的 SIZE 参数用于卷分析。该参数必须为常量。

消息标识：ERROR_1383

## Error:此 PREFETCH_REF 指令无效的 LEVEL 值。

对于 PREFETCH_REF 指令，LEVEL 子句可以向编译器说明要在内存层次中预取的级别。级别为 1 从 L2 到 L1 的预取 缓存级别为 2 从内存到 L1 缓存的预取 不允许其它值。

消息标识：ERROR_1384

## Error:此指令需要变量名参数。

FILL_SYMBOL 和 ALIGN_SYMBOL 指令的第一个参数必须为变量名。

消息标识：ERROR_1385

## Error:此指令的第二个参数必须是 L1cacheline、L2cacheline、页或幂为 2 的常量。

FILL_SYMBOL 或 ALIGN_SYMBOL 指令的第二个参数必须是幂为 2（1、2、4、8 等等...） 的常量或是关键字 L1cacheline、L2cacheline 或页等中的一个。

消息标识：ERROR_1386

## Error:已经为当前循环嵌套指定了指令。

当一个以上的 INTERCHANGE 指令或 BLOCKABLE 指令应用到单个循环嵌套时，发出此消息。通常在一个以上的此类指令位于循环之前时发出此消息，例如： C*$* INTERCHANGE(i, j, k) C*$* INTERCHANGE(j, k, m) DO j = 1, 5 ... 或者这些指令中的一个指令位于一个循环嵌套之前，并且另一个相同类型的指令出现在第一个指令范围内的两个 DO 语句之间，此时也会发出此消息，例如： C*$* INTERCHANGE(i, j, k) DO j = 1, 5 DO i = 1, 5 C*$* INTERCHANGE(m, k) DO k = 1, 5 DO m = 1, 5 ...END DO END DO END DO END DO

消息标识：ERROR_1387

## 内联：由于是具有交替实体的函数，所以例程没有内联。

用户正在试图内联具有交替实体的函数。内联函数不能确定代码是否确实只定义了所获得入口点的结果名称。 例如： FUNCTION IBA() 10 CONTINUE IBA = 3 RETURN ENTRY IDA() !This call will not inline.IDA = 1 GOTO 10 END

消息标识：INLINE_1388

## Error:DO 循环嵌套深度与 BLOCKABLE 指令 DO 变量列表中 DO 变量的数量不匹配。

如果在 BLOCKABLE 指令 DO 变量列表中指定的 DO 变量数量大于 BLOCKABLE 指令之后 DO 循环嵌套的嵌套深度，则发出此消息。例如，遇到以下程序段的第一个 END DO 时发出此消息。 C*$* BLOCKABLE(i, j, k) DO j = 1, 3 DO i = 1, 3 ...END DO END DO

消息标识：ERROR_1389

## 警告：Cray 字符指针对象将被处理为假定长度字符变量。

遇到以显式字符长度声明的 Cray 字符指针对象。指针对象的字符长度仅由关联 Cray 字符指针的赋值确定。指针对象将被处理为假定长度字符变量。显式长度规范将被忽略。 Cray 指针数据类型是 Fortran 标准的一个扩展。

消息标识：WARNING_1390

## Log_Warning：源文件不包含 Fortran 语句。

要成为一个有效的 Fortran 程序，源文件必须至少包含一个 END 语句。该源文件或者大小为零（完全为空）或者仅包含注释和/或空白行。此类实际或有效的空源文件不能构成一个 Fortran 程序。

消息标识：LOG_WARNING_1391

## Ansi：在规范表达式中，不允许能够返回整型以外的数据类型的内在属性。

标准不允许在规范表达式中返回整型以外数据类型的内在属性。

消息标识：ANSI_1392

## 警告：在下一版本中，将不会使用单个霍尔瑞斯或字符常量初始化多数组元素。

通过中断单个霍尔瑞斯或字符常量，扩展可以允许多个字长数组元素在 DATA 语句中初始化。这样的扩展是一个过时、有歧义和易出错的扩展。因此，从编译器下一版本开始将不再提供此扩展。霍尔瑞斯或字符常量将对应 DATA 语句目标列表中的单个数组元素。

消息标识：WARNING_1393

## Error:仅允许 COMMON 块名称和 COMMON 块变量作为 COPYIN 指令的参数。

此消息不再使用。 C$COPYIN 指令中的每项必须是局部 COMMON 块的成员。它可以是一个变量、一个数组、一个数组的单个元素或整个 COMMON 块。 注意：C$COPYIN 指令不能从平行区域内部执行。 例如， C$COPYIN x,y, /foo/, a(i) 传播 x 和 y 的值、在 COMMON 块 foo 中所有的值和数组 a 的第 i 元素。所有这些项目必须是局部 COMMON 块的成员。注意此指令已被译为可执行代码，所以在此示例中，执行此语句时会求出 i 值。

消息标识：ERROR_1394

## Error:C$COPYIN 指令不能用于平行区域内。

C$COPYIN 指令中的每项必须是局部 COMMON 块的成员。它可以是一个变量、一个数组、一个数组的单个元素或整个 COMMON 块。 C$COPYIN 指令不能从平行区域内部执行。 例如， C$COPYIN x,y, /foo/, a(i) 传播 x 和 y 的值、在 COMMON 块 foo 中所有的值和数组 a 的第 i 元素。所有这些项目必须是局部 COMMON 块的成员。注意此指令已被译为可执行代码，所以在此示例中，执行此语句时会求出 i 值。

消息标识：ERROR_1395

## Error:在%s指令中仅能指定数组变量名。

C$DYNAMIC 或 C$REDISTRIBUTE 指令必须具有作为参数的一个或多个数组名称。

消息标识：ERROR_1396

## Error:必须是标量 INTEGER 表达式。

指令的此参数必须是一个标量整型表达式。

消息标识：ERROR_1397

## Error:太少或太多 ONTO 值。

DISTRIBUTE、DISTRIBUTE_RESHAPE 和 REDISTRIBUTE 指令的 ONTO 子句（如果指定）必须具有与 BLOCK 或 CYCLIC 分配规范完全相同的值数量。不要为“*”分配规范指定 ONTO 值。

消息标识：ERROR_1398

## 警告：在 4.0 和更新的版本中，将不会支持此内在属性。

此内在属性不是标准的一部分并且正在逐渐淘汰。请更改您的代码。

消息标识：WARNING_1399

## Error:在此上下文中，不允许可分配数组。

已经将可分配数组指定给规范表达式内的查询内在属性。这是不允许的。

消息标识：ERROR_1400

## 警告：不带参数调用内在子例程 EXIT，以零代替。

未使用参数退出调用时，会自动将零作为参数 EXIT(3F) 提供。

消息标识：WARNING_1401

## Log_Summary：f90：MIPSpro Fortran 90 版本 %s (%s) %s

这确定了正在使用哪一个版本的编译器。

消息标识：LOG_SUMMARY_1402

## Log_Summary：f90：%d 个错误、%d 个警告、%d 个其它消息、%d 个 ANSI

此消息给出编译过程中发出的消息之汇总。

消息标识：LOG_SUMMARY_1403

## 警告：在接口体或接口块内不能指定 STACK 指令。

在接口体或接口块内不能指定 STACK 指令。该指令在此处没有意义。

消息标识：WARNING_1404

## 警告：在 MODULE 的规范部件中不能指定 STACK 指令。

在 MODULE 的规范部件中不能指定 STACK 指令。在 MODULE 的规范部件中，缺省的存储总是静态存储，不能用 STACK 指令更改。

消息标识：WARNING_1405

## 内部：cif_flush_include_recs 中的 file_id_list 溢出。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免编译器尝试发布此消息。

消息标识：INTERNAL_1406

## 警告：这有一个属性，指示将来可能会支持此方式的声明。

编译器检测到此对象声明中有冲突。鉴于对象的给定属性，不能将其声明为新的项目。尽管此时不被允许，但是在将来的版本中会被允许。

消息标识：WARNING_1407

## Error:它的声明方式指出将来可能会支持具有此属性的声明。

编译器检测到此对象声明中有冲突。该对象不能被赋予指定属性。尽管此时不被允许，但是在将来的版本中会被允许。

消息标识：ERROR_1408

## 内联：由于例程包含 !DIR$ INTEGER= 指令，所以例程没有被内联。

此指令可能会更改伪参数的类型，例程已内联时可能产生不正确结果。

消息标识：INLINE_1409

## 内部：关键字长度大于最大长度 127。

鉴于标记尺寸限制，关键字表中的所有项都必须少于 127 个字符。发出此消息时，请检查正在使用的表。 应避免产生此消息，它表示编译器错误或安装错误。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息并不表示您的代码有问题。

消息标识：INTERNAL_1410

## Error:不能在这个区域中指定此指令。

检测到编译器指令的不当使用。许多指令都存在不能在其中进行指定的代码区。例如，使用在由 C$PAR CRITICAL SECTION / C$PAR END CRITICAL SECTION 限制的临界断面内指定的 C$PAR PDO 指令。

消息标识：ERROR_1411

## Error:必须在这个区域内指定此指令。

检测到编译器指令的不当使用。许多指令只能在某些代码区域中指定。例如，C$PAR PDO 指令只能在由 C$PAR PARALLEL / C$PAR END PARALLEL 限制的平行区域中指定。

消息标识：ERROR_1412

## 警告：此数值常量超出范围。

发现一个数值常量超出范围。整型常量太大，或者实数常量的指数太大。

消息标识：WARNING_1413

## Ansi：符号常量“N$PES”是 Fortran 标准的一个扩展。

N$PES 是 Fortran 标准的一个扩展。它是一个特殊符号常量，已经由编译器将其预定义为 INTEGER 类型；不能给 N$PES 指定属性。它可以在合法使用符号常量的地方用作符号常量。N$PES 的值由编译器命令行选项、装入时选项或运行时选项设置。

消息标识：ANSI_1414

## Error:在此平台上不支持 AUTOSCOPE 子句。

在此平台上不支持 AUTOSCOPE 子句。任何无范围的变量将被假定为 SHARED。

消息标识：ERROR_1415

## Error:循环索引的顺序必须与此 NEST 子句中的顺序相对应。

PDO、PARALLEL DO 和 DOACROSS 指令的 NEST 子句必须使用与嵌套循环循环控制变量的顺序相同的参数顺序。 C$DOACROSS ...NEST(i,j,k) ... do i = 1,10 do k = 1,10 do j = 1,10 enddo enddo enddo 以上示例会发出此消息。

消息标识：ERROR_1416

## Error:此 AFFINITY 列表项与 NEST 列表不匹配。

在 DOACROSS、PDO 或 PARALLEL DO 指令的 AFFINITY 子句中指定的 DO 循环控制变量必须与 NEST 子句中列表的顺序相匹配。

消息标识：ERROR_1417

## Error:DATA 相似性不允许 ONTO。

在 DOACROSS、PDO 或 PARALLEL DO 指令中指定 DATA 相似性时，不能使用 ONTO 子句。

消息标识：ERROR_1418

## Error:数组是假定大小的指针对象。不能在模块中声明。

不能在模块程序单元中指定以假定大小说明符声明的数组。

消息标识：ERROR_1419

## Error:接口体无法从主机访问命名的实体，因此未定义此派生类型。

Fortran 标准的 NOTE 规定“接口体不能通过主关联访问命名的实体，但是可以通过 USE 关联访问实体。”编译器遇到用作派生类型的对象，但是在接口体定义内没有派生类型的定义。因为在接口体主体中编译器发现派生类型，所以该编译器（正确地或错误地）假定用户正在试图将派生类型主关联到接口体中。这是不允许的。此操作的最佳方法是将类型定义移动到模块并使用两处的模块。替换方法是在两处声明派生类型，注意该派生类型声明应符合匹配派生类型声明的要求。（如果两个不同类型的声明具有相同的名称、都具有 SEQUENCE 属性并且具有无 PRIVATE 可访问性而顺序、名称和属性一致的组件，那么它们被看作是相同的。）

消息标识：ERROR_1420

## 内部：在接口压缩过程中，局部名称入口已经压缩出去。不应该被压缩出去。

在接口块压缩过程中，局部名称表中的入口被压缩出去。不应将此入口压缩出去。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免编译器尝试发布此消息。

消息标识：INTERNAL_1421

## Error:CONCURRENT 指令中的 SAFE_DISTANCE= 值必须为大于或等于一的标量整型常量。

CONCURRENT 编译器指令的安全距离值必须是标量整型常量表达式，这样编译器才能在编译时求出其值。表达式求出的值必须是大于或等于 1 的整数值。

消息标识：ERROR_1422

## Ansi：已经确认此对象的隐式类型定义。在引用 IMPLICIT NONE前，Fortran 标准要求进行类型定义。

在作用单元中指定 IMPLICIT NONE 时，Fortran 标准要求在引用对象之前声明该对象的类型。在此测试中，设定该对象类型之前已有该对象的引用。

消息标识：ANSI_1423

## Error:由于指定了 IMPLICIT NONE，在引用、初始化或声明为常量之前必须声明其类型。

如果在一个范围内指定了 IMPLICIT NONE，那么 Fortran 标准要求在引用、初始化、指定为名称列表组中的对象或声明为常量之前声明该对象的类型。

消息标识：ERROR_1424

## 内联：因为函数结果类型不匹配，所以没有内联例程。

调用者/被调用者的函数结果类型不匹配。因此，编译器无法扩展此函数内联。

消息标识：INLINE_1425

## Error:在此范围内先前的语句中，已经引用或定义这种情况。可能不会为其赋予 PARAMETER 属性。

正在声明的对象已经引用或定义过。在引用或定义对象之前，必须为其赋予 PARAMETER 属性。

消息标识：ERROR_1426

## Error:这是 Cray 字符指针。其所有指针对象必须为字符，但它不是字符。

Cray 指针可以具有一个以上指针对象，但是所有指针对象必须为字符或非字符。不能混合使用。

消息标识：ERROR_1427

## Error:这是 Cray 指针对象。其所有指针对象必须为非字符，但已经将它的类型定为字符。

Cray 指针可以具有多个指针对象。但是，所有指针对象必须为字符或者非字符。不能混合使用。

消息标识：ERROR_1428

## 警告：此命令行选项覆盖了指定的指令，所以忽略了该指令。

指定的命令行选项与指定的指令不兼容。该指令已被忽略并作为注释行处理。

消息标识：WARNING_1429

## Error:在此指令的 LOCAL 子句中不能声明此数组。

在 mp 指令（例如 DOACROSS、PDO、PARALLEL DO）中不支持局部化的 ALLOCATABLE 或 POINTER 数组。不能在 LOCAL 子句中指定这些数组。同样，在 LOCAL 子句中不支持 Cray 指针对象。

消息标识：ERROR_1430

## Error:此指令此子句的参数必须为整型常量或变量。

该指令此子句的参数必须为整型常量或整型变量。 在 SEND 指令中的 POINT 子句，在 WAIT 指令中的 POINT 子句

消息标识：ERROR_1431

## Error:此指令此子句的参数必须为整型常量。

该指令此子句的参数必须为整型常量。 在 WAIT 指令中的 SPAN 子句

消息标识：ERROR_1432

## Error:此指令此子句的参数必须为逻辑表达式。

该指令此子句的参数必须为逻辑表达式。 在 SEND 指令中的 IF 子句

消息标识：ERROR_1433

## Error:此表达式所需的存储大小超过了最大可用存储大小。

此表达示所需的存储大小超过了本机的存储大小（以字节为单位）。表达式可能包含数组构造函数，或者是函数调用的结果。

消息标识：ERROR_1434

## Error:它所需的存储大小超过了最大可用存储大小。

此项目所需的存储大小超过了本机的存储大小（以字节为单位）。

消息标识：ERROR_1435

## 警告：此子句不被支持并将被忽略。

编译器遇到了一个可识别但却不被支持的任务指令子句。出现这种情况的原因是该子句与支持的硬件不相关或者将来的版本才会支持该子句。

消息标识：WARNING_1436

## 内联：因为将要生成常量 LOC()，所以例程没有被内联。

遇到的情形是在伪参数位置替换常量实际参数时将生成常量 LOC()。优化器不能处理此类构造。

消息标识：INLINE_1437

## 注意：此参数产生临时变量的副本。

函数或子例程调用具有必须被复制输入或复制输入/复制输出到临时变量的参数。如果消息提到“可能”复制输入或复制输出，那么将运行检查将被执行以查看 POINTER 或 ALLOCATABLE 参数的副本是否是必要的。

消息标识：CAUTION_1438

## Error:在规范表达式中不能出现伪参数。

基本过程的伪参数不能出现在规范表达式中，除非作为 BIT_SIZE、KIND、LEN 或数值查询内在属性的参数。

消息标识：ERROR_1439

## Error:必须在此指令中指定公共块名称而并非对象名称。

指令 SECTION_GP 和 SECTION_NON_GP 的参数必须为公共块名称或静态存储器中的变量。不能指定公共块中对象的名称。相反，要使用公共块名称。例如： COMMON /BLK/ A,B !*$*SECTION_GP /BLK/ ! correct !*$*SECTION_GP (A) ! illegal

消息标识：ERROR_1440

## Error:这有一个属性，指出不能使用该编译器指令进行指定。

编译器检测到此对象声明中有冲突。指定的属性和指令不兼容，因此不能将两者同时声明给该对象。

消息标识：ERROR_1441

## Error:它的声明方式禁止以此编译器指令对其进行再次声明。

编译器检测到此对象声明中有冲突。不能使用指定的编译器指令声明该对象。

消息标识：ERROR_1442

## Error:这已经声明并作为伪参数使用。不能使用此编译器指令来再次声明。

被声明的对象是一个被引用或定义的伪参数，该伪参数禁止使用指定的编译器指令声明该对象。

消息标识：ERROR_1443

## Error:它已被用作变量，因此不能用此编译器指令再次声明。

被声明的对象已用作变量，该变量禁止使用指定的编译器指令声明该对象。

消息标识：ERROR_1444

## 警告：此指令不能影响 -pfa 命令行选项下的自动任务。

在此平台上未完全执行 TASK 和 NOTASK 编译器指令。它们控制其它任务 CMIC$ 指令的识别，但是不影响 -pfa 命令行选项下的自动任务。

消息标识：WARNING_1445

## Error:在此指令的 PRIVATE 子句中不能声明此变量。

在 mp 指令 DOALL 和 PARALLEL 中，不支持私有化的 ALLOCATABLE 或 POINTER 变量。它们在 PRIVATE 子句中不能指定。 同样，不能使用 PRIVATE 子句指定 Cray 指针对象。

消息标识：ERROR_1446

## Error:这已经是符号常量，因此不能使用此编译器指令指定。

N$PES 是特殊符号常量。编译器将它定义为 INTEGER 型，并且不能更改类型。不能给 N$PES 赋予属性，也不能在任何编译器指令中指定 N$PES。它可以在合法使用符号常量的地方用作符号常量。N$PES 的值由编译器命令行选项、装入时选项或运行时选项设置。

消息标识：ERROR_1447

## Error:它已是使用关联，因此不能用此编译器指令再次声明。

对象成为使用关联之后，在任何规范语句或任何声明性编译器指令（例如 ALIGN_SYMBOL、FILL_SYMBOL、NAME、SECTION_GP、SECTION_NON_GP、VFUNCTION 或 SYMMETRIC）中不能指定该对象。

消息标识：ERROR_1448

## Error:这是主关联的，因此不能使用此编译器指令指定。

如果在主范围内声明对象并在局部范围内使用，那么该对象是主关联的。对象主关联到某个范围内之后，就不能重声明。也不能在声明性指令中指定。

消息标识：ERROR_1449

## Error:这被定为变量长度字符类型，因此不能使用此编译器指令再次声明。

编译器检测到此对象声明中有冲突。声明的对象类型已被定义为可变长度字符实体，所以不能声明为声明性编译器指令。

消息标识：ERROR_1450

## Error:这是一个有非恒定边界的显形数组，因此不能使用此编译器指令指定。

编译器检测到此对象声明中有冲突。声明的对象是具有非恒定边界的显形数组，这样就禁止在声明编译器指令中指定它。

消息标识：ERROR_1451

## Error:已经用此指令指定它，因此不能定义为变量长度字符类型。

编译器检测到此对象声明中有冲突。声明的对象由指令指定，这样就禁止将此对象定义为变量长度字符类型。

消息标识：ERROR_1452

## Error:它在显式接口中定义，因此不能用此编译器指令再次声明。

如果已为过程声明了显式接口，则必须在此显式接口内部指定描述此过程的所有信息（除 PTIONAL、PRIVATE 和 PUBLIC 属性）。此过程可以被指定为伪参数。也可以在 INLINE 指令中指定此过程。

消息标识：ERROR_1453

## Error:它已被用作函数，因此不能用此编译器指令再次声明。

声明的对象已被用作函数，因此不能对此对象作进一步的声明。

消息标识：ERROR_1454

## Error:它已被用作子例程，因此不能用此编译器指令再次声明。

声明的对象已被用作子例程，因此不能对此对象作进一步的声明。

消息标识：ERROR_1455

## Error:在初始化表达式中仅允许整型或字符类型的基本内在属性。

标准中提到，初始表达式的主项可以是整型或字符类型的基本内在函数引用，此时每个参数都是整型或字符类型的初始表达式。

消息标识：ERROR_1456

## Error:已经用此指令指定它，因此不能用其它指令再次指定。

编译器检测到此对象声明中有冲突。此对象不能在两个指令中都指定。

消息标识：ERROR_1457

## Error:已经用此指令指它定，因此不能用这种方式指定。

编译器检测到此对象声明中有冲突。指定的指令停止用此属性声明此对象。

消息标识：ERROR_1458

## Error:已经用此指令指定它，因此不能用此属性指定。

编译器检测到此对象声明中有冲突。指定的指令停止用该属性指定此对象。

消息标识：ERROR_1459

## 警告：已由编译器生成对 start_pes_() 的调用。

使用 –ufmm 选项时，编译器立刻生成对 start_pes_(0) 的调用。请删除代码中所有对 START_PES() 的用户调用。

消息标识：WARNING_1460

## Error:不允许使用此构造名称。

待提供。

消息标识：ERROR_1461

## Error:不允许使用此标签。

待提供。

消息标识：ERROR_1462

## Error:这（用此指令指定的）是过程。语句函数实际参数必须是标量数据对象。

语句函数的所有实际参数必须为标量数据对象。以下属性将非数据对象声明为过程。

消息标识：ERROR_1463

## Error:已经用此指令指定它。不能声明它为具有非恒定边界的显形数组。

编译器已检测到声明中有冲突。已用指定的指令声明此对象，因此不能声明它为具有非恒定边界的显形数组。

消息标识：ERROR_1464

## Error:已经用此指令指定它。它不能是边界取决于符号常量的数组。

编译器已检测到声明中有冲突。已用指定的指令声明此对象，因此它不能是用符号常量表达式声明其边界的数组。

消息标识：ERROR_1465

## Error:已经用此指令指定它，因此不能是接口块中的过程。

编译器已检测到声明中有冲突。已用指定的指令声明此对象，因此不能在接口块中将它声明为过程。

消息标识：ERROR_1466

## Error:已经用此指令指定它，因此它不能用作外部函数名。

编译器已检测到声明中有冲突。已用指定的指令声明此对象，因此它不能用作外部函数名。

消息标识：ERROR_1467

## Error:已经用此指令指定它，因此在 CALL 语句中不能用作子例程名。

编译器已检测到声明中有冲突。已用指定的指令声明此对象，因此它不能在 CALL 语句中用作子例程名。

消息标识：ERROR_1468

## Error:已经用 %s 指令指定它，因此不能用作派生类型名。

编译器已检测到声明中有冲突。已用指定的指令声明此对象，因此它不能用作派生类型名。

消息标识：ERROR_1469

## Error:已经用此指令指定它，因此不是常量。它不能用于初化表达式。

编译器已检测到声明中有冲突。对象已用指定的指令声明。因为它不是常量，所以不能用于初始化表达式。

消息标识：ERROR_1470

## Error:在此范围已引用或已声明它。它不能声明为函数结果。

如果在 FUNCTION 语句中指定结果名称，则此名称先前不能被引用过或声明过。以下示例中可能有先前引用过的内容： CHARACTER*(RSLT()) FUNCTION FUN() RESULT(RSLT) 如果结果名称与伪参数名称相同，那么可能是先前的声明。

消息标识：ERROR_1471

## Error:此 END CRITICAL 指令必须与匹配 CRITICAL 指令具有相同的名称。

如果命名了 CRITICAL 段，也必须命名与它成对的 END CRITICAL。

消息标识：ERROR_1472

## Error:对象必须是此指令子句中的变量。

在以下 OpenMP 指令的子句中仅允许数据对象。PRIVATE SHARED FIRSTPRIVATE COPYIN REDUCTION LASTPRIVATE

消息标识：ERROR_1473

## Error:不允许嵌套 DO、SECTIONS 和 SINGLE 指令。

不允许互相嵌套绑定到相同的 PARALLEL 指令的DO、SECTIONS 和 SINGLE 指令。PARALLEL DO 和 PARALLEL SECTIONS 指令可以被看作后面跟有适当的工作共享指令的 ARALLEL 指令。因此 DO、SECTIONS和 SINGLE 指令不能直接在 PARALLEL DO 或 PARALLEL SECTIONS 区域内嵌套。

消息标识：ERROR_1474

## Error:定义 RUNTIME 进度表类型时，在 SCHEDULE 子句中指定 CHUNK 是非法的。

在 OpenMP 任务指令的 SCHEDULE 子句中，仅能在 TYPE 为STATIC、DYNAMIC 或 GUIDED时指定 CHUNK。它不能用 RUNTIME 指定。

消息标识：ERROR_1475

## Error:变量在多个 !$OMP 指令子句中被指定。

每个在 !$OMP 指令子句中指定的变量仅在一个子句中显式出现，除非变量可以同时被指定为 FIRSTPRIVATE 和 LASTPRIVATE。

消息标识：ERROR_1476

## Error:为此指针对象声明范围属性是非法的。

在 OpenMP 任务指令中，Cray 指针对象不能具有为它们声明的范围。

消息标识：ERROR_1477

## Error:在 FIRSTPRIVATE 或 LASTPRIVATE 子句中不能指定它。

Fortran 指针、可分配的数组和 Cray 指针仅能在 OpenMP 任务指令的 PRIVATE 和 SHARED 子句中指定。在 FIRSTPRIVATE 或 LASTPRIVATE 子句中都不能指定它。

消息标识：ERROR_1478

## Error:在用 THREADPRIVATE 指令指定前，必须声明公共块。

!$OMP THREADPRIVATE 指令必须在公共块声明结束后出现在例程的声明段中。

消息标识：ERROR_1479

## Error:在 FLUSH 指令列表中仅允许命名的变量。

!$OMP FLUSH 指令具有可选列表。此列表仅包含命名的变量。

消息标识：ERROR_1480

## 在%s指令中不能声明空白公共区，“//”。

在 COMMON、TASK COMMON 或 THREADPRIVATE 指令中不允许将空白公共区指定为 //。这些指令必须指定命名的公共块。

消息标识：ERROR_1481

## Error:不能将此数组指定为 PRIVATE、FIRSTPRIVATE 或 LASTPRIVATE。

不能在 OpenMP 指令的 PRIVATE、FIRSTPRIVATE 或 LASTPRIVATE 子句中指定假定大小和假定形式的数组。

消息标识：ERROR_1482

## Error:对象必须是在此指令的 REDUCTION 子句中的标量变量。

仅命名的标量和定义了类型的内在变量才能出现在 REDUCTION 子句的变量列表中。不允许子对象、数组元素、指针和公共块是约简变量。

消息标识：ERROR_1483

## Error:在 %s 子句中不允许它。

Fortran 指针、可分配数组和 Cray 指针仅允许在 SHARED 和 PRIVATE 子句中使用。不允许在 REDUCTION 列表、FIRSTPRIVATE、LASTPRIVATE 和 COPYIN 子句中使用它们。

消息标识：ERROR_1484

## Error:公共块是主机或使用关联。不能使用 THREADPRIVATE 指令指定。

如果在 THREADPRIVATE 指令中指定了公共块，那么必须在所有声明中用此指令指定它。指定的公共块是此范围内的主机或使用关联，但未用 THREADPRIVATE 指令在其声明范围内指定它。THREADPRIVATE 可以仅由使用关联的公共块指定为确认声明。也即：它在声明模块中用 THREADPRIVATE 指定。如果在模块中用 THREADPRIVATE 声明公共块，则此指令可以用作一种决定方法。

消息标识：ERROR_1485

## Error:在用 THREADPRIVATE 指令指定前，公共块必须声明为存储块。

仅公共块可以用THREADPRIVATE 指令指定。相同的存储块不能用 TASKCOMMON 或 AUXILIARY 指令指定。它不能用 TASKCOMMON 语句指定。

消息标识：ERROR_1486

## Error:在此编译器指令中不允许变量子对象。

在以下指令中不允许变量子对象（数组元素或数组段、字符子串、结构组件引用）： 仅允许 SUPPRESS 变量名。 仅允许 CACHE_ALIGN 变量名和公共块。 仅允许 ALIGN_SYMBOL FILL_SYMBOL 公共块变量和自动变量。也可以指定公共块或模块名。如果指定了模块名，就将此指令应用于此模块中的所有非 COMMON 存储区。 仅允许 SECTION_GP SECTION_NON_GP 公共块变量和 SAVE 变量。也可以指定公共块或模块名。如果指定了模块名，就将此指令应用于此模块中的所有非 COMMON 存储区。

消息标识：ERROR_1487

## Error:它（公共块的成员）不能等价，因为已经为此块指定了此指令。

如果为公共块指定 ALIGN_SYMBOL 或 FILL_SYMBOL 指令，则公共块的成员不能等价。

消息标识：ERROR_1488

## Error:它（模块的成员）不能等价，因为已经为此模块指定了此指令。

如果为模块指定 ALIGN_SYMBOL 或 FILL_SYBMOL 指令，那么此模块（未在公共块中指定）中的所有静态对象都会受到此指令的影响。任何带有 ALIGN_SYMBOL 或 FILL_SYMBOL 指令都不能等价。

消息标识：ERROR_1489

## Error:存储块或模块已经为其指定了一个指令，所以同样不能指定冲突的指令。

ALIGN_SYMBOL 和 FILL_SYMBOL 指令是互斥的。如果为公共块或模块指定了一个指令，就不能指定其它指令。

消息标识：ERROR_1490

## Error:如果为模块名指定了编译器指令，它必须用于正在编译的当前模块。

SECTION_GP、SECTION_NON_GP、ALIGN_SYMBOL 和 FILL_SYMBOL 编译器指令可以为模块指定。但仅能为正在编译的当前模块指定这些指令。于是，此指令应用于此模块中的所有静态非公共存储

消息标识：ERROR_1491

## Error:伪参数具有 INTENT(IN) 属性。它必须是可定义的，以便在此子句中能够声明。

具有 INTENT(IN) 属性的伪参数不可定义。在 OpenMP 指令的PRIVATE、FIRSTPRIVATE、ASTPRIVATE 或 REDUCTION 子句中指定的所有变量必须是可定义的。

消息标识：ERROR_1492

## Error:变量在过程中，且无法被定义。它必须是可定义的，以便在此子句中能够指定。

在 OpenMP 指令的 PRIVATE、FIRSTPRIVATE、ASTPRIVATE 或 REDUCTION 子句中指定的所有变量必须是可定义的。 Fortran 标准中 PURE 过程的约束禁止在 PURE 子程序内对以下伪参数进行定义：函数子程序的所有伪参数和子程序内具有 INTENT(IN) 属性的所有伪参数。 约束也禁止公共名称、主机关联或使用关联变量出现在可能更改变量值的语句中。可以使用此变量，但不能在纯子程序内重新定义。 根据定义，基本子程序是纯子程序，因此上述约束也适用于基本子程序内的伪参数和变量。

消息标识：ERROR_1493

## 警告：已经引用变量，但并未在此程序单元中定义。

编译器已检测到在此程序单元中引用过但从未定义过的变量。此变量不是伪参数，也不在公共块中或是使用关联，如果在此程序单元中引用此变量，那么也应在此程序单元中定义它。

消息标识：WARNING_1494

## 内联：例程未被内联，因为它是模块过程并且 NOMODINLINE 已生效。

因为正在讨论的模块过程在 NOMODINLINE 的控制之下，所以没有关于内联的信息。可以通过命令行或者通过使用 NOMODINLINE 编译器指令指定 NOMODINLINE。

消息标识：INLINE_1495

## Error:它不是此范围内的模块，因此不能在隐式使用选项中将其指定为模块名。

对于此范围而言，在隐式使用命令行选项中指定为模块名的名称已经是其它内容而不是模块名。module_name 仅能是模块名。

消息标识：ERROR_1496

## Error:已经用此指令指定它。必须是公共块名、模块名或在静态存储中。

仅有静态分配的变量可以用 SECTION_GP 和 SECTION_NON_GP 编译器指令指定。(利用 SAVE 语句可以强迫静态分配变量。)也可以指定公共块或模块名。如果指定了模块名，就将此指令应用于此模块中的所有非 COMMON 存储区。

消息标识：ERROR_1497

## Error:必须在此指令中指定模块名而不是对象名。

Kay - 待提供

消息标识：ERROR_1498

## Error:此工作分配的值必须为正整数。

对于 DO ALL 和 DO PARALLEL 编译器指令，为工作分配 CHUNKSIZE 和 NUMCHUNKS 指定的值必须是大于零的整数值。

消息标识：ERROR_1499

## Error:伪参数数组的总尺寸大于此实际参数的尺寸。

数组伪参数的总尺寸在序列相关时必须小于或等于相关的实际参数数组的尺寸。如果数组为字符类型，字符伪参数数组的总长必须小于或者等于字符实际参数数组序列的总长。

消息标识：ERROR_1500

## Error:已经在函数字符长度表达式中引用它。不能用此指令声明它。

编译器检测到对象的使用和声明之间有冲突。声明的对象被函数字符长度表达式引用，这样就禁止用指定的编译器指令声明它。

消息标识：ERROR_1501

## Error:已经在此指令中指定公共块，因此必须在 COMMON 语句中指定。

如果在 CDIR$ (!DIR$) CACHE_ALIGN 语句中指定了公共块，那么 $OMP THREADPRIVATE 指令，或具有以下 *!*$* 指令 (*SECTION_GP, SECTION_NON_GP) 之一以及公共块也必须在 COMMON 语句中被声明。

消息标识：ERROR_1502

## Error:非法分支转移进或分支转移出区域。

分支转移进或分支转移出由 OpenMP 指令 PARALLEL、DO、SECTIONS、SINGLE、PARALLEL DO、PARALLEL SECTIONS、MASTER、CRITICAL 和 ORDERED 创建的结构块是非法的。这包括 GOTO 语句以及 ERR=、EOF= 或 EOR= IO 语句的分支和子例程调用交替返回的分支。

消息标识：ERROR_1503

## Error:非法分支转移进或分支转移出区域。

分支转移进或分支转移出由 -mp 指令DOACROSS、PSECTION、SECTION、PDO、PARALLEL DO、PARALLEL、CRITICAL SECTION 和 SINGLE PROCESS 创建的结构块是非法的。这包括 GOTO 语句以及 ERR=、EOF= 或 EOR= IO 语句的分支和子例程调用交替返回的分支。

消息标识：ERROR_1504

## Error:已经用此指令指定它，因此它必须是伪参数。

如果用 IGNORE_TKR 指令指定了对象，那么必须声明它为伪参数。

消息标识：ERROR_1505

## Error:ORDERED 指令仅能出现在 DO 或 PARALLEL DO 指令的动态范围内。

遇到未绑定到封闭的 DO 或 PARALLEL DO 指令的 ORDERED OpenMP 指令。检测到 ORDERED 指令，因为它位于 PARALLEL 指令的静态范围内。决不能将指令绑定到相距最近的封闭 PARALLEL 指令以外的任何指令上。PARALLEL SECTIONS 指令隐含着 PARALLEL 指令。

消息标识：ERROR_1506

## Error:ORDERED 指令绑定到没有指定 ORDERED 子句的 DO 指令上是非法的。

ORDERED 指令必须绑定到封闭的 DO 或 PARALLEL DO 指令上。必须在此指令上指定 ORDERED 子句。

消息标识：ERROR_1507

## Error:在模块的声明部分中必须指定此指令。

编译器已检测到在 PROGRAM、BLOCKDATA、外部 SUBROUTINE 或外部 FUNCTION 内的指定指令。在模块的声明部分中必须仅指定此指令。

消息标识：ERROR_1508

## Error:Do 循环控制变量在平行区域中，并且如果没有指定自动范围，则它必须在 PRIVATE 列表中。

如果没有指定 AUTOSCOPE，所有用于平行区域或 DOALL 循环的用户变量，必须在 SHARED 或 PRIVATE 列表中。Do 循环控制变量不能定义 SHARED 的范围，所以必须在 PRIVATE 列表中指定这些变量。

消息标识：ERROR_1509

## Error:因为已经指定了 DEFAULT(NONE)，所以变量必须显式声明其数据范围。

在 !$OMP PARALLEL、!$OMP PARALLEL DO 和 !$OMP PARALLEL SECTIONS 指令中使用DEFAULT(NONE) 子句意味着所有在这些区域内遇到的变量显式定义了其范围。

消息标识：ERROR_1510

## Error:在 IF 子句中的表达式必须为标量 Fortran 逻辑表达式。

如果 IF 子句出现在 !$OMP PARALLEL、!$OMP PARALLEL DO 或 !$OMP PARALLEL SECTIONS 指令中，它必须有与其参数相同的标量 Fortran 逻辑表达式。

消息标识：ERROR_1511

## Error:在封闭的 PARALLEL 区内，已私有化变量。无法再次进行私有化。

在封闭的工作分享指令中，平行区域中私有化的变量不能被再次私有化。因此，出现在工作分享指令中的 PRIVATE、FIRSTPRIVATE、LASTPRIVATE 和 RDUCTION 子句内的变量在封闭的平行区域中必须有共享的范围。工作共享指令为 !$OMP DO、!$OMP SECTIONS 和 !$OMP SINGLE。

消息标识：ERROR_1512

## Error:此指令必须紧跟在 Do 循环之后。

如果使用 !$OMP END DO、!$OMP END PARALLEL DO 或 !DIR$ META END DO 指令，它们必须紧跟在 Do 循环之后。

消息标识：ERROR_1513

## Error:在 OpenMP 工作共享构造中时，DO 循环迭代变量必须为整型。

DO 循环在 !$OMP DO 或 !$OMP PARALLEL DO 工作共享构造中时，DO 循环迭代变量必须为整型。

消息标识：ERROR_1514

## Ansi：过程在同一范围内具有多个已声明的显式接口。这是非标准的。

如果两个显式接口完全一致，编译器允许描述正在编译的程序单元的接口体存在。关键字（伪参数）的名称和数量必须相同。每个伪参数的种类、类型和等级必须相同。如果此过程是函数，那么种类、类型、等级和结果名称必须相同。在 Fortran 标准中这是不允许的。

消息标识：ANSI_1515

## Error:过程在此范围内具有多个已声明的显式接口。这些接口必须完全一致。

如果两个显式接口完全一致，编译器允许描述正在编译的程序单元的接口体存在。关键字（伪参数）的名称和数量必须相同。每个伪参数的种类、类型和等级必须相同。如果此过程是函数，那么种类、类型、等级和结果名称必须相同。编译器已检测到有差别。

消息标识：ERROR_1516

## Error:无效子句。

指令遇到了无法识别的子句。

消息标识：ERROR_1517

## 警告：这是 OpenMP 标准的一个扩展。应该具有 !$SGI 标记。

允许 mp 子句 AFFINITY 和 NEST 与 OpenMP 指令一起使用，但应与 !$SGI 标记一起使用，以使代码仍可移植。以下代码段说明了如何使用它们。 !$OMP DO !$SGI+ NEST (i) do i = 1,100 a(i) = 0 enddo 同时，可以用 !$SGI 标记指定 mp 指令 DISTRIBUTE、DISTRIBUTE_RESHAPE、REDISTRIBUTE、DYNAMIC 和 PAGE_PLACE，但不应该用 !$OMP 标记指定。

消息标识：WARNING_1518

## Error:必须在 %s 区内指定自动任务指令 WAIT。

必须在 DOPARALLEL 或 DOALL 区内指定 !MIC$ WAIT。CASE 或 GUARD 区中不允许它存在。

消息标识：ERROR_1519

## Error:必须在 DOPARALLEL 或 DOALL 区内指定此自动任务指令。

必须在 DOPARALLEL 或 DOALL 区内指定此自动任务指令 WAIT 和 SEND。

消息标识：ERROR_1520

## Error:必须对循环中所有 WAIT/SEND 对（除非是单个）编号。编号必须唯一。

在包含多个相关代码段的循环内，必须对所有 WAIT/SEND 对（除非是单个）编号。如果点值是整数变量，那么其值对每个 WAIT/SEND 对而言必须是唯一的。

消息标识：ERROR_1521

## Error:在定义对象类型前，对象不能用作 KIND 内在属性的参数。

在使用前，必须定义用作 KIND 内在属性参数的对象的类型。引用对象为 KIND 内在属性的参数后，编译器已检测到正在定义对象的类型。

消息标识：ERROR_1522

## Error:WAIT/SEND 对必须都具有相同的 POINT 值或两者都不具有 POINT 值。

编译器已检测到 WAIT/SEND 对中有 POINT 值不匹配。如果为 WAIT 指令指定了POINT 值，那么必须为 SEND 指令指定相同的 POINT 值。如果没有为 WAIT 指令 POINT 值，则不必为 SEND 指令指定 POINT 值。

消息标识：ERROR_1523

## 警告：由于例程 %s的内联扩展，COMMON 块长度正在增加。

内联的例程恰好包含与调用者中相同的 COMMON 块。被调用者中 COMMON 块的长度大于调用者中 COMMON 块的长度。这样，合并的 COMMON 块长度即为两者中较长的块长度。

消息标识：WARNING_1524

## Error:不允许一个循环内存在多个跨度。

在一个循环内指定的所有跨度都必须相同。编译器已检测到不同的跨度。

消息标识：ERROR_1525

## Error:此循环的等待/发送指令对最多为 %d，已经超出。

DOALL/PARALLEL 循环内非跨越的 WAIT/SEND 指令对总数的限制为 65。此数值包括一个未编号的 WAIT/SEND 指令对和 64个 编号唯一的 WAIT/SEND 指令对。如果没有使用未编号的 WAIT/SEND 对，则限制为 64。如果超出此限制，编译器就会出错。 对于跨越的 WAIT/SEND 指令对，限制为“64 /跨度值”。例如，跨度值为 4 时，限制为 16，包括一个未编号的 WAIT/SEND 对和 15 个编号唯一的 WAIT/SEND 对。另外，与每个 WAIT/SEND 对关联的 POINT 必须在 1 <= n <= 15 范围之内。即使没有使用未编号的 WAIT/SEND 对，此限制也不变。如果超出此限制，编译器就会出错。

消息标识：ERROR_1526

## Error:在此循环中，此 POINT 与其它 POINT 不匹配。

编译器已检测到有 SEND 或 WAIT 指令，而没有匹配的 WAIT 或 SEND 指令。指令的 POINT 值匹配或指令缺少 POINT 值。

消息标识：ERROR_1527

## Error:常量点值不能超过 wait/send 指令对的最大数。

如果点值为常量值，那么此值不能超过 wait/send 指令对所允许的最大数。此值按以下方法计算： DOALL/PARALLEL 循环内非跨越的 WAIT/SEND 指令对总数的限制为 65。此数值包括一个未编号的 WAIT/SEND 指令对和 64个 编号唯一的 WAIT/SEND 指令对。如果没有使用未编号的 WAIT/SEND 对，则限制为 64。如果超出此限制，编译器就会出错。 对于跨越的 WAIT/SEND 指令对，限制为“64 /跨度值”。例如，跨度值为 4 时，限制为 16，包括一个未编号的 WAIT/SEND 对和 15 个编号唯一的 WAIT/SEND 对。另外，与每个 WAIT/SEND 对关联的 POINT 必须在 1 <= n <= 15 范围之内。即使没有使用未编号的 WAIT/SEND 对，此限制也不变。如果超出此限制，编译器就会出错。

消息标识：ERROR_1528

## Error:对象已经是此模块中的模块过程，所以不能再次声明为模块过程。

声明的对象已经是模块过程。模块过程在模块中仅能声明一次。

消息标识：ERROR_1529

## 警告：此指令已废弃，并且在下一版本中将被删除。

MAXCPUS 指令已废弃，并且在编译器的下一版本中将被删除。(3.2 on PVP's).应改用 PARALLEL 或 DO ALL 指令中的 MAXCPUS 子句。

消息标识：WARNING_1530

## Error:此初始化表达式具有非常量值。在编译时它必须计算为常量值。

按照定义，在编译时初始化表达式必须计算为常量值。此初始化表达式没有计算为常量值。初始化表达式的主要用途是组件声明和参数声明。

消息标识：ERROR_1531

## Error:如果指定了 SPAN，那么它必须是 1 到 64 范围内的整型常量值。

WAIT 指令的 SPAN 参数必须是 1 到 64 范围内的整数常量。SPAN 参数可选。如果在 DOALL/DOPARALLEL 指令范围内为任何 WAIT 指令指定了 SPAN，那么必须在此范围内为所有 WAITs 指定相同的 SPAN。

消息标识：ERROR_1532

## Error:参数必须是缺省整数类型。

参数必须是缺省整数类型。

消息标识：ERROR_1533

## 内部：所有内在说明必须跟随所有非内在说明。内在次序紊乱。

编译器已发现在通用接口内有说明的意外排序。编译器未修正此排序。请提交关于此问题的报告。您可以将一些说明或 USE 语句重新排序，从而避开此问题。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免编译器尝试发布此消息。

消息标识：INTERNAL_1534

## Log_Error：已指定了“-O”，因此不能指定不兼容的“-O”。

如果在命令行中使用 -O 参数指定优化级别，则所有以下选项都不能在此命令行中指定： -O scalar0 -O vector0 -O task0 -O scalar1 -O vector1 -O task1 -O scalar2 -O vector2 -O task2 -O scalar3 -O vector3 -O task3

消息标识：LOG_ERROR_1535

## Log_Warning：优化级别应与调试级别兼容。

对于调试级别，优化级别设置得太高。使用 -O 命令行选项降低此优化级别。

消息标识：LOG_WARNING_1536

## Error:在 EQUIVALENCE 语句中不允许组件引用。

在 EQUIVALENCE 语句中不允许组件引用。

消息标识：ERROR_1537

## 警告：在 –O 整形命令行选项中已经指定了数组。它在此范围内不是数组。

编译器已发现与在整形维数命令行中指定的数组具有相同名称的对象。它不是数组。

消息标识：WARNING_1538

## Error:数组必须是使用 -O 整形指定的显形常量或变量大小确定的数组。

如果数组由整形维数命令行选项指定，那么此数组必须是显形常量或变量大小确定的数组。

消息标识：ERROR_1539

## Log_Error：指定 -O inlinepgm= 选项时，必须指定 -O inlinefrom= 选项。

-O inlinepgm= 选项要求 -O inlinefrom= 选项。

消息标识：LOG_ERROR_1540

## Error:对 DISTRIBUTE_RESHAPE 数组传递到假定形伪参数支持将在以后版本中实现。

编译器的此版本不支持此类（带有在 DISTRIBUTE_RESHAPE 编译器指令中指定的数组实际参数）假定形数组伪参数的关联。今后的版本会支持。

消息标识：ERROR_1541

## 警告：在程序单元而不是在块数据中初始化命名公共块成员，对于此体系结构为非法。

对象是由 DATA 语句或类型声明语句中的初始化值来初始化的。此对象是命名公共块的一个成员。Fortran 标准规定，如果对象是命名公共块的一个成员，那么它仅能在块数据程序单元内初始化。 在程序单元而不是在块数据程序单元中初始化命名的公共块成员会导致对同一公共块进行多次初始化。此体系结构中不允许对同一公共块进行多次初始化。

消息标识：WARNING_1542

## 内联：因为在调用图中此例程不是叶例程，所以例程没有被内联。

为此程序计算的调用图中非叶例程的例程不是扩展内联。叶例程是一种不调用其它例程的例程。

消息标识：INLINE_1543

## Error:跟随此指令的循环不能是不带循环控制的 DO WHILE 或 DO 循环。

跟随 !$OMP DO 或 !$OMP PARALLEL DO 指令的 DO 循环必须是迭代 DO 循环。它不能是不带循环控制的 DO WHILE 或 DO 循环。

消息标识：ERROR_1544

## 内联：因为实际和伪参数的等级不一致，所以例程没有被内联。

将实际数映射到伪参数时，它们的等级必须一致。 例如： program boo dimension a(10,10) call sam(a) ! will not inline end subroutine sam(b) dimension b(100) print *, b end

消息标识：INLINE_1545

## 内联：因为在所有维数中范围不一致，所以例程没有被内联。

为了产生内联，在关联的实际参数和伪参数的每个维数中，范围必须一致。 例如：program boo dimension a(11,10) call sam(a) ! will not inline because first dimension extents not equal end subroutine sam(b) dimension b(10,10) print *, b end

消息标识：INLINE_1546

## Error:必须在此指令中指定模块名称而不是变量名。

模块内特定的非公共变量不能用 SECTION_GP 和 SECTION_NON_GP 指令分别指定。通过用指令指定模块名，SECTION_GP 和 SECTION_NON_GP 指令可以应用于模块内的非公共变量。那么，SECTION_GP 或者 SECTION_NON_GP 指令将会应用于模块内所有的非公共静态存储。

消息标识：ERROR_1547

## Log_Warning：它不再是最主动的内联处理格式。请参阅此消息编号的解释。

现在，通过 -Oinline4 可以获得最主动的内联处理格式。-Oinline3 是一种新的内联处理格式。-Oinline3 调用叶例程内联。叶例程是一种不调用其它例程的例程。使用 -Oinline3 时，程序中仅有叶例程为扩展内联。

消息标识：LOG_WARNING_1548

## 警告：在自身定义内使用宏。

不能在自身定义内使用宏名称，因为这将导致无休止的递归宏扩展。此警告意味着指定的宏仍未定义。

消息标识：WARNING_1549

## 警告：在调用宏时参数太少。

此次调用宏时参数的数目与定义匹配。此警告意味着未出现宏扩展。

消息标识：WARNING_1550

## 警告：在调用宏时参数太多。

此次调用宏时参数的数目与定义匹配。此警告意味着未出现宏扩展。

消息标识：WARNING_1551

## Error:它具有 ALLOCATABLE 属性，因此必须指定为延迟形联合数组。

如果某对象已声明为可分配联合数组，则必须声明为延迟形联合数组。以下是声明 A 为可分配联合数组的两种正确方式。 ALLOCATABLE ::A(:)[:] REAL, ALLOCATABLE ::A DIMENSION A(:)[:] 以下方式非法。 ALLOCATABLE ::A(:)[8] REAL, ALLOCATABLE ::A DIMENSION A(:)[8]

消息标识：ERROR_1552

## 内联：因为实际参数是结构引用，所以例程没有被内联。

在实际参数是完整派生类型的位置编译器不能支持映射。

消息标识：INLINE_1553

## 内联：因为实际参数是字符常量，所以例程没有被内联。

内联函数不能扩展字符常量实际参数。

消息标识：INLINE_1554

## 内联：由于包含 DATA 语句，所以例程没有被内联。

包含诸如 DATA 语句的静态初始化的例程不能是扩展内联。

消息标识：INLINE_1555

## 内联：由于包含平行区域，所以例程没有被内联。

因为例程包含平行区域而且在平行区域内已经存在内联调用点，所以此例程不是扩展内联。平行区域不能存在于其它平行区域内。

消息标识：INLINE_1556

## Error:非法放置 NULL 内在属性。

NULL 内在属性可以出现在以下位置： 1) 指针赋值的右侧 2) 声明中对象的初始化 3) 缺省组件初始化 4) 在结构构造函数中 5) 作为实际参数 6) 在 DATA 语句中

消息标识：ERROR_1557

## Error:此 ALLOCATE 形式说明符残缺不全。

编译器遇到残缺的 ALLOCATE 形式说明符。如果使用了“:”，则必须指定上界和下界。以下所有示例都将产生此消息。 ALLOCATE ( a(:) ) ALLOCATE ( a(1:)) ALLOCATE ( a(:10) )

消息标识：ERROR_1558

## Error:在此上下文中，它仅能用 NULL 内在属性初始化。

指针仅能用 NULL 内在属性静态初始化。

消息标识：ERROR_1559

## Error:无效 CHUNK 值。

OpenMP SCHEDULE 子句的 CHUNK 参数值必须大于零。

消息标识：ERROR_1560

## Error:它必须是要在此指令列表中指定的局部声明变量。

变量以外的对象在编译器指令语句中的 SHARED 或 PRIVATE 列表内。变量也必须被局部声明。变量不能是主机关联或使用关联。

消息标识：ERROR_1561

## Error:非法指针赋值。

这不是有效的指针赋值语句。

消息标识：ERROR_1562

## 注释：字符声明的“* [,]”格式是一个废弃的格式。

字符声明不使用 * [,]，而使用以下格式：* () [,] OR (LEN=) [,] 请参见手册以了解其它格式。

废弃特征是 FORTRAN 77 或 Fortran 90 的多余特征，在 Fortran 95 中还有更好的方法。ANSI Fortran 委员会建议程序员在新程序中使用首选方法并将现有代码转换为首选方法。如果在 Fortran 程序中废弃特征的使用已经不重要，将来的 Fortran 标准委员会考虑将其从此标准中删除。

消息标识：COMMENT_1563

## Error:用此方法声明的函数不能声明为 CHARACTER*(*)。

Fortran 标准中的约束规定，用带星号的 char-len-param-value 声明的函数名不应为值确定的数组、值确定的指针、递归或纯子程序。 从 12.7.1. 来看，基本子程序是纯子程序

消息标识：ERROR_1564

## 注释：已废弃假定长度字符函数。

以下自 Fortran 标准： 在此语言中假定的函数字符长度不合常规，因为 Fortran 原理的其它地方规定：函数结果的属性仅取决于调用的实际参数，以及任何可以通过主机或使用关联由函数访问的数据。此功能的某些应用，可以用自动字符长度函数来代替，在这些地方，函数结果的长度在规范表达式中声明。通过使用子例程（其参数对应于函数结果和函数参数）可以代替其它的应用。请注意，函数的伪参数可以是假定字符长度。 废弃特征是 FORTRAN 77 的多余特征，在 Fortran 95中还有更好的方法，ANSI Fortran 委员会建议程序员在新程序中使用首选方法并将现有代码转换为首选方法。如果在 Fortran 程序中废弃特征的使用已经不重要，将来的 Fortran 标准委员会考虑将其从此标准中删除。

消息标识：COMMENT_1565

## 警告：无法调用假定长度字符函数。无法匹配调用者/被调用者的特性。

以下自 Fortran 标准： 仅在未调用此函数时，才可以为其结果带有字符长度参数 * 的伪函数或外部函数指定接口体。这是因为此特性必须被指定为在接口体和在过程定义中都相同，但是为了调用这种过程，调用例程要求指定 * 以外的长度。

消息标识：WARNING_1566

## Ansi：从 IF 构造外将控制传输到 END IF 语句是 Fortran 标准的一个扩展。

不是从其 IF 构造外分支转移到 END IF 语句，而是分支转移到 END IF 跟有的语句。如果跟随 END IF 的语句不是有效的分支目标语句，那么可能要求更改程序逻辑。

这是 FORTRAN 77 标准中删除的特征。删除的特征是 FORTRAN 77 的多余特征，在 Fortran 95中还有更好的方法，ANSI Fortran 委员会建议程序员在新程序中使用首选方法并将现有代码转换为首选方法。此编译器仍将支持此特征作为 Fortran 95 标准的一个扩展。

消息标识：ANSI_1567

## Ansi：此语句是 Fortran 标准的一个扩展。

列出的语句现在是 FORTRAN 95 标准中删除的特征。删除的特征是 FORTRAN 77 的多余特征，在 Fortran 95中还有更好的方法。此编译器仍将支持此特征作为 Fortran 标准的一扩展。

ASSIGN 语句允许将标签动态赋值给整型变量，而且赋值 GO TO 语句允许通过此变量的“间接分支”。这就防碍了程序流的可读性，特别是算术运算也使用整型变量时。整型变量这两种完全不同的用途可能导致混淆性错误。

这些语句一般用于模拟现在可以直接编码的内部过程。

在多数情况下，用等待输入数据的 READ 语句，可以采用可移植的方式实现PAUSE 语句的功能。

消息标识：ANSI_1568

## Ansi：类型为缺省实数或双精度实数的 DO 循环变量或表达式是 Fortran 标准的一个扩展。

实数或双精度实变量，或是 DO 循环表达式是被删除的特征。（删除的特征是 FORTRAN 77 的多余特征，在 Fortran 95中有更好的方法。）此编译器仍将支持此特征作为 Fortran 标准的一个扩展。

DO 变量或者整型表达式应该用来替代类型为缺省实数或双精度实数的 DO 循环表达式。

在 io_implied_do 中 DO 变量应为整型标量，而不是缺省实数或双精度实数。

消息标识：ANSI_1569

## Log_Error：不能使用%s命令行选项指定 -O 流命令行选项。

-Ostream、-Ostream 和 -Ostream 不能用 -Z 选项指定。

消息标识：LOG_ERROR_1570

## 注释：可执行语句中的定位 DATA 语句是一个废弃特征。

可执行语句中的 DATA 语句是一个废弃特征。 以下自 ANSI Fortran 标准 B.2.4：为了实现兼容，FORTRAN 66 以及此后的 FORTRAN 77 和 Fortran 90/95的语句排序规则允许 DATA 语句出现在规范语句之后程序单元中的任何位置。在可执行语句中，很少使用定位 DATA 语句功能，同时也不必使用，另外它还可能导致错误。 废弃特征是 FORTRAN 77 的多余特征，在 Fortran 95中还有更好的方法，ANSI Fortran 委员会建议程序员在新程序中使用首选方法并将现有代码转换为首选方法。如果在 Fortran 程序中废弃特征的使用已经不重要，将来的 Fortran 标准委员会考虑将其从此标准中删除。

消息标识：COMMENT_1571

## Error:不支持派生类型联合数组的组件的指针赋值。

在带有联合数组的 Fortran 初始执行过程中，联合数组衍生类型变量的 POINTER 组件作为 ALLOCATABLE 对象处理。这意味着对于这些组件不允许指针赋值。

消息标识：ERROR_1572

## Error:在此上下文中，MOLD 参数不是 NULL 内在属性的有效参数。

在初始化或 DATA 语句中不允许 MOLD 参数。

消息标识：ERROR_1573

## Error:MOLD 参数必须具有 POINTER 属性。

MOLD 必须具有指针属性。

消息标识：ERROR_1574

## Error:对于 THIS_IMAGE 内在属性，此参数必须为联合数组。

仅有联合数组可以作为可选参数 ARRAY 指定到 THIS_IMAGE 内在函数。

消息标识：ERROR_1575

## Error:最终联合数组的边界必须是“*”。

联合数组边界声明必须是假定的大小。联合数组的总大小始终等于图像数，因此最终边界必须始终指定为“*”。

消息标识：ERROR_1576

## Error:这是一个自动变量。它不能有联合数组 DIMENSION 属性。

自动变量不允许是联合数组。

消息标识：ERROR_1577

## Error:变量具有联合数组子对象。在 %s 语句中不能指定联合数组子对象。

在 EQUIVALENCE 或 DATA 语句中不能指定联合数组子对象。

消息标识：ERROR_1578

## Error:派生类型的组件具有联合数组 DIMENSION 属性。这是不允许的。

联合数组可以是派生类型，但派生类型的组件不能是联合数组。换句话说，在组件声明语句中不允许方括号表示法。

消息标识：ERROR_1579

## Error:纯子程序或基本子程序不能包含它，它是联合数组变量或内在属性。

纯过程不允许包含任何联合数组 Fortran 特征。如果消息指 USE 语句，那么带有联合数组 DIMENSION 属性的变量是使用关联。消息也可以用联合数组 DIMENSION 属性指主机关联变量。没有联合数组 Fortran 内在属性可以在纯过程或者基本过程中被调用。 按照定义，基本子程序是纯子程序，因此上述约束也适用于基本子程序。

消息标识：ERROR_1580

## Error:必须将所有语句包含在程序单元中且跟有 END。

编译器已检测到跟随所有程序单元的 trailing 语句。所有有效的 Fortran 语句必须包含在程序单元之内。尽管程序单元语句是可选的，程序单元也应以 BLOCKDATA、MODULE、PROGRAM、SUBROUTINE 或 FUNCTION 开始。程序单元以 END 语句结束。END 语句不是可选的。

消息标识：ERROR_1581

## 注释：在 Fortran 95 中，固定源格式是一个废弃特征。

在 Fortran 标准中，固定源格式是一个废弃特征。自由格式是首选方法。 废弃特征是 FORTRAN 77 或 Fortran 90 的多余特征，在 Fortran 95 中还有更好的方法。ANSI Fortran 委员会建议程序员在新程序中使用首选方法并将现有代码转换为首选方法。如果在 Fortran 程序中废弃特征的使用已经不重要，将来的 Fortran 标准委员会考虑将其从此标准中删除。

消息标识：COMMENT_1582

## Error:Fortran 今后可能会支持联合数组的一些特征。

在今后的初始原型版本中， Fortran 可能会支持联合数组的一些特征。

消息标识：ERROR_1583

## Error:此实际参数必须是联合数组，以便与联合数组伪参数相关联。

为确保联合数组伪参数不必使用复制进或复制出，实际参数必须具有联合数组名或联合数组的子对象。

消息标识：ERROR_1584

## Error:在联合数组引用中，当前仅支持类型为 64 位的变量。

在 T3E 的联合数组 Fortran 初始原型中，仅支持联合数组引用中的 64 位类型。

消息标识：ERROR_1585

## Error:非法分支转移进或分支转移出区域。

分支转移进或分支转移出由任务 DO 指令创建的结构块是非法的。这包括 GOTO 语句以及 ERR=、EOF= 或 EOR= IO 语句的分支和子例程调用交替返回的分支。

消息标识：ERROR_1586

## Error:联合数组必须具有 ALLOCATABLE 属性，以便在联合数组维数中具有延迟形式。

所有联合数组尺寸必须有显形边界，除非联合数组具有 ALLOCATABLE 属性。以下语句合法。integer, allocatable ::a(:)[:] 以下语句将产生此错误。integer ::a (10)[:]

消息标识：ERROR_1587

## Error:在平行或工作共享区域中，不允许此语句。

在创建平行或工作共享区域的当前语句之前遇到编译器指令。在此文上下中，不允许当前语句。 此代码将产生消息。 SUBROUTINE S(N) C$OMP PARALLEL INTEGER N C$OMP END PARALLEL END

消息标识：ERROR_1588

## Error:在 DATA 语句中不能指定它。已将其类型定为派生类型，已被缺省初始化。

以下自 Fortran 95 标准：如果非指针对象或子对象已经在类型定义中用缺省初始化指定，那么它将不会在数据对象列表中出现。换句话说，如果对象定义为具有缺省初始化的派生类型，那么在 DATA 语句中不能指定时间。通过在类型声明语句中指定初始化可以覆盖缺省初始化。

消息标识：ERROR_1589

## Error:它是带有 INTENT(OUT) 的假定大小数组。不能用这种方式定义类型，因为此类型已被缺省初始化。

标准禁止具有 INTENT(OUT) 属性（定义为缺省初始化的派生类型）的假定大小数组的伪参数。

消息标识：ERROR_1590

## Error:它不能等价于公共块中的对象，因为其类型是缺省初始化的。

以下自 Fortran 95 标准。等价关联不应导致具有缺省初始化的派生类型对象与公共块中的对象关联。

消息标识：ERROR_1591

## 内部：ntr_stor_blk_tbl 被使用无效存储块类型调用。这种情况决不应发生。

ntr_stor_blk_tbl 例程已被使用无效或未知的存储块类型调用。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免编译器尝试发布此消息。

消息标识：INTERNAL_1592

## 限制：宏扩展导致连续语句超出内部源缓冲区大小。

字符数组用于存储完整的 fortran 语句，因此源预处理器以对宏进行扫描。尽管此数组很大，也有可能溢出缓冲区。

消息标识：LIMIT_1593

## Error:在用于联合数组的 ALLOCATE 语句中，最终联合维数的上界必须始终是“*”。

要分配 ALLOCATABLE 联合数组，必须用假定大小形说明符 (*) 指定联合维数。 INTEGER, ALLOCATABLE ::A(:)[:] ALLOCATE(a(10)[2,*])

消息标识：ERROR_1594

## Error:不允许将控制传输到起始于那行的 FORALL 构造中。

语句试图将控制传输到 FORALL 构造中的语句。在FORALL 构造中，仅有 FORALL 构造语句本身可以是分支目标。

消息标识：ERROR_1595

## 警告：标签是在起始于那行的 FORALL 构造中定义的。

ASSIGN 语句中的标签在 FORALL 构造中包含的语句中定义。禁止将控制传输到 FORALL 构造的内部。

消息标识：WARNING_1596

## Error:在 FORALL 构造中不允许此语句。

在 FORALL 构造内仅允许赋值、指针赋值、WHERE 和 FORALL 语句或构造。

消息标识：ERROR_1597

## Error:FORALL 头中的索引名必须是类型为 INTEGER 的命名标量。

用于 FORALL 语句或结构中的索引名必须是类型为 INTEGER 的命名标量。它不能是命名的常量、变量子对象或数组元素。

消息标识：ERROR_1598

## Error:索引名已经是封闭 FORALL 构造的索引名。

在 FORALL 构造范围内，嵌套的 FORALL 语句或者 FORALL 构造不应有相同的索引名。

消息标识：ERROR_1599

## Error:对象的类型定义为缺省初始化的派生类型。它不能还是一个公共块对象。

Fortran 标准中的约束规定： 如果公共块对象为派生类型，那么它应为无缺省初始化的序列类型。 编译器已检测到属于包含缺省初始化的序列派生类型的公共块对象。

消息标识：ERROR_1600

## 内联：例程没有被内联，因为它带有联合数组伪参数。

在联合数组 fortran 的初始执行中，当过程具有联合数组伪参数时，不支持内联。

消息标识：INLINE_1601

## 警告：公共块用于多个程序单元。在所有使用中，它必须使用 %s 指令指定。

在此编译中，公共块用于多个程序单元。如果用描述存储或如何在块内赋值偏移的指令来指定公共块，那么在每个块中必须指定相同的指令。指令为 ALIGN_SYBMOL、FILL_SYMBOL、SECTION_GP、SECTION_NON_GP 和 CACHE_ALIGN。（注意：不是在所有的平台上都有所有这些指令。）可以用来防止出现这类问题的 Fortran 特征是：在模块中声明公共块，然后在任何声明的公共块使用该模块。用这种方法可以保证公共块无论用于何处，都将有相同的声明。

消息标识：WARNING_1602

## 注意：公共块已在多个程序单元中声明。一个或多个公共对象在类型、种类或等级方面不同。

在编译过程中，编译器追踪所有的公共块和公共块中的对象。编译器已找到至少一个对象的种类、类型和/或等级与在同一个公共块的先前声明中的对象不同。

消息标识：CAUTION_1603

## Error:在 forall-triplet-spec 中的下标或跨度必须是标量整数表达式。

在 forall-triplet-spec 中使用的下标或跨度表达式必须是标量整数表达式。

消息标识：ERROR_1604

## Error:下标或跨度不能引用与其同在 forall-triplet-spec-list 中出现的索引名。

在 forall-triplet-spec 中使用的下标或跨度表达式不能从同一个 FORALL 标题中引用索引名。嵌套的 FORALL 语句或构造可以从封闭的 FORALL 构造中引用索引名。

消息标识：ERROR_1605

## Error:在 forall-triplet-spec 中的跨度值不能为零。

在 forall-triplet-spec 中使用的跨度值一定不能为零。

消息标识：ERROR_1606

## Error:用于 FORALL 语句的 scalar-mask-expr 必须是标量逻辑表达式。

如果存在用于 FORALL 语句或构造的标量屏蔽表达式，它必须是标量逻辑类型表达式。

消息标识：ERROR_1607

## Error:在 FORALL 索引为活动状态时，不能对其进行定义。

活动 FORALL 索引名出现在将改变它的值的语句中。FORALL 索引可在它出现的 FORALL 构造或语句的范围内使用，但不能在其中重新定义。

消息标识：ERROR_1608

## Error:屏蔽 ELSE WHERE 块不能跟在 ELSE WHERE 块之后。

如果 WHERE 构造包含 ELSE WHERE 块，ELSE WHERE 一定是构造中的最后一块。因此，屏蔽的 ELSE WHERE 块不能跟在 ELSE WHERE 块之后。

消息标识：ERROR_1609

## Error:WHERE 构造中的所有屏蔽表达式必须同形。

如果 WHERE 构造包含 WHERE 语句、屏蔽的 ELSEWHERE 语句或其它 WHERE 构造，那么在 WHERE 构造中的每个屏蔽表达式必须同形。遇到形式与封闭的 WHERE 结构的屏蔽表达式不同的屏蔽表达式。

消息标识：ERROR_1610

## Error:过程在 FORALL 内引用。它必须是 PURE 过程。

在 FORALL 语句、或构造的标量屏蔽表达式中、或 forall-body-construct 中引用的任意过程，包括由定义的操作或赋值所引用的过程，应该是 PURE 过程。

消息标识：ERROR_1611

## 内联：例程未被内联，因为它被联合数组实际参数调用。

在联合数组 fortran 的初始执行中，当过程被联合数组实际参数调用时，不支持内联。

消息标识：INLINE_1612

## 内联：例程未被内联，因为它与一个联合数组成员共享了一个公共块。

在联合数组 fortran 的初始执行中，当过程共享至少有一个联合数组成员的公共块时，不支持内联。

消息标识：INLINE_1613

## 注意：过程也在另一行被引用。此参数的函数结果的类型和等级不一致。

全局名称的使用范围是整个编译，所以，在编译中对全局（或外部）名称的定义和引用必须一致。编译器已找到对此全局名称的引用或定义不同与此名称的另一个引用或定义。 在伪参数和实际参数之间存在不匹配。与伪参数相关联的实际参数类型必须一致。如果这些都是函数定义，那么伪过程的函数结果的类型和等级必须一致。如果比较伪过程和实际过程，那么函数结果的类型和等级必须一致。

消息标识：CAUTION_1614

## 警告：过程已在另一行中定义。伪参数是数组参数。此参数是标量。

全局名称的使用范围是整个编译，所以，在编译中对全局（或外部）名称的定义和引用必须一致。编译器已找到对此全局名称的引用或定义不同与此名称的另一个引用或定义。 编译器比较两个定义或比较一个定义与一个对列出的过程的引用。如果编译器比较两个定义，那么编译器已在一个定义中找到一个伪参数是数组参数，但在第二个定义中相应的伪参数是标量参数。参数必须相同。如果编译器正在比较一个引用和它的定义，那么它已找到与标量实际参数相关联的数组伪参数或与数组伪参数相关联的标量实际参数。再次说明，参数必须都是标量或都是数组。（注意：在引用中，数组元素被看作标量。）

消息标识：WARNING_1615

## 注意：过程也在另一行被引用。那里的参数是标量。此参数是值确定的数组。

全局名称的使用范围是整个编译，所以，在编译中对全局（或外部）名称的定义和引用必须一致。编译器已找到对此全局名称的引用或定义不同与此名称的另一个引用或定义。

消息标识：CAUTION_1616

## 注意：函数也在另一行被引用。两个引用的函数结果的类型和等级不同。

全局名称的使用范围是整个编译，所以，在编译中对全局（或外部）名称的定义和引用必须一致。编译器已找到对此全局名称的引用或定义不同与此名称的另一个引用或定义。 如果同一个函数在编译过程的几个位置被引用，函数结果类型和等级应该一致。

消息标识：CAUTION_1617

## 警告：函数也在另一行被引用。函数结果的类型和等级与此定义不同。

全局名称的使用范围是整个编译，所以，在编译中对全局（或外部）名称的定义和引用必须一致。编译器已找到对此全局名称的引用或定义不同与此名称的另一个引用或定义。 如果同一个函数在编译过程的几个位置被引用，函数结果类型和等级应该一致。

消息标识：WARNING_1618

## 注意：过程也在另一行被引用。参数是值确定的数组。此参数是标量。

全局名称的使用范围是整个编译，所以，在编译中对全局（或外部）名称的定义和引用必须一致。编译器已找到对此全局名称的引用或定义不同与此名称的另一个引用或定义。

消息标识：CAUTION_1619

## 警告：程序单元在另一行以一种方式引用，但在此处的定义或引用的方式不同。

全局名称的使用范围是整个编译，因此全局（或外部）名称只能声明一次。对此全局名称的任何引用必须正确，并与此名称的定义相匹配。 编译器找到了引用的程序单元和定义不匹配，或两个引用不匹配。参阅消息 1293 中的示例。

消息标识：WARNING_1620

## 警告：此过程也在另一行被引用。在一个引用中参数是标签，而在另一个引用却不是。它们应当相同。

全局名称的使用范围是整个编译，所以，在编译中对全局（或外部）名称的定义和引用必须一致。编译器已找到对此全局名称的引用或定义不同与此名称的另一个引用或定义。 对“子例程”的引用包含用户标签作为实际参数。在其它引用中，参数不是用户标签。相应的参数应该是相同的，或都是标签、都是程序单元或都是数据对象。

消息标识：WARNING_1621

## 警告：它也在另一行中被引用。参数是用户标签。伪参数必须是一个交替返回参数。

全局名称的使用范围是整个编译，所以，在编译中对全局（或外部）名称的定义和引用必须一致。编译器已找到对此全局名称的引用或定义不同与此名称的另一个引用或定义。 显形接口或子例程定义将该此伪参数定义为交替返回参数 (*)，但是调用点不提供作为相应的实际参数的用户标签。

消息标识：WARNING_1622

## 警告：这也被定义在另一行中。在两个定义中，参数必须是交替返回参数。

全局名称的使用范围是整个编译，所以，在编译中对全局（或外部）名称的定义和引用必须一致。编译器已找到对此全局名称的引用或定义不同与此名称的另一个引用或定义。 此子例程有多个显形接口。（这可能是对“子例程”的实际定义或多个接口块。）在两个定义中，伪参数应该是相同的，但它们不是。在一个定义中，伪参数是交替返回参数。在另一个定义中，它不是。它们应当相同。

消息标识：WARNING_1623

## 错误：此属性也在另一行中定义。此属性仅在一个定义中指定。两个定义中都应指定。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与接口块或另一程序单元定义不一致。它们应当相同。 经过检查的属性包括纯属性、基本属性和递归属性。 备注：对于 PURE – 如果在定义上指定 PURE，它不需要在接口体中指定。

消息标识：ERROR_1624

## 错误：此指令也在另一行中被引用。此指令在一个位置上指定，而没有在另一个位置上指定。

在此编译的全局语义分析中，编译器发现在不同的程序单元中的两个引用相互不一致。在两个不同的程序单元中进行了调用过程。在一个程序单元中，用指定的指令声明了被调用者。在另一个程序单元中，没有为被调用者指定这个指令。正在被检查的指令为 NOSIDE、EFFECTS 和 VFUNCTION。

消息标识：ERROR_1625

## Ansi：省略此编辑描述符的字段宽度，是 Fortran 标准的一个扩展。

当出现不带任何字段宽度（或数字或指数）的编辑描述符时，发出此消息。 例子：(I) (F) (G)

消息标识：ANSI_1626

## Error:等价对象是子串时，长度不能为零。

Fortran 标准中的约束规定如果等价对象是子串，其长度不应为零。

消息标识：ERROR_1627

## Ansi：省略此编辑描述符的字段宽度，是 Fortran 标准的一个扩展。

当把零用作编辑描述符的字段宽度时，发出此消息，此标准规定宽度不应为零。 例子：(L0) (I0) 在 FORTRAN 77 和 Fortran 90 中时发出错误消息，但在 Fortran95（以及以后版本）允许

消息标识：ANSI_1628

## Error:某个（些）字母已在先前的 IMPLICIT 语句中指定，所以不能再次指定。

一个字母只能在域单元的 IMPLICIT 类型语句中被指定一次，并且只能在域单元的 IMPLICIT 存储语句中被指定一次。 例如： IMPLICIT INTEGER (A) IMPLICIT REAL (A,B) !非法 这是非法的，因为 A 在先前 IMPLICIT 类型语句中指定过。

消息标识：ERROR_1629

## Log_Error：宏超过字符的最大支持个数。

给定宏的定义比能支持的限制长。减小宏的长度将解决这个问题，方式可能是将宏分解为几个较小的宏。

消息标识：LOG_ERROR_1630

## 警告：预处理指令时遇到未终止的字符文字。

源预处理程序在源预处理程序指令内遇到没有结束分隔符的字符文字。

消息标识：WARNING_1631

## Error:不能定义符号常量。

不能定义符号常量。

消息标识：ERROR_1632

## 警告：该维数的数组下标不在定义范围内。

在下标超出数组边界时，遇到数组引用。下标可能是单值或三元组段。如果指定 -Rb 并且下标和边界值是常量，编译器在编译时将检查数组边界。针对特定代码范围或特定变量，BOUNDS 和 NOBOUNDS 编译器指令将控制是否发出此消息。以下代码说明了将发出此消息的三种情况。 integer i(10) i(11) = 1 i(1:11:1) = 1 i(-1:10:1) = 1

消息标识：WARNING_1633

## 警告：子串的开始或结束值在定义范围之外。

字符子串引用的子串指示器不当。在以下字符子串引用中，子串指示器的开始和结束值指示了子串的开始字符和结束字符的位置： CHAR ([begin]:[end]) 如果子串长度大于 0，那么开始和结束值必须大于 0 并小于或等于实体中字符的个数，CHAR。如果结束值比开始值小，子串长度为 0。

消息标识：WARNING_1634

## Error:参数不匹配：这些必须都是函数或都是子例程，并且带有相同数量的参数。

已为实际过程和伪过程声明了显形接口。编译器已找到一个是函数而另一个是子例程或实际参数和伪参数的参数个数不同。

消息标识：ERROR_1635

## Log_Summary 解释命令提供关于每条信息的详细信息

解释命令给出了此信息的更详细的描述以及发出它的原因。关于解释命令的详细信息，请参阅手册解释。例如：要得到关于消息 33 的详细信息，请使用下列命令： f90-724 f90：ERROR MAIN__，File = d.f，Line = 1, Column = 14 未知语句。要求使用赋值语句，但找到“EOS”而不是“=”或“=>”。 说明 f90-724

消息标识：LOG_SUMMARY_1636

## 注释：命令行选项被应用于此数组。

指定的数组已被整形，因为它在整形命令行选项上被指定，或因为已指定通用整形命令行选项，而且此数组满足必要的标准。

消息标识：COMMENT_1637

## Error:作为定义赋值的 WHERE 赋值语句必须是基本的。

如果在 WHERE 语句或 WHERE 构造中的赋值是已定义的赋值，子例程必须是基本的。

消息标识：ERROR_1638

## Error:这是一个基本过程。它不能被用作实际参数。

Fortran 标准约束规定非内在基本过程一定不能被用作实际参数。

消息标识：ERROR_1639

## Ansi：Fortran 标准不允许 END 语句延续。

Fortran 标准约束规定 END 语句一定不能延续。

消息标识：ANSI_1640

## Ansi：此标准规定必须指定 ALLOCATABLE、POINTER 或 SAVE，因为它是缺省初始化类型。

Fortran 标准的约束描述如下： “如果已为一种类型的对象指定组件初始化，而这种类型的对象出现在模块的说明部分中并且没有 ALLOCATABLE 或 POINTER 属性，那么此对象将有 SAVE 属性。” 此约束针对在模块的说明部分中声明的对象，这些对象不是公共块中的成员，也不是常量。 如果一个对象被定义为派生类型，已为其指定缺省初始化，那么必须为此对象指定 SAVE 属性。 此编译器放松了这条约束规则，并且不需要指定 SAVE，因为在模块说明部分指定的对象被视为 SAVEd 对象。

消息标识：ANSI_1641

## Error:此过程正在被传递到一个 PURE 过程。它也必须是 PURE 过程。

在 Fortran 标准中的一项约束要求所有传递到 PURE 过程的过程必须是 PURE 过程。

消息标识：ERROR_1642

## 内部：此 enum 已被更改。

编译器在列出的 enum 中检测到一处更改。此 enum 不能以这种方式更改。 应避免产生此消息。请将此错误消息编号和所有支持信息通告您的产品支持组织。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_1643

## Error:要用 -O 整形指定数组，数组不能被静态初始化。

已被静态初始化的数组不能被整形。

消息标识：ERROR_1644

## Error:公共块不能在 !$OMP THREADPRIVATE 指令和 !*$* SECTION_GP 指令中同时指定。

!$OMP THREADPRIVATE 指令防止任何公共块被放置在 GP-rel 区域中。任何指定 THREADPRIVATE 公共块的 SECTION_GP 指令将导致发出此错误消息。

消息标识：ERROR_1645

## Error:实际参数的等级小于伪参数的等级。

指定 -Oreshape 选项时，用户不能映射等级比相关联的伪参数低的实际参数。

消息标识：ERROR_1646

## 警告：这是 CRI 指针对象。它将不被缺省初始化。

CRI 指针对象可以被声明为派生类型，但它们不能被缺省初始化，因为在为 CRI 指针对象分配存储器前，没有存储器与其相关联。

消息标识：WARNING_1647

## Error:data-stmt-constant 必须是已命名或文字常量或 NULL() 或是一个结构构造函数。

KAY – 更新：对 data-stmt-repeat 的定义如下： data-stmt-repeate 是标量整型常量或标量整型子对象 遵循以下约束： data-stmt-repeat 应该为正或零。 如果 data-stmt-repeat 是命名常量，应该预先在域单元中声明它或通过使用关联或主机关联可以访问它。 data-stmt-repeat 在标量常量子对象中，任何下标都应该是初始化表达式。

消息标识：ERROR_1648

## 警告：表达式中检测出了为零的除数。

当编译器检测出为零的除数，并且使用此除数的表达式在编译时不需要求值，出现可能的用户错误时发出“警告”级消息。如果此表达式是在编译时求值的常量表达式，发出“错误”级消息。

消息标识：WARNING_1649

## Error:此参数不能是常数。

此实际参数不能为常量。

消息标识：ERROR_1650

## Error:DO SERIAL 自动任务指令已经在此区域中。

待提供。

消息标识：ERR_WAS_DOSERIAL

## Error:因强制等价造成对象错误对齐。

在一个对象与另一个对象等价时，其在等价组中的偏移未能向通常那样使对象严格对齐。例如：

    INTEGER(2) A		! 通常 A 按16 位对齐
    INTEGER(1) B(2)
    EQUIVALENCE(A,B(2))	! 等价造成 A 仅按 8 位对齐

消息标识：ERR_BAD_ALIGNMENT

## ???

此消息不再使用。Use DEFAULT_HTML_LINK2..

消息标识：DEFAULT_HTML_LINK

## Error:下标越界。

在下标超出数组边界时，遇到数组引用。如果指定“-C”并且下标和边界值是常量，编译器在编译时将检查数组边界。

消息标识：WARNING_1911

## Error:在 INTEL 平台上不支持数据类型。

在 INTEL 平台上不支持 128 位浮点操作。这包括 REAL*16、REAL(KIND=16)、DOUBLE PRECISION*16、COMPLEX*32、COMPLEX(KIND=16)。

消息标识：IA32_ERROR_1912

## Error:在 INTEL 平台上，对 ###### 类型不支持 KIND 值 ######。

待提供。

消息标识：IA32_ERROR_1913

## 警告：编译器指令 #### 必须在目标子程序前出现。

待提供。

消息标识：WARNING_1914

## Log_Error：选项有非法参数。

该指定选项的参数是非法的。

消息标识：ERROR_ERROFF

## 内部编译器错误：源自编译器 FW 部分的内部错误。

待提供。

消息标识：FW_INTERNAL_ERROR_1

## 内部编译器错误：%s：%s %d。

待提供。

消息标识：FW_INTERNAL_ERROR_2

## 内部编译器错误：源自编译器 FW 部分的内部错误。

待提供。

消息标识：FW_INTERNAL_ERROR_3

## 内部编译器错误：源自编译器 FW 部分的内部错误。

待提供。

消息标识：FW_INTERNAL_ERROR_4

## 内部编译器错误：源自编译器 FW 部分的内部错误。

消息标识：FW_INTERNAL_ERROR_5

## 内部编译器错误：源自编译器 FW 部分的内部错误。

消息标识：FW_INTERNAL_ERROR_6

## 不允许使用这个对象和那个对象的 ERROR_IVAL_EQUIV 等价。

待提供。

消息标识：ERROR_IVAL_EQUIV

## 不允许使用带有各种类型参数的这些区间对象的 ERROR_IVAL_EQUIV_KIND 等价。

待提供。

消息标识：ERROR_IVAL_EQUIV_KIND

## ERROR_IVAL_CONST 区间常量的左端点必须小于或等于右端点。

待提供。

消息标识：ERROR_IVAL_CONST

## ERROR_IVAL_INTERVAL_ARG 伪参数 X 是区间类型，因此不能出现伪参数 Y。

待提供。

消息标识：ERROR_IVAL_INTERVAL_ARG

## WARN_IVAL_DEFOP_WIDESTNEED 多处需要的求值不能应用于用户定义的操作参数。

待提供。

消息标识：WARN_IVAL_DEFOP_WIDESTNEED

## WARN_IVAL_REAL_PARAM“%s”参数不必等于其定义的常量表达式的数学值。

待提供。

消息标识：WARN_IVAL_REAL_PARAM

## ERROR_IVAL_OP_KIND_MISMATCH 运算“%s”不允许具有不同种类类型参数值的操作数。

待提供。

消息标识：ERROR_IVAL_OP_KIND_MISMATCH

## ERROR_IVAL_ASSIGN_KIND_MISMATCH 当区间表达式与区间变量具有不同类型参数值时，区间表达式对区间变量的赋值是不允许的。

待提供。

消息标识：ERROR_IVAL_ASSIGN_KIND_MISMATCH

## Error:SIZEOF 内在函数不能用于假定大小的数组。

消息标识：SIZEOF_ERROR_01

## Error:SIZEOF 内在函数不能用于已传递长度的字符。

消息标识：SIZEOF_ERROR_02

## Error:Cray 字符指针不能指向 CHARACTER*(*) 变量。

Cray 指针不能指向声明为假定长度字符 (CHARACTER*(*)) 的数据对象。

消息标识：ERROR_CRICHARPTR

## Error:变量“%s”不会在任何 THREADPRIVATE 公共块中出现，因而不能用作 COPYIN 指令的参数。

消息标识：ERR_NO_THREADPRIVATE_VAR

## Error:公共块“%s”不是 THREADPRIVATE，因此它不能用作 COPYIN 指令的参数。

消息标识：ERR_NO_THREADPRIVATE_COMMON

## 内部编译器错误：文件名行号：shiftcount 超出 ar_dblshift 中的范围

在执行移位操作的同时，编译器检测到移位数超出有效范围。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2000

## 内部编译器错误：文件名行号：shiftcount 超出 ar_divide_integer 中的范围。

在整数除法操作过程期间执行移位操作的同时，编译器检测到移位数超出有效范围。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2001

## 内部编译器错误：文件名行号：AR_convert_str_to_int 中的无效乘法和/或加法。

在求整数常量值时，编辑器在内部乘法和/或加法操作中检测到错误。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2002

## 内部编译器错误：文件名行号：AR_convert_int_to_str 中存在无效的除法。

在把整数值转换为可打印的字符串时，编辑器在内部乘法和/或加法操作中检测到错误。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2003

## 内部编译器错误：文件名行号：ar_clear_unused_bits 被使用浮点或其它无效类型调用。

编译器内部函数，ar_clear_unused_bits，被带有浮点型的无效参数调用。当编译过程对表达式求值时调用此函数。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2004

## 内部编译器错误：文件名行号：未载入 AR_c2fapprox。

CRAY-2 倒数和倒数平方根近似函数，AR_c2fapprox，不是编译器内建的算术库的一部分。编辑器在编译时不能求 \s-1CRAY-2\s+1 数学表达式的值。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2005

## 内部编译器错误：文件名行号：未载入双精度复数例程。

数学库中双精度复数的接口不是编译器内建的算术库的一部分。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2006

## 内部编译器错误：文件名行号：在数学库内调用 ARERP%%/merrp%%。

在常量简化库外部的编译期间，对数学库函数的调用异常中断并试图调用数学库错误处理例程 ARERP%（或在 CRAY-2 系统上的 merrp%）。此行为有时由编译器中除数为零的运算引起。

ARERP% 例程在编译器中被取而代之，以便编译器能试图将调用合并到一些数学库内在函数中，并且没有因不良数据而中断整个编译的危险。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2007

## 内部编译器错误：文件名行号：截断位超出范围。

编译器内部函数 AR_CRAY_64_trunc 被用无效截断值调用当编译过程对浮点表达式求值时调用此函数。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2008

## 内部编译器错误：文件名行号：无法打开内在仿真文件。

当编译器遇到涉及这些内在函数的常量表达式时，编译器为目标平台仿真这些内在函数。无法打开包含内在函数指令和数据的文件。显然在此系统上不可访问此文件。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2009

## 内部编译器错误：文件名行号：无效的内在仿真文件

当编译器遇到涉及这些内在函数的常量表达式时，编译器为目标平台仿真这些内在函数。包含内在函数指令和数据的文件格式不正确或不能被读取。格式应为在目标平台上被截断的可执行 a.out 文件格式，并且版本信息与 Craylibs 的发布版本应一致。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2010

## 内部编译器错误：文件名行号：不被支持的内在函数。

当编译器遇到涉及这些内在函数的常量表达式时，编译器为目标平台仿真这些内在函数。不是所有的内在函数能被编译器所用。编译器请求了不可用的内在函数求值。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2011

## 内部编译器错误：文件名行号：仿真的内在函数错误。

当编译器遇到涉及这些内在函数的常量表达式时，编译器为目标平台仿真这些内在函数。此仿真使用目标系统库中的原样指令和数据。在此仿真中不允许一些结束条件情形。例如，调用内存管理例程以分配更多空间未被仿真。对这些例程的调用被中止并返回错误条件。最可能的错误原因是输入的数字字符串过长。其它原因可能是由系统库例程自身的改变造成的，这些改变未反映在仿真例程中或试图改写只读的内在数据。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2012

## 内部编译器错误：文件名行号：遇到未仿真的指令。

当编译器遇到涉及这些内在函数的常量表达式时，编译器为目标平台仿真这些内在函数。这种仿真不仿真目标系统硬件的所有指令 – 只仿真那些为仿真支持的内在函数必要的指令。遇到未被仿真的指令。最可能的错误原因也许是由于新版本的系统库内在例程，其中包含迄今未被仿真的新指令。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2013

## 内部编译器错误：文件名行号：仿真的内在接口错误。

当编译器遇到涉及这些内在函数的常量表达式时，编译器为目标平台仿真这些内在函数。包含内在函数指令和数据的文件有一个针对被仿真的内在函数的新接口。这与用于建立编译器的旧接口不兼容。需要用支持新接口的 Craylibs 更高版本重新建立编译器。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2014

## 内部编译器错误：文件名行号内部名：不被支持的内在函数。

当编译器遇到涉及这些内在函数的常量表达式时，编译器为目标平台仿真这些内在函数。编译器请求了一个未知的内在函数求值。这可能因为较新的编译器使用了旧版本文件，此文件包含内在函数的指令和数据。此旧的文件不包含新编译器编译求值时所需的所有内在函数。需要安装与新编译器兼容的 Craylibs 版本。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2015

## 警告：体系结构仿真：潜在地不同内在函数值。

当编译器遇到涉及这些内在函数的常量表达式时，编译器为目标平台仿真这些内在函数。编译时执行的求值将使用与载入已编译程序所用的内在库的版本不同。结果，依赖所用的内在函数以及 Craylibs 库所做的更改，数字结果稍有不同是可能的。通常情况下，编译器应使用与其一起发布的 Craylibs 版本。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：WARNING_2016

## 内部编译器错误：内在名行号：未载入内在例程。

数学库中给定的内在例程的接口不是编译器内建算术库的一部分。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2017

## 内部编译器错误：文件名行号：不一致的浮点类型。

当编译器遇到涉及这些内在函数的常量表达式时，编译器为目标平台仿真这些内在函数。包含内在函数指令和数据的文件使用与编译器要求的格式不同的浮点格式。例如，已打开的文件使用 Cray 浮点格式，而编译器要求 IEEE 浮点结果。

应避免产生此消息。请将此错误消息编号和所有支持信息通告您的系统支持人员。此消息不表示您的代码有问题，尽管您可以通过更改代码避免遇到此错误。

消息标识：INTERNAL_2018

## 内部编译器错误：来自目标库的内部错误。

编译器不能确定编译的主机或体系结构。

消息标识：INTERNAL_2019

## 注释：字符声明的“* [,]”形式是废弃的。

字符声明不使用 * [,]，而使用以下格式：* () [,] OR (LEN=) [,] 请参见手册以了解其它格式。

废弃特征是 FORTRAN 77 或 Fortran 90 的多余特征，在 Fortran 95 中还有更好的方法。ANSI Fortran 委员会建议程序员在新程序中使用首选方法并将现有代码转换为首选方法。如果在 Fortran 程序中废弃特征的使用已经不重要，将来的 Fortran 标准委员会考虑将其从此标准中删除。

消息标识：COMMENT_1744

## Error:当其参数不是限定表达式时，内在调用“%s”在规范表达式中是无效的。

消息标识：ERR_INTR_IN_SPEC_EXPR

## Error:隐含 DO 嵌套深度超出了编译器限制。

消息标识：ERR_IMPLIED_DO_NESTING

## workshop.f90l.sparc

消息标识：LIC_SUNPRO_FEATURE_F90L

## Error:具有不等长度的定长字符数组构造函数值是非标准并不被支持。

Fortran 标准的 4.5 节要求数组构造函数中的所有元素的长度必须相等。

消息标识：ERR_UNEQUAL_LENGTH_CONSTRUCTORS

## Error:超出允许的数组边界。

消息标识：ERR_BOUND_OUT_OF_RANGE

## 警告：子串的起始点超过结束点。

起始点和结束点必须在字符串范围内，除非起始点超过结束点，在这种情况下，子串长度为零。如果指定“-C”并且子串值是常量，编译器将在编译时检查这种情况。

消息标识：WARNING_SUBSTRING

## Error:在 OpenMP 指令中不允许使用此子句。

遇到的子句在指定的 OpenMP 指令中不被支持。

消息标识：ERR_OPENMP_CLAUSE_NOT_ALLOW

## Error:内在 KIND 获得被禁止类型作为实际参数。

内在 KIND 获得被禁止类型作为实际参数。

消息标识：ERR_KIND_ARG_PROHIBITED

## 内部编译器错误：内在函数 SIZEOF 得到未预料的实际参数类型。

内在函数 SIZEOF 得到未预料的实际参数类型。

消息标识：INTERNAL_2020

## 警告：子串超出范围。

起始点和结束点必须在字符串范围内，除非起始点超过结束点，在这种情况下，子串长度为零。如果指定“-C”并且子串值是常量，编译器将在编译时检查这种情况。

消息标识：WARNING_SUBSTR_RANGE

## Error:不允许内部文件使用无格式读/写语句，或其无效。

Fortran 95 标准的 9.2.2.2 节。对内部文件有以下约束：(1) 仅由按顺序存取的格式化 i/o 语句读写记录，这种语句不指定名称列表格式。

消息标识：ERR_UNFMT_IO_ON_INTERNAL

## Error:下标越界。

在下标超出数组边界时，遇到数组引用。如果指定“-C”并且下标和边界值是常量，编译器在编译时将检查数组边界。

消息标识：ERR_OUT_OF_RANGE

## Error:对指针组件的子组件进行数据初始化

指针组件不是初始化中最右边的部分引用时，遇到数据初始化；例如 DATA T % P % I /0/，在这里 P 是指针。标准不允许这种情况。仅能将指针 P 自身进行初始化，而且仅对 NULL() 函数适用。

消息标识：ERR_PTR_CPNT_INIT

## Ansi：在首先声明长度选择符并且出现 LEN 关键字时，省略 KIND 关键字，是对 Fortran 标准的一个扩展。

在首先声明长度选择符并且出现 LEN 关键字时，省略 KIND 关键字，是对 Fortran 标准的一个扩展：请参阅 R507 (J3/97-007R2)

消息标识：ANSI_OMMITED_KIND

## Error:SIZEOF 内在函数不能应用于动态地确定大小的参数。

消息标识：SIZEOF_ERROR_03

## Error:下一个语句必须是一个 DO 语句。

跟随应用于 DO 循环的并行指令的语句必须是 DO 语句。

消息标识：ERR_STMT_NOT_DO

## 属性说明

Fortran 标准的术语。

消息标识：ANNEX_D_ATTR_SPEC

## 块数据名

Fortran 标准的术语。

消息标识：ANNEX_D_BLOCK_DATA_NAME

## 逗号或数据语句对象或 EOS

Fortran 标准的术语。

消息标识：ANNEX_D_COMMA_DSTMT_OBJECT_EOS

## 公共块名

Fortran 标准的术语。

消息标识：ANNEX_D_COMMON_BLOCK_NAME

## （/公共块名/）

Fortran 标准的术语。

消息标识：ANNEX_D_CBLOCK_NAME_DELIMITED

## /公共块名/

Fortran 标准的术语。

消息标识：ANNEX_D_CBLOCK_NAME_DELIMITED2

## 公共块名或 /

Fortran 标准的术语。

消息标识：ANNEX_D_CBLOCK_NAME_OR_SLASH

## 公共块对象

Fortran 标准的术语。

消息标识：ANNEX_D_COMMON_BLOCK_OBJECT

## 公共块对象或 /

Fortran 标准的术语。

消息标识：ANNEX_D_CBLOCK_OBJECT_OR_SLASH

## 组件名

Fortran 标准的术语。

消息标识：ANNEX_D_COMPONENT_NAME

## 构造名

Fortran 标准的术语。

消息标识：ANNEX_D_CONSTRUCT_NAME

## 构造名称或 EOS

Fortran 标准的术语。

消息标识：ANNEX_D_CONSTRUCT_NAME_OR_EOS

## data-i-do-object

Fortran 标准的术语。

消息标识：ANNEX_D_DATA_I_DO_OBJECT

## data-i-do-object 或 data-i-do-variable

Fortran 标准的术语。

消息标识：ANNEX_D_DATA_I_DO_OBJ_OR_VAR

## data-i-do-variable

Fortran 标准的术语。

消息标识：ANNEX_D_DATA_I_DO_VARIABLE

## 数据语句常量

Fortran 标准的术语。

消息标识：ANNEX_D_DATA_STMT_CONSTANT

## 数据语句重复

Fortran 标准的术语。

消息标识：ANNEX_D_DATA_STMT_REPEAT

## 数据语句重复或数据语句常量

Fortran 标准的术语。

消息标识：ANNEX_D_DATA_STMT_REPT_OR_CONS

## 数据语句对象

Fortran 标准的术语。

消息标识：ANNEX_D_DATA_STMT_OBJECT

## 定义的运算符

Fortran 标准的术语。

消息标识：ANNEX_D_DEFINED_OPERATOR

## 数字串

Fortran 标准的术语。

消息标识：ANNEX_D_DIGIT_STRING

## 维数说明

Fortran 标准的术语。

消息标识：ANNEX_D_DIMENSION_SPEC

## （维数说明）

Fortran 标准的术语。

消息标识：ANNEX_D_DIMENSION_SPEC_W_PARS

## do 变量

Fortran 标准的术语。

消息标识：ANNEX_D_DO_VARIABLE

## do 变量或 WHILE

Fortran 标准的术语。

消息标识：ANNEX_D_DO_VARIABLE_OR_WHILE

## 伪参数名

Fortran 标准的术语。

消息标识：ANNEX_D_DUMMY_ARG_NAME

## 入口名

Fortran 标准的术语。

消息标识：ANNEX_D_ENTRY_NAME

## = 或逗号或是“（下标列表）”

Fortran 标准的术语。

消息标识：ANNEX_D_EQ_COMMA_SUBLIST_W_PARS

## 等价对象

Fortran 标准的术语。

消息标识：ANNEX_D_EQUIVALENCE_OBJECT

## 所有主体构造

Fortran 标准的术语。

消息标识：ANNEX_D_FORALL_BODY_CONSTRUCT

## 函数名

Fortran 标准的术语。

消息标识：ANNEX_D_FUNCTION_NAME

## 通用名

Fortran 标准的术语。

消息标识：ANNEX_D_GENERIC_NAME

## if 构造名称

Fortran 标准的术语。

消息标识：ANNEX_D_IF_CONSTRUCT_NAME

## 隐含 do 对象

Fortran 标准的术语。

消息标识：ANNEX_D_IMPLIED_DO_OBJECT

## 隐含 do 对象或 do 变量

Fortran 标准的术语。

消息标识：ANNEX_D_IMPLIED_DO_OBJ_OR_VAR

## 索引名

Fortran 标准的术语。

消息标识：ANNEX_D_INDEX_NAME

## 索引名或屏蔽表达式

Fortran 标准的术语。

消息标识：ANNEX_D_INDEX_NAME_OR_MASK_EXPR

## 内部过程

Fortran 标准的术语。

消息标识：ANNEX_D_INTERNAL_PROCEDURE

## （或，或 ::或类型名

Fortran 标准的术语。

消息标识：ANNEX_D_LP_COMMA_DOTS_TYPE_NAME

## 模块名

Fortran 标准的术语。

消息标识：ANNEX_D_MODULE_NAME

## 模块过程

Fortran 标准的术语。

消息标识：ANNEX_D_MODULE_PROCEDURE

## 命名的常量

Fortran 标准的术语。

消息标识：ANNEX_D_NAMED_CONSTANT

## 名称列表组名

Fortran 标准的术语。

消息标识：ANNEX_D_NAMELIST_GROUP_NAME

## 名称列表组对象

Fortran 标准的术语。

消息标识：ANNEX_D_NAMELIST_GROUP_OBJECT

## 对象名

Fortran 标准的术语。

消息标识：ANNEX_D_OBJECT_NAME

## 对象名或 /

Fortran 标准的术语。

消息标识：ANNEX_D_OBJECT_NAME_OR_SLASH

## ONLY 或使用名

Fortran 标准的术语。

消息标识：ANNEX_D_ONLY_OR_USE_NAME

## OPERATOR 或 ASSIGNMENT 或通用名

Fortran 标准的术语。

消息标识：ANNEX_D_OP_ASG_GENERIC_NAME

## 程序名

Fortran 标准的术语。

消息标识：ANNEX_D_PROGRAM_NAME

## 过程名

Fortran 标准的术语。

消息标识：ANNEX_D_PROCEDURE_NAME

## 结果名称

Fortran 标准的术语。

消息标识：ANNEX_D_RESULT_NAME

## 标量整型文字常量

Fortran 标准的术语。

消息标识：ANNEX_D_SCALAR_INT_LIT_CONS

## 标量整型文字常量或（

Fortran 标准的术语。

消息标识：ANNEX_D_SCALAR_INT_LIT_CONS_LP

## 标量整型变量

Fortran 标准的术语。

消息标识：ANNEX_D_SCALAR_INT_VARIABLE

## 标量屏蔽表达式

Fortran 标准的术语。

消息标识：ANNEX_D_SCALAR_MASK_EXPR

## 子例程名称

Fortran 标准的术语。

消息标识：ANNEX_D_SUBROUTINE_NAME

## 子例程名列表

Fortran 标准的术语。

消息标识：ANNEX_D_SUBSCRIPT_LIST

## 类型名称

Fortran 标准的术语。

消息标识：ANNEX_D_TYPE_NAME

## 使用名

Fortran 标准的术语。

消息标识：ANNEX_D_USE_NAME

## 变量名

Fortran 标准的术语。

消息标识：ANNEX_D_VARIABLE_NAME

## where 构造名称

Fortran 标准的术语。

消息标识：ANNEX_D_WHERE_CONSTRUCT_NAME

## 警告：对模块“MODULE”和该编译两者必须都用产生 8 字节数据对齐的选项（-fast、-dalign 或 –f）进行编译，或都不使用。

消息标识：DALIGN_OPTION_WARNING

## Error:给定子句的参数必须是标量 INTEGER 表达式。

消息标识：CLAUSE_MUST_BE_INTEGER

## Error:对象“%s”用在 THREADPRIVATE 指令中，因而必须是一个变量。

消息标识：ERR_THREADPRIVATE_NO_VAR

## Error:%s“%s”用在 THREADPRIVATE 指令中，但它对此类对象是禁用的。

消息标识：ERR_THREADPRIVATE_ATTR

## Error:变量“%s”用在 THREADPRIVATE 指令中，因而不能是公共块的一部分。

消息标识：ERR_COMMON_VAR_IN_THREADPRIVATE

## Error:变量“%s”用在 THREADPRIVATE 指令中，因而不能在 EQUIVALENCE 语句中声明。

消息标识：ERR_EQU_VAR_IN_THREADPRIVATE

## Error:变量“%s”用在 THREADPRIVATE 指令中且没有在模块范围内声明，因而必须要有 SAVE 属性。

消息标识：ERR_NO_SAVE_IN_THREADPRIVATE

## Error:在 !$OMP WORKSHARE 构造中不允许使用此语句。

在 WORKSHARE 构造内仅允许赋值、WHERE 和 FORALL 语句或构造。

消息标识：ERR_BAD_WORKSHARE_STMT

## Error:变量“%s”不会在任何 THREADPRIVATE 公共块中出现，因而不能作为 COPYPRIVATE 指令的参数。

消息标识：ERR_WRONG_COPYPRIVATE_VAR

## Error:公共块“%s”不是 THREADPRIVATE，因而不能用作 COPYPRIVATE 指令的参数。

消息标识：ERR_WRONG_COPYPRIVATE_COMMON

## Error:已指定 AFFINITY 子句，因此不能指定 SCHEDULE 子句。

消息标识：ERR_SCHEDULE_AND_AFFINITY

## Error:伪参数具有 ALLOCATABLE 属性。它需要一个带 ALLOCATABLE 属性的实际参数。

具有 ALLOCATABLE 属性的伪参数必须与具有 ALLOCATABLE 属性的实际参数匹配。

消息标识：ERROR_1836

## Error:等价对象为含具有 ALLOCATABLE 属性的最终组件的派生类型。

派生类型的等价对象的一个组件为可分配数组。具有可分配组件的派生类型无法等价。

消息标识：ERROR_1837

## Error:具有可分配组件的派生类型的 I/O 列表项目是不被允许的。

如果派生类型最终包含可分配组件，那么此类型的对象既不能作为 I/O 输入项目出现，也不能作为 I/O 输出列表项目的评估结果出现。

消息标识：ERROR_1838

## Error:这是一个具有最终可分配组件的派生类，因此不能是命名常量。

命名常量不能赋予 ALLOCATABLE 属性，而且不能是具有可分配组件的派生类型。

消息标识：ERROR_1839

## Error:伪参数具有 INTENT(IN) 属性，因此不能在 ALLOCATE/DEALLOCATE 语句中使用。

具有 INTENT(IN) 的伪参数不能在调用过程中改变其分配状态。

消息标识：ERROR_1840

## Error:只有 MAX、MIN、IAND、IOR 或 IEOR 等内在属性才可用在 REDUCTION 子句中。

消息标识：ERR_WRONG_REDUCTION_INTRINSIC

## Error:数组%s不能是延迟形式、假定形式或假定大小，如果用于指令%s的 REDUCTION 子句中。

消息标识：ERROR_WRONG_REDUCION_ARRAY

## Error:如果为类型字符的伪参数指定 VALUE 属性，那么长度参数将被省略，或被具有值一的初始化表达式指定。

消息标识：VALUE_CHARACTER

## 如果指定了 VALUE 属性，就不会指定 [...] INTENT(INOUT) 或 INTENT(OUT) 属性

消息标识：VALUE_INTENTOUT

## Error:它有一个属性指示其现在不能位于公共块。

具有可分配数组最终组件的派生类型对象不应成为公共块对象。

消息标识：ERROR_COMMON_ALLOCAT_CMPT

## Error:%s和%s子句不要同时在%s指令中指定。

Fortran 标准的术语。

消息标识：ERR_INCOMPATIBLE_CLAUSES

## Error:应该是结构名

消息标识：ANNEX_D_STRUCT_NAME

## Error:结构类型名不能定义多次。

结构类型名只能定义一次。编译器发现一个类型名称被连续用于定义另一个结构。

消息标识：ERR_DUP_STRUCT

## Error:结构需要在 STRUCTURE 声明中定义后，才能用于 RECORD 语句。

结构需要在 STRUCTURE 声明中定义后，才能用于 RECORD 语句。

消息标识：ERR_UNDEF_STRUCT

## Error:在 RECORD 语句中只允许使用结构类型。

RECORD 语句必须使用先前声明的结构类型。

消息标识：ERR_NOT_STRUCT_TYPE

## Error:在 UNION 类型不应出现的地方发现该类型。

UNION 项目出现在不应出现的地方。

消息标识：ERR_UNION_NOT_EXPECTED

## Error:在结构声明内，只允许序列派生类型。

在结构内使用了派生类型组件，但此派生类型未声明为序列派生类型。

消息标识：ERR_SEQUENCE_TYPE_REQUIRED

## Error:百分号后只允许 %FILL 作为结构组件名。

结构组件名之前为“%”字符，但之后不能跟“FILL”。

消息标识：ERR_FILL_EXPECTED

## 警告：结构名不超过 30 个字符。当结构名超过 30 个字符时，会被删减到 30 个字符，可能和其它符号冲突。

指定的结构名超过 30 个字符。因此会被删减到 30 个字符。

消息标识：ERR_LONG_STRUCT_NAME

## Ansi：STRUCTURE/UNION/MAP/RECORD 和相应的 END 语句是 Fortran 标准的扩展。

STRUCTURE、END STRUCTURE、UNION、END UNION、MAP、END MAP和 RECORD 语句不是 Fortran 标准的组成部分。

消息标识：ANSI_VAX_STRUCTURE

## 警告：过程已在前一行定义。标量实际参数与数组伪参数非法关联。

全局语义检测到定义和在另一程序单元中的引用之间存在差异。 数组伪参数不能具有与其相关联的标量实际参数。此处允许数组元素。

消息标识：WARNING_ILLEGAL_ASSOC

## Error:函数“%s”不是 ELEMENTAL，因而不能用于 WORKSHARE 块。

消息标识：ERR_NO_ELEMENTAL_IN_WORKSHARE

## Error:STRUCTURE 语句在另一个结构中声明，但其后未跟记录名列表。

当在另一个结构内使用 STRUCTURE 语句时，语句后需跟记录名列表。

消息标识：WARN_NESTED_STRUCT_NEED_REC

## Error:在 UNION 定义中，只允许 MAP 定义。

在 UNION 定义范围中唯一允许的语句是 MAP 和 ENDMAP。

消息标识：NOT_IN_UNION

## Error:Vax STRUCTURE/RECORD 声明用于不能被声明为记录的项目中。

此符号不能被声明具有“Vax 结构”类型。

消息标识：STRUCTURE_NOT_ALLOWED

## Error:不能在“VAX 结构/映射”定义内使用此声明。

在 STRUCTURE/MAP 定义范围内，唯一允许的声明是“结构/映射”组件的类型声明。

消息标识：NOT_IN_STRUCTURE

## Error:如果 UNIT= 说明符引用内部文件，则不能出现 POS= 说明符。

消息标识：ERR_POS_SPEC_ON_INTERNAL

## Error:如果出现 POS= 说明符， 将不会包含 REC= 说明符。

消息标识：ERR_POS_AND_REC_TOGETHER

## Error:如果出现 DECIMAL= 或 ROUND= 说明符， 或 也将出现。

消息标识：ERR_DECIMAL_OR_ROUND_NEED_FMT

## Error:在编译器库中没有执行某 I/O 说明符。

消息标识：ERR_SPECIFIER_NOT_IMPLEMENTED

## Error:在%s循环中 DO 控制变量不能是 SHARED。

DOALL 和 OpenMP 循环的 DO 变量不能用 SHARED 属性指定。

消息标识：ERR_SHARED_DO_VAR

## Error:STRUCTURE 语句在另一个结构中声明，但其后未跟记录名列表。

当在另一个结构内使用 STRUCTURE 语句时，语句后需跟记录名列表。

消息标识：NESTED_STRUCT_NEED_REC

## Error:因为指定了 -u、IMPLICIT NONE 命令行选项，必须为此对象指定一个显式类型。

-u 命令行选项要求在编译的每个过程中指定一个 IMPLICIT NONE。对于此编译该命令行已生效。列出的对象需要指定显式类型。

消息标识：ERR_TYPE_MUST_BE_EXPLICIT

## Error:数组%s的第 %d 维的下界溢出。

超出允许的数组边界。

消息标识：ERR_LOWER_BOUND_OUT_OF_RANGE

## Error:数组%s的第 %d 维的上界溢出。

超出允许的数组边界。

消息标识：ERR_UPPER_BOUND_OUT_OF_RANGE

## Error:Cray 指针“%s”（与 Cray 指针对象“%s”关联）位于平行区域中，如果没有指定自动范围，那么它必须在共享或专用列表中。

消息标识：WAR_DEFAULT_POINTEE

## Error:在第 199 行引用过程 FOO (foo.f90)。它必须具备指定的显式接口。

编译器已检测到某外部过程应有一个显式接口（F95标准的 12.3.1.1）。如果此过程的早期调用无显式接口，那么编译器就会显示这个错误。

消息标识：ERR_NEED_EXPL_INTRFC

## Error:数组%s不能是延迟形式或假定大小，如果用于指令%s的 REDUCTION 子句中。

消息标识：ERROR_WRONG_ARRAY_REDUCTION

## Error:假定大小数组 ARR 不能指定为 COPYPRIVATE。

不能在 OpenMP 指令的 COPYPRIVATE 子句中指定假定大小数组。

消息标识：ERR_WRONG_ARRAY_IN_COPYPRIVATE

## Error:变量 A 出现在封闭的 PARALLEL 区域的 REDUCTION 列表中。因而，它不能专用。

消息标识：ERR_REDUCTION_PRIVATIZATED

## 部分：199 (foo.f90)

此消息是其它消息的一部分。

消息标识：PART_LINE_AND_FILE

## Ansi：Fortran 标准要求“&”作为自由源格式中续行的第一个非空字符。

3.3.1.3.1 节“非字符上下文续行”包含以下断言：“如果词法表示在一行结尾处被分隔，则其后第一个非注释行中的第一个非空字符将是“&”，并且后面紧跟被分隔标记的连续字符。”

消息标识：ANSI_NOT_AMPERSAND

## 错误：同名的 CRITICAL 指令不允许相互嵌套。

消息标识：ERR_WRONG_NESTED_CRITICAL

## Error:DO、SECTIONS、SINGLE 和 WORKSHARE 指令不允许嵌套。

绑定到相同 PARALLEL 指令的 DO、SECTIONS、SINGLE 和 WORKSHARE 指令不允许互相嵌套。PARALLEL DO、PARALLEL WORKSHARE 和 PARALLEL SECTIONS 指令可看作后跟适当的工作共享指令的 PARALLEL 指令。因此，DO、SECTIONS、SINGLE 和 WORKSHARE 指令不能直接在 PARALLEL DO、PARALLEL WORKSHARE 或 PARALLEL SECTIONS 区域中嵌套。

消息标识：ERR_WRONG_NESTING

## Error:变量“A”在封闭的 PARALLEL 区域中共享。因而，它不能用在 COPYPRIVATE 子句中。

消息标识：ERR_SHARED_COPYPRIVATE

## Error:变量“A”出现在 REDUCTION 子句中。因而，在封闭的上下文中它应该是 SHARED。

消息标识：ERR_PRIVATE_REDUCTION

## BLOCK、CYCLIC 或 *

消息标识：ANNEX_DIST_FORMAT

## 警告：当下标三元组中的跨度为正时，第一个下标大于第二个下标。

跨度为正时，如果下标三元组中的第一个下标大于第二个下标，那么数组段大小为零。如果指定了“-C”并且下标是常数，编译器将在编译时检查到这种情况。

消息标识：WARNING_EMPTY_TRIPLET

## 警告：如果在下标三元组中的跨度为负，则第二个下标大于第一个下标。

跨度为负时，如果下标三元组中的第二个下标大于第一个下标，那么数组段大小为零。如果指定了“-C”并且下标是常数，编译器将在编译时检查到这种情况。

消息标识：WARNING_EMPTY_TRIPLET2

## Ansi：Fortran 标准要求“程序语句”中有“程序名”。

F95 规则：R1102 程序语句是 PROGRAM 程序名，但 f90 允许程序语句无程序名。

消息标识：ANSI_TERM_ABSENT

## 程序语句

Fortran 标准的术语。

消息标识：ANNEX_D_PROGRAM_STMT

## 警告：在第 2 (foo.f) 行引用有 2 个实际参数的过程“SUB”。此定义有 3 个指定的伪参数。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与一项对该过程的引用不符。 实际程序单元定义中的伪参数数量与此引用中指定的实际参数的数量不同。

消息标识：WARNING_REF_DEF_ARGS

## 警告：在第 2 (foo.f) 行引用有 2 个实际参数的过程“SUB”。此定义有 3 个指定的伪参数。

在此编译的全局语义分析过程中，编译器发现实际程序单元定义与其先前的定义不符。 实际程序单元定义中的伪参数数量与以前指定的伪参数的数量不同。

消息标识：WARNING_DEF_DEF_ARGS

## Error:不能在这个区域中指定此指令。

检测到编译器指令的不当使用。许多指令都存在不能在其中进行指定的代码区。例如，使用在由 C$PAR CRITICAL SECTION / C$PAR END CRITICAL SECTION 限制的临界断面内指定的 C$PAR PDO 指令。

消息标识：ERR_BAD_REGION_FOR_DIRECTIVE

## Error:必须在这个区域内指定此指令。

检测到编译器指令的不当使用。许多指令只能在某些代码区域中指定。例如，C$PAR PDO 指令只能在由 C$PAR PARALLEL / C$PAR END PARALLEL 限制的平行区域中指定。

消息标识：ERR_REGIONS_FOR_DIRECTIVE

## 部分：，或

此消息是其它消息的一部分。

消息标识：COMMA_OR

## Ansi：当在类型声明语句中初始化变量时，Fortran 标准只允许“=”。

第 5.1 节 关于“类型声明语句”

消息标识：ANSI_SLASH_INIT

## Ansi：没有输入/输出宽度字段的编辑描述符是 Fortran 标准的一个扩展。

Fortran 标准不允许没有输入/输出宽度字段的编辑描述符。

消息标识：EDIT_DESCRIPTOR_WITHOUT_W

## 在 MODDIR 环境变量中用于放置模块的目录名无效。

MODDIR 环境变量的设置值为无效目录名。结果，编译模块无法放入此位置。

消息标识：ERR_INVALID_MODDIR_ENV

## 在 -moddir 选项中用于放置模块的目录名无效。

-moddir 选项的语法为 -moddir=。指定选项时使用了错误的语法，或者目录名无效。结果，编译模块无法放入此位置。

消息标识：ERR_INVALID_MODDIR

## Ansi：Fortran 标准不允许在类型声明语句后跟 IMPLICIT 语句。

消息标识：ANSI_IMPLICIT

## Ansi：Fortran 标准不允许使用非整数作为数组下标。

消息标识：ANSI_F77_SUBSCRIPT

## Ansi：Fortran 标准不允许使用非整数作为数组维数。

消息标识：ANSI_F77_BOUND

## Ansi：Fortran 标准不允许在子串范围内使用非整数。

消息标识：ANSI_F77_SUBSTRING

## Error:检查有效的串行许可时出现致命错误。

此消息不再使用。

消息标识：LICENSE_ERROR

## Ansi：已声明类型 BYTE 不是 Fortran 标准的组成部分。

消息标识：ANSI_BYTE_TYPE

## 警告：EXTERNAL 属性将不用于此子程序。

如果函数包括在由 -xknown_lib 选项命名的库中，那么其语义已被那个标志严格定义，可能无法通过赋予 EXTERNAL 属性更改。特别地，此函数可能既无法由已知库之外的其它库执行，也无法由任何用户提供的代码执行。

消息标识：WARNING_IGNORING_EXTERNAL

## 警告：用户代码不会编译到结果中。

如果函数包括在由 -xknown_lib 选项命名的库中，那么其语义已被那个标志严格定义，此函数的任何用户代码都必定被忽略。

消息标识：WARNING_IGNORING_USER_CODE

## Ansi：以 D 或 d 开始的调试行是 Fortran 标准的一个扩展。

消息标识：ANSI_F77_D

## 因为不存在 -f77=输入/输出选项，ACCESS='APPEND' 将被忽略

消息标识：WARNING_ACCESS_APPEND

## Ansi：ACCESS='APPEND' 是 Fortran 标准的一个扩展。

消息标识：ANSI_ACCESS_APPEND

## Ansi：计算的 GOTO 表达式中的非整数是 Fortran 标准的一个扩展。

消息标识：ANSI_F77_GOTO

## 因为不存在 -f77=输入/输出选项，FILEOPT= 将被忽略

消息标识：WARNING_FILEOPT

## Ansi：FILEOPT= 是 Fortran 标准的一个扩展。

消息标识：ANSI_FILEOPT

## Error:在%s（属%s指令）中不允许有它。

Fortran 指针、可分配数组和 Cray 指针仅允许在 SHARED 和 PRIVATE 子句中使用。不允许在 REDUCTION 列表、FIRSTPRIVATE、LASTPRIVATE 和 COPYIN 子句中使用它们。

消息标识：DISALLOWED_IN_CLAUSE

## 警告：当检查有效的串行许可时出现非致命错误。

此消息不再使用。

消息标识：LICENSE_WARNING

## Error:当检查有效的序列号时出现致命错误。

此消息由序列号库产生。

消息标识：SERIAL_ERROR

## 警告：当检查有效的序列号时出现非致命错误。

此消息由序列号库产生。

消息标识：SERIAL_WARNING

## Error:已在局部范围中指定 IMPLICIT UNDEFINED，因此必须为此数据对象指定显式类型。

指定 IMPLICIT UNDEFINED 后，所有数据对象都必须具有显式类型。

消息标识：ERROR_IMPLICIT_UNDEFINED

## Error:已在主机范围中指定 IMPLICIT UNDEFINED，因此必须为此数据对象指定显式类型。

指定 IMPLICIT UNDEFINED 后，所有数据对象都必须具有显式类型。

消息标识：ERROR_IMPLICIT_HOST_UNDEFINED

## %s函数被当作 LOC

消息标识：WARNING_PERCENT_LOC

## 常量值超出范围。

消息标识：VALUE_OUT_OF_RANGE

## Ansi：直接存取到内部文件是 Fortran 95 标准的一个扩展。

消息标识：ANSI_DIRECT_INTERNAL

## 因为不存在 -f77=输入/输出选项，NAME= 将被忽略

消息标识：WARNING_OPEN_NAME

## Ansi：NAME= 是 Fortran 95 标准的一个扩展。

消息标识：ANSI_OPEN_NAME

## 因为不存在 -f77=输入/输出选项，FORM='PRINT' 将被忽略

消息标识：WARNING_FORM_PRINT

## Ansi：FORM='PRINT' 是 Fortran 标准的一个扩展。

消息标识：ANSI_FORM_PRINT

## 因为不存在 -f77=输入/输出选项，READONLY 将被忽略

消息标识：WARNING_OPEN_READONLY

## Ansi：READONLY 是 Fortran 标准的一个扩展。

消息标识：ANSI_OPEN_READONLY

## Log_Summary：f90comp:%d 个源代码行

此消息报告从输入文件读取的源代码行数，以及从在 INCLUDE 行中指定的所有 INCLUDE 文件读取的源代码行数。

消息标识：LOG_SUMMARY_1925

## Log_Summary：f90comp:%d 个错误、%d 个警告、%d 个其它消息、%d ANSI

此消息给出编译过程中发出的消息之汇总。

消息标识：LOG_SUMMARY_1926

## 警告：公共块“%s”被一 USE 语句存取，不能在 COPYIN 子句中引用。

OpenMP 标准不允许在 COPYIN 子句中使用以下公共块名：不是程序单元的局部名称。您应该使用变量名。

消息标识：WARN_THREADPRIVATE_HOST_ASSOC

## Error:COPYIN 指令的参数必须是 THREADPRIVATE。

C$COPYIN 指令中的每一项都必须是 threadprivate 数据项。

消息标识：ERROR_THREADPRIVATE_COPYIN

## 公共块“%s”的大小超出目标平台的支持范围

消息标识：SIZE_OF_COMMON

## Error:该可分配组件位于一个非零级部分引用的右面。

非零级的 part_ref 不允许右方存具有 ALLOCATABLE 属性的另一个 part_ref。

消息标识：ERR_ALLOC_ATTRIB

## Ansi：Fortran-77 标准要求这些格式字段之间加逗号。

消息标识：S_COMMA_F77_REQUIRED

## Error:应该有 -nP、-nX 或 +nP，但却找到其它东西。

消息标识：NEGATIVE_SPECIFIER

## Ansi：带非缺省种类参数的 INQUIRE 语句中的 IOLENGTH= 说明符是 Fortran 95 标准的一个扩展。

消息标识：ANSI_NODEFINT_IOLENGTH

## Error:nR 格式说明符的 n 值应该大于等于 2 且小于等于 36。

消息标识：E_INVALID_RADIX_CONTROL

## Error:\"%s\" 被用作公共块的名称，因此必须在 COMMON 语句中指定。

公共块必须先定义后使用。

消息标识：ERROR_NO_COMMON

## 警告：因为不存在 -f77=输入/输出选项，DISP= 将被忽略

消息标识：WARNING_CLOSE_DISP

## Ansi：DISP= 是 Fortran 95 标准的一个扩展，旨在兼容 Fortran 77。

消息标识：ANSI_CLOSE_DISP

## 警告：因为不存在 -f77=输入/输出选项，DISPOSE= 将被忽略

消息标识：WARNING_CLOSE_DISPOSE

## Ansi：DISPOSE= 是 Fortran 95 标准的一个扩展，旨在兼容 Fortran 77。

消息标识：ANSI_CLOSE_DISPOSE

## 分离指针

消息标识：ILLEGAL_NULL

## 警告：-xalias=overindex 标志在数组语法中无效。

消息标识：WARNING_OVERINDEX_ARRAY_SYNTAX

## Ansi：使用非缺省 INTEGER 种类类型参数调用 RANDOM_SEED，是 Fortran 95 标准的一个扩展。

消息标识：ANSI_RAN_SEED

## Error:RANDOM_SEED 的参数必须是 4 字节或 8 字节的整数。

消息标识：ERROR_RAN_SEED

## Ansi：使用 COMPLEX 变量作为 RANDOM_NUMBER 的参数，是 Fortran 95 标准的一个扩展。

消息标识：ANSI_RAN_HARVEST

## 警告：“%REF”函数的这个参数的类型是 CHARACTER

消息标识：WARNING_PERCENT_REF_CHARACTER

## Error:绑定实体列表中不允许两个或两个以上的元素带有 NAME= 说明符。

消息标识：ERROR_BIND_LIST

## Error:如果 ENUMERATOR 语句中出现 \"标量整型初始化表达式\"，则枚举器列表之前应该有 \"::\"。

Fortran 标准的术语。

消息标识：ERROR_ENUM_COLON

## 类型假名

Fortran 标准的术语。

消息标识：ANNEX_D_TYPE_ALIAS_NAME

## 声明类型说明

消息标识：ANNEX_D_TYPE_SPEC

## Error:“A”具有同“B”一样的关联名称

消息标识：ERROR_DOUBLE_BIND_NAME

## Error:具有 BIND 属性的派生类型不应该是 SEQUENCE 类型。

消息标识：ERROR_BIND_DERIVED_SEQUENCE

## Error:具有 BIND 属性的派生类型的每个组件应该是，具有能共同操作类型和类型参数的、非指针型不可分配的数据组件。

消息标识：ERROR_BIND_DERIVED_PARAMETERS

## Error:具有 BIND 属性的派生类型将不会有 EXTENSIBLE 或 EXTENDS 属性。

消息标识：ERROR_BIND_EXTENS

## Error:具有 BIND 属性的派生类型的每个组件应该是，具有能共同操作类型和类型参数的、非指针型不可分配的数据组件。

消息标识：ERROR_BIND_POINTER

## Error:此派生类型多次指定 BIND(C) 属性。

消息标识：ERROR_BIND_DOUBLE

## Error:类型假名不应该和任何内类型的名称相同。

消息标识：ERROR_TYPEALIAS_NAME

## Error:COPYIN 子句的参数必须是 THREADPRIVATE。

COPYIN 子句的每一项都必须是 threadprivate 数据项。

消息标识：ERROR_THREADPRIVATE_COPYIN_OMP

## Error:FILEOPT= 说明符中的缓冲区大小的值必须大于零。

消息标识：ERROR_FILEOPT_NONPOSIT_BUFFERN

## 警告：FILEOPT= 说明符中的缓冲区大小的值超出范围。

消息标识：WARNING_FILEOPT_OVERFL_BUFFERN

## Error:模块名的长度超过 %d 个字符的最大值限定。

编译器检测到长度超过 MAX_MODULE_NAME_LEN 字符的模块名。Fortran 标准限制模块名的长度为 MAX_MODULE_NAME_LEN 字符。

消息标识：ERROR_LENGTH_MODULE_NAME

## Error:此语句在 !$OMP ATOMIC 指令中无效。

跟随 !$OMP ATOMIC 指令的语句必须具有以下形式之一：

    	x = x operator expr
    	x = expr operator x
    	x = intrinsic(x, expr-list)
    	x = intrinsic(expr-list, x)

其中，x 是内类型的标量变量引用，expr 是不引用 x 的标量表达式，内在过程有 MIN、MAX、IAND、IOR 或 IEOR，运算符有 +、*、-、/、AND、OR、EQV 或 NEQV。

消息标识：ERROR_BAD_OMP_ATOMIC

## Error:标识符长度超过 MAX_ANSI_ID_LEN 字符的最大长度。

编译器检测到长度超过 MAX_ANSI_ID_LEN 字符的标识符。根据ANSI 标准，f90 的标识符长度不超过 31 个字符，f77 的标识符长度不超过 6 个字符。

消息标识：ANSI_LENGTH_ID_NAME

## Error:通用过程调用“%s”中的参数类型/属性不正确

实际参数与要求的伪参数类型/属性不匹配。要获得更详细的错误信息，如果可用，请用预定具体函数替换通用函数调用。

消息标识：ERROR_INCORRECT_ARG_TYPE

## Error:通用过程调用“%s”中的实际参数数量 %d 的类型/属性不正确

此实际参数与要求的伪参数类型/属性不匹配。

消息标识：ERROR_INCORRECT_ARGNUM_TYPE

## Error:通用过程调用“%s”中的参数类不正确

实际参数与要求的伪参数的类不匹配。例如，如果应该是伪过程，但提供的实际参数是数据对象，那么就会给出此消息。要获得更详细的错误信息，如果可用，请用预定具体函数替换通用函数调用。

消息标识：ERROR_INCORRECT_ARG_CLASS

## Error:通用过程调用“%s”中的实际参数数量 %d 的类不正确。

此实际参数与要求的伪参数的类不匹配。

消息标识：ERROR_INCORRECT_ARGNUM_CLASS

## Error:通用过程调用“%s”中的参数等级不正确。

实际参数与要求的伪参数等级不匹配。要获得更详细的错误信息，如果可用，请用预定具体函数替换通用函数调用。

消息标识：ERROR_INCORRECT_ARG_RANK

## Error:通用过程调用“%s”中实际参数数量 %d 的等级不正确。

此实际参数与要求的伪参数等级不匹配。

消息标识：ERROR_INCORRECT_ARGNUM_RANK

## Error:在通用调用过程“%s”中，实际参数比非可选伪参数少。

实际参数比非选择的伪参数少

消息标识：ERROR_TOO_FEW_ACTUALS

## Error:在通用调用过程“%s”中，实际参数比非可选伪参数多。

通用函数调用中的实际参数比具体函数中的伪参数多。

消息标识：ERROR_TOO_MANY_ACTUALS

## Error:在通用过程调用“%s”中使用了无效关键字。

在此通用函数调用中，至少有一个关键字无效。

消息标识：ERROR_INCORRECT_KEYWORD

## 警告：“A”上的绑定标签“a$4”不能与任何 C 名称共同使用。

消息标识：WARN_BIND_NAME

## Error:意外语法：绑定标签“a b”错误。

消息标识：ERR_BIND_NAME

## 警告：用 BIND 属性复制名称规范。

消息标识：DUPL_BIND_NAME

## 实体名或/公共块名/

Fortran 标准的术语。

消息标识：ANNEX_D_BIND_ENTITY

## Ansi：UNSIGNED 类型是 Fortran 标准的一个扩展。

已声明非标准类型不是 Fortran 标准的组成部分。

消息标识：ANSI_NONSTANDARD_TYPE

## Error:此上下文中不允许 UNSIGNED 类型。

在任何对象类型（例如：UNSIGNED 类型）不应出现的位置发现该类型。

消息标识：ERR_THIS_TYPE_NOT_EXPECTED

## Error:C_LOC 函数参数必须是能共同操作的过程，是具有 TARGET 属性并能共同操作的变量，或者是具有目标属性、并具有可共同操作类型和类型参数的、已分配的可分配变量。

消息标识：ERR_C_LOC

## Error:具有 BIND 属性和 LOGICAL*2 类型的“A”不能与任何 C 实体共同操作。

消息标识：ERR_BIND_TYPE

## Error:“SHAPE”的大小应等于“FPTR”的等级。

C_F_POINTER 子例程的规范。

消息标识：ERR_C_F_POINTER_SIZE

## Error:此上下文中不允许类型假名“EN1”。

消息标识：ERROR_TYPEALIAS_EXPR

## Error:只有外部文件允许异步输入/输出。

消息标识：ERROR_AIO_TO_INTERNAL

## Error:STDIO 不允许异步输入/输出。

消息标识：ERROR_AIO_TO_STDIO

## Error:此 ID= 说明符还要求 ASYNCHRONOUS='YES' 说明符。

消息标识：ERROR_ID_WTOUT_ASYNC

## 警告：此 ASYNCHONOUS= 说明符被忽略。它的初始化表达式有非常量值，因而将同步执行%s。

消息标识：WARN_ASYNC_INIT_VAL

## Error:此 ID= 说明符还要求 PENDING= 说明符。

消息标识：ERROR_ID_WTOUT_PEND

## Error:具有 PROTECTED 属性的变量将不会出现在变量定义上下文中。

不能定义具有 PROTECTED 属性的变量，除非其所在模块含被赋予 PROTECTED 属性的实体。

消息标识：NO_DEF_PROTECTED

## Error:具有 PROTECTED 属性的变量不应在指针赋值语句或无效语句中作为指针对象出现。

消息标识：ASG_PTR_PROTECTED

## Error:具有 PROTECTED 属性的变量不应在指针赋值语句中作为数据目标或处理目标出现。

消息标识：TRG_PTR_PROTECTED

## Error:具有 PROTECTED 属性的变量不应在分配或解除分配语句中作为分配对象出现。

消息标识：ALLOC_PTR_PROTECTED

## Error:具有 PROTECTED 属性的变量将不会出现在变量定义上下文中。

消息标识：NML_READ_PROTECTED

## 警告：此 INTEGER (kind=4) 表达式的求值产生了一个超出 UNSIGNED (kind=4) 范围的值。

消息标识：WARN_EXPR_OUT_OF_RANGE

## Error:公共块是在 BIND(C) 语句中指定的，但未在 COMMON 语句中指定。

消息标识：ERR_BIND_WITH_COMMON

## 错误：变量“A”具有 BIND(C) 属性，不能出现在公共块中。

消息标识：ERR_BIND_IN_COMMON

## Error:VFE 不允许非标量值。

消息标识：VFE_ARRAY

## Ansi：VFE 的使用是 Fortran 95 标准的一个扩展。

消息标识：VFE_ANSI

## Error:不能给 VFE 格式变量的标签赋值。

消息标识：VFE_ASSIGN

## 注释：为改进 I/O 性能，带接续元素的隐含 do 循环被当作数组段。

为改进 I/O 性能，带接续元素的隐含 do 循环被当作数组段。如果在隐含 do 循环中有 I/O 错误，它就会导致隐含 do 变量的值产生差异。根据 Fortran 标准，在这种情况下不定义隐含 do 变量的值。

消息标识：IMPLIED_DO_CONVERTED

## 警告：此指令总是成对出现，但是编译器未能发现它的匹配指令。

例如，C$PRAGMA END ASSUME 指令一定在匹配的 C$PRAGMA BEGIN ASSUME 指令后出现。在这种情况下，该指令将完全被忽略。

消息标识：WARNING_NO_MATCHING_DIRECTIVE

## 警告：此模块被编译用于另一个体系结构（异于为当前编译所指定者）。除非此模块使用或声明了显式指针，否则这个差异一般无害。

消息标识：WARNING_ARCH

## 警告：用来编译此模块的缺省整数大小与为当前编译所指定者不同。这个差异一般无害。

消息标识：WARNING_INTEGER_SIZE

## 警告：用来编译此模块的缺省实数大小与为当前编译所指定者不同。这个差异一般无害。

消息标识：WARNING_REAL_SIZE

## 警告：用来编译此模块的双精度大小与为当前编译所指定者不同。这个差异一般无害。

消息标识：WARNING_DOUBLE_SIZE

## 警告：用来编译此模块的缺省间隔大小与为当前编译所指定者不同。这个差异一般无害。

消息标识：WARNING_INTERVAL_SIZE

## 警告：用来编译此模块的最大对齐与为当前编译所指定者不同。这个差异可能无害。

消息标识：WARNING_ALIGNMENT

## Log_Error：此模块文件在写入后已被错误更改。

消息标识：LOG_ERROR_CORRUPT_MOD_FILE

## Error:此说明符也要求 ADVANCE='NO' 说明符。

消息标识：WTOUT_ADVANCE_NO

## Error:它被指定为 USE 语句中的内在模块名，但是它不是内在模块。

编译器无法定位在 USE 语句中指定的内在模块名。

消息标识：NO_INTRINSIC_MODULE

## Error:在变量格式表达式中不允许类型字符的值。

消息标识：VFE_TYPE

## 警告：此文件中的数组、结构和公共块使用的内存总量超出 32 位系统的可用内存。要使用此程序，就必须将它编译为 64 位寻址，并在具有足够内存和交换空间的系统中运行。

消息标识：MEMORY_LIMIT

## 数组“%s”的大小超出目标平台的支持范围

消息标识：SIZE_OF_ARRAY

## Error:“H”编辑描述符不允许变量格式表达式。

消息标识：VFE_HOLLER

## Log_Error：在 -xpad=common[:n] 命令行选项中指定的可选填充量必须在 0 和 4096 之间。

可在 -xpad=common[:n] 命令行选项中指定可选填充量。此数必须是大于零小于 4096 的整型文字常量。指定的数字不在此范围内。

消息标识：LOG_ERROR_PAD

## Ansi：使用不带小数部分宽度的实数编辑描述符是 Fortran 标准的一个扩展。

消息标识：EDIT_DESCRIPTOR_WITHOUT_D

## Error:nP 或 nX 编辑描述符应该是“P”或“X”符号，但是找到了其它符号。

消息标识：NEGATIVE_FMT_SPECIFIER

## Ansi：此编辑描述符的使用是对 Fortran 标准的一个扩展。

消息标识：NON_STD_FMT_SPECIFIER

## 警告：-xalias=overindex 标志对专用变量无影响。

消息标识：WARNING_OVERINDEX_PRIVATE

## Error:不能写入到“编译器信息文件”。

编译器无法将记录写入到“编译器信息文件”(CIF)。最可能的原因是文件系统用完了磁盘空间。

消息标识：WRITE_CIF_FILE

## Ansi：“IOMSG=”说明符是 Fortran 标准的一个扩展。

消息标识：NON_STD_SPECIFIER

## Ansi：ACCESS='STREAM' 是 Fortran 标准的一个扩展。

消息标识：NON_STD_SPECIFIERS_VALUE

## Error:如果一个等价对象具有 PROTECTED 属性，那么在 EQUIVALENCE 集中的所有对象都将具有 PROTECTED 属性。

消息标识：EQUIV_PROTECTED

## Error:如果存在 PRAGMA ASSUME 的第二个参数，则必须是介于 0 到 1 之间的常数值。

消息标识：BAD_PROBABILITY

## Error:除了在规范中指定的那些，PRAGMA ASSUME 的第一个参数可能不包含函数或内在调用：__branchexp、__invariant、__ispowerof、max、min、__no_overlap、__tripcount 和 __unique。

消息标识：CALL_IN_ASSERT_EXPR

## Error:PRAGMA ASSUME 内在过程%s的这个参数必须是一个变量引用。

消息标识：ASSERT_NOT_LVALUE

## Error:PRAGMA ASSUME 的第一个参数必须是一个标量逻辑表达式。

消息标识：ASSERT_NOT_LOGICAL

## Error:__unique 的参数必须是对同一数组的引用，该数组只在一维方向上有正偏差。

消息标识：UNIQUE_BAD_ARRAY

## Error:包含 __tripcount 的点 ASSUME 必须在后面紧跟一个 DO LOOP。

消息标识：BAD_TRIPCOUNT

## Error:包含 __branchexp 的 ASSUME 必须在后面紧跟一个转移语句。

消息标识：BAD_BRANCHEXP

## 警告：此 BOZ 常量将被转换成 INTEGER*4 常量。

消息标识：BOZ_CNST_DFLT_INT_CNVRT

## Error:MVBITS 内在过程的 TO 参数必须与 FROM 具有相同的类型和参数类型。

PP MVBITS 内在过程的 TO 参数必须与 FROM 具有相同的类型和类型参数。

消息标识：MVBITS_FROM_TO

## 警告：该指令被忽略。只执行 DOALL/DOSERIAL 指令序列中的第一个指令。

消息标识：DO_DIR_ACTIVE

## 警告：忽略未执行的功能：%DESCR() 函数。

消息标识：WARNING_PERCENT_FEATURE

## 此内在过程已在范围 ASSUME pragma 命令中指定，但仅允许在点 ASSUME pragma 命令中使用它。

消息标识：NOT_IN_POINT_ASSUME

## Error:为大数组或公共块非零初始化。

PP

消息标识：F77_BIG_ARR

## 警告：其上下文中不允许此指令。

消息标识：WARNING_DIRECTIVE

## Error:如果出现 ADVANCE= 说明符，则 FMT= 说明符一定不能指定列表控制格式。

消息标识：ADVANCE_LIST_DIRECT

## 警告：OpenMP、Sun 和 Cray Parallelization 指令不允许在 PURE 或 ELEMENTAL 子程序中使用。

消息标识：PURE_DIRECTIVE

## 警告：READ/WRITE 语句中 io-control-spec-list 后面的额外冒号是不标准的语法。

消息标识：EXTRA_COMMA

## Error:STOP 或 PAUSE 语句中指定的十进制数字不能超过 5 个。

消息标识：STOP_OVER

## Error:该参数是数组，因此将会存在第三个参数。

消息标识：ERR_C_F_POINTER_SHAPE

## Error:该参数的大小将等于第二个参数的等级。

消息标识：ERR_C_F_POINTER_SHAPE_SIZE

## 警告：该参数被忽略，因为第二个参数是标量。

消息标识：WAR_C_F_POINTER_SCALAR

## Error:将不会指定内部过程的 BIND 属性。

消息标识：ERR_C_INTERNAL_PROC

## Error:“A”定义 INTEGER*8 类型，因为它不应该为 INTEGER*4 类型。

消息标识：ERR_TYPED_TWICE

## Error:在此指令的 REDUCTION 子句中不能声明此变量。

消息标识：ERR_REDUCTION

## Error:只有在模块的作用域内声明的公共块和变量才能与 C 互操作。

消息标识：ERR_LOCAL_C_BIND

## Ansi：具有 TYPELESS 类型的参数是非标准的。

消息标识：ANSI_NON_STANDARD_ARG

## Error:初始化变量的长度不能超过 2**31 -1 个字节。

消息标识：LIMIT_INIT

## Error:前面指令之后的语句必须是 DO 语句。

前面指令之后的语句必须是 DO 语句。该指令可应用于 DO 循环。

消息标识：STMT_MUST_BE_DO

## 注意：过程具有 RECURSIVE 属性，所以该过程中的局部变量将位于栈中，且被取消定义。

消息标识：CAUTION_1103_SUN

## Error:REAL 不允许有该类型说明或长度说明。

消息标识：ERROR_0125_SUN

## Error:此类型参数对类型 REAL 无效。

消息标识：ERROR_0130_SUN

## Error:CHARACTER 不允许有此长度说明。

消息标识：ERROR_0125_CH_LEN_SUN

## 警告：处于编译状态的函数不能与 USE 关联。如果将当前过程的外部过程接口从模块文件中导入，将会忽略该过程接口。

消息标识：ANSI_EXT_PROC

## 部分：PRIVATE、SHARED、__AUTO 或 NONE

此消息是其它消息的一部分。

消息标识：PRIV_SHAR_AUTO_NONE

## 部分：into

此消息是其它消息的一部分。

消息标识：INTO

## 部分：out of

此消息是其它消息的一部分。

消息标识：OUT_OF

## Error:ONTO 值太少。

DISTRIBUTE、DISTRIBUTE_RESHAPE 和 REDISTRIBUTE 指令的 ONTO 子句（如果指定）必须具有与 BLOCK 或 CYCLIC 分配规范完全相同的值数量。不要为“*”分配规范指定 ONTO 值。

消息标识：ERROR_FEW_ONTO

## Error:ONTO 值太多。

DISTRIBUTE、DISTRIBUTE_RESHAPE 和 REDISTRIBUTE 指令的 ONTO 子句（如果指定）必须具有与 BLOCK 或 CYCLIC 分配规范完全相同的值数量。不要为“*”分配规范指定 ONTO 值。

消息标识：ERROR_MANY_ONTO

## Error:REPEAT 内在函数的结果长度超过了目标平台支持的最大长度。

已超出最大字符长度。

消息标识：REPEAT_LENGTH

## Error:它包含错误的属性。因为它不是常量，所以不能在此说明表达式中使用。

消息标识：ERROR_0210_SUN

## Error:要在此说明表达式中使用，它必须是常量。

消息标识：ERROR_0276_SUN

## 警告：不支持的编译器指令。

编译器遇到了一个可识别但却不支持的编译器指令。之所以会这样，原因在于编译器指令与支持的硬件无关。

消息标识：UCD

## WARNING_SUBSTR_RANGE 子字符串超出范围。对于 'S' 子字符串，起始点的值是 -10

此消息是其它消息的一部分。

消息标识：STARTING

## WARNING_SUBSTR_RANGE 子字符串超出范围。对于 "S" 子字符串，结束点的值是 -10

此消息是其它消息的一部分。

消息标识：ENDING

## 意外语法：应该是“操作数”或“:”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_D_OPERAND_OR_COLON

## 意外语法：应该是“操作数”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_D_OPERAND

## 意外语法：应该是“操作数”、“,”或“)”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_D_OPERAND_COMMA_OR_P

## 意外语法：应该是“operand”或“:”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_EOS

## 意外语法：应该是“(”或“EOS”，但找到的是“S”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_L_PAR_OR_EOS

## 意外语法：应该是“SUBROUTINE NAME”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_SUBROUTINE_NAME

## 意外语法：应该是“,”或“)”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COMMA_OR_R_PAR

## 意外语法：应该是“(”或“DEFAULT”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_L_PAR_OR_DEFAULT

## 意外语法：应该是“标量整型 STAT 变量”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_SCALAR_INT_STAT_VARIABLE

## 意外语法：应该是“分配对象”或“STAT =”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_ALLOC_OBJ_OR_STAT

## 意外语法：应该是“(”或“=”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_L_PAR_OR_EQUALS

## 意外语法：应该是“,”或“EOS”，但找到的是“S”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COMMA_OR_EOS

## 意外语法：应该是“分号”、“逗号”或“右括号”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COLON_COMMA_OR_R_PAR

## 意外语法：应该是“=”或“)”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_EQUALS_R_PAR

## 意外语法：应该是“标识符”或“EOS”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_IDENTIFIER_OR_EOS

## 意外语法：应该是“,”或“(”，但找到的是“S”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COMMA_OR_L_PAR_OR_EOS

## 意外语法：应该是“LABEL”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_LABEL

## 意外语法：应该是“IDENTIFIER”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_IDENTIFIER

## 意外语法：应该是“语句标签”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_STATEMENT_LABEL

## 意外语法：应该是“运算符”或“EOS”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_OPERATOR_OR_EOS

## 意外语法：应该是“CONSTANT”，但找到的是“]”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_CONSTANT

## 意外语法：应该是“/”、“,”或“EOS”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_SLASH_OR_COMMA_OR_EOS

## 意外语法：应该是“POINTER”或“DIMENSION”，但找到的是“X”。

该派生类型说明语句的语法是类型错误的 S REAL X 结束类型。此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_POINTER_OR_DIMENSION

## 意外语法：应该是“,”或“/”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COMMA_OR_SLASH

## 意外语法：应该是“,”、“*”或“/”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COMMA_OR_ASTER_OR_SLASH

## 意外语法：应该是“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“G”、“K”、“L”、“M”、“N”、“O”、“P”、“Q”、“R”、“S”、“T”、“U”、“V”、“W”、“X”、“Y”或“Z”，但找到的是“5”。

该语句的语法是错误的 IMPLICIT real (5) 此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_ALPHABET

## 意外语法：应该是“INTEGER”、“REAL”、“DOUBLE”、“COMPLEX”、“LOGICAL”、“CHARACTER”或“TYPE”，但找到的是“EOS”。

该语句的语法是错误的 IMPLICIT 此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_TYPE_DECL

## 意外语法：应该是“PUBLIC”、“PRIVATE”、“EXTENSIBLE”、“EXTENDS”或“BIND(C)”，但找到的是“:”。

该派生类型声明语句的语法是错误的类型，即 ::S REAL X 结束类型 此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_ACCESS_ATTRIBUTE

## 意外语法：应该是“INTRINSIC”或“NON_INTRINSIC”，但找到的是“EOS”。

该 USE 语句的语法是错误的 USE IEEE_ARITHMETIC 该消息属于其它消息，如 #197 ERROR_0197。

消息标识：ANNEX_INTRINSIC_OR_NON_INTRIN

## 意外语法：应该是“,”或“::”，但找到的是“Y”。

该类型声明语句的语法是错误的实数参数 Y 此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COMMA_OR_COLON_SEPARATOR

## 意外语法：应该是“ALLOCATABLE”、“BIND”、“DIMENSION”、“EXTERNAL”、“INTENT”、“INTRINSIC”、“OPTIONAL”、“PARAMETER”、“POINTER”、“PRIVATE”、“PUBLIC”、“PROTECTED”、“SAVE”或“TARGET”，但找到的是“:”。

该类型声明语句的语法是错误的实数 ::Y 此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_ATTRIBUTE

## 128 或 EOS

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_128_OR_EOS

## 意外语法：应该是“FUNCTION”、“SUBROUTINE”、“INTEGER”、“LOGICAL”、“DOUBLE PRECISION”、“REAL”、“COMPLEX”、“CHARACTER”或“TYPE”，但找到的是“A”。

该过程定义的语法是错误的纯函数 a() 此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_PROG_OR_TYPE_DECL

## 意外语法：应该是“RESULT”或“EOS”，但找到的是“R”。

该过程定义的语法是错误的实数函数 a(b) resul(bb)，此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_RESULT_OR_EOS

## 意外语法：应该是“指针对象名称”，但找到的是“)”。

该语句的语法是错误的 pointer( rr,) 此消息是其它消息的一部分，如 #197 ERROR_0197.

消息标识：ANNEX_POINTEE_NAME

## 意外语法：应该是“Cray 指针对象名称”，但找到的是“)”。

该语句的语法是错误的 pointer( ) 此消息是其它消息的一部分，如 #197 ERROR_0197.

消息标识：ANNEX_CRAY_POINTER_NAME

## 意外语法：应该是“Cray 指针对象”，但找到的是“,”。

该语句的语法是错误的 pointer( ,cc) 此消息是其它消息的一部分，如 #197 ERROR_0197.

消息标识：ANNEX_CRAY_POINTEE

## 具有 BIND 属性的派生类型将不会有“EXTENSIBLE”或“EXTENDS”属性。

此消息是其它消息的一部分，如 #1958 ERROR_BIND_EXTENS。

消息标识：ANNEX_EXTENSIBLE_OR_EXTENDS

## “ARR”具有初始化属性，因而不能声明为带有非恒定边界的显形数组。

此消息是其它消息的一部分，如 #582 ERROR_0582。

消息标识：ANNEX_INITIALIZED

## 意外语法：应该是“END ENUM”或“ENUMERATOR”，但找到的是“REAL”。

该语句的语法是不正确的枚举 ::数字实数 t 此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_ENDENUM_OR_ENUMERATOR

## “SS”具有 CHARACTER 属性，因此它不能声明为 Cray 指针。

字符 ss pointer(ss,i ) 此消息是其它消息的一部分，如 #552 ERROR_0552。

消息标识：ANNEX_CRAY_POINTER

## “I”具有 INTEGER 属性，因此它不能声明为 Cray 字符指针。

字符 ss pointer(i,ss ) 此消息是其它消息的一部分，如 #552 ERROR_0552。

消息标识：ANNEX_CRAY_CHARACTER_POINTER

## “B”是伪参数，因为它不能声明为 Cray 指针对象。

此消息是其它消息的一部分，如 #553 ERROR_0553。

消息标识：ANNEX_DUMMY_ARGUMENT

## “B”是伪参数，因为它不能声明为指针对象。

此消息是其它消息的一部分，如 #553 ERROR_0553。

消息标识：ANNEX_POINTEE

## 意外语法：应该是“运算符”，但找到的是“逻辑文字常量”。

该语句的语法是错误的 bb = i.TRUE。此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_OPERATOR

## 意外语法：应该是“运算符”，但找到的是“逻辑文字常量”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_LOGICAL_LITERAL_CONSTANT

## 意外语法：应该是“一个数字”，但找到的是“]”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_A_NUMBER

## 意外语法：应该是“,”或“]”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COMMA_OR_R_SQUARE_BRACKET

## 此 ALLOCATE 形式说明符缺少下界。

此消息是其它消息的一部分，如 #1604 ERROR_1558。

消息标识：ANNEX_LOWER_BOUND

## 此 ALLOCATE 形式说明符缺少上界。

该消息属于其它消息，如 #1604 ERROR_0553。

消息标识：ANNEX_UPPER_BOUND

## 意外语法：应该是“IN”、“OUT”或“INOUT”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_IN_OR_OUT_OR_INOUT

## 意外语法：应该是“IN”或“OUT”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_IN_OR_OUT

## 意外语法：应该是“COMPLEX”或“PRECISION”，但找到的是“S”。

该类型声明语句的语法是错误的 DOUBLE ss 此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COMPLEX_OR_PRECISION

## DECODE 的源无效。它必须是变量、数组元素或者整个数组的引用。

此消息是其它消息的一部分，如 #1112 ERROR_1112。

消息标识：ANNEX_SOURSE

## ENCODE 的目标无效。它必须是变量、数组元素或者整个数组的引用。

此消息是其它消息的一部分，如 #1112 ERROR_1112。

消息标识：ANNEX_DESTINATION

## “ARR”具有假定大小的 DIMENSION 属性，因此它不能使用显形 DIMENSION 属性声明。

此消息是其它消息的一部分，如 #550 ERROR_0550。

消息标识：ANNEX_EXPLISIT_SHP_ARR

## “ARR”具有显形 DIMENSION 属性，因为它不能使用假定大小的 DIMENSION 属性声明。

此消息是其它消息的一部分，如 #550 ERROR_0550。

消息标识：ANNEX_ASUMED_SIZE_ARR

## “ARR”具有显形 DIMENSION 属性，因为它不能使用延迟形的 DIMENSION 属性声明。

此消息是其它消息的一部分，如 #550 ERROR_0550。

消息标识：ANNEX_DEFERRED_SHP_ARR

## “ARR”具有显形 DIMENSION 属性，因为它不能使用假定形的 DIMENSION 属性声明。

此消息是其它消息的一部分，如 #550 ERROR_0550。

消息标识：ANNEX_ASUMED_SHP_ARR

## “ARR”具有 DATA 初始化属性，因此它必须使用 ALLOCATABLE 属性声明。

此消息是其它消息的一部分，如 #550 ERROR_0550。

消息标识：ANNEX_DATA_INITIALIZED

## “ARR”具有联合数组 DIMENSION 属性，因此它不能声明为 Cray 指针。

此消息是其它消息的一部分，如 #552 ERROR_0552。

消息标识：ANNEX_CO_ARRAY_DIMENSION

## “S”是变量，因此它不能使用 PARAMETER 属性声明。

此消息是其它消息的一部分，如 #551 ERROR_0551。

消息标识：ANNEX_VARIABLE

## “S”是 Cray 字符指针对象，因此不能使用 SAVE 属性声明。

此消息是其它消息的一部分，如 #551 ERROR_0551。

消息标识：ANNEX_CRAY_CHARACTER_POINTEE

## “P”是模块子例程，因此它不能使用 SAVE 属性声明。

此消息是其它消息的一部分，如 #551 ERROR_0551。

消息标识：ANNEX_MODULE_SUBPROGRAM

## “F”是语句函数，因此它不能使用 SAVE 属性声明。

此消息是其它消息的一部分，如 #551 ERROR_0551。

消息标识：ANNEX_STATEMENT_FUNCTION

## “F”是内在函数，因此它不能使用 SAVE 属性声明。

此消息是其它消息的一部分，如 #551 ERROR_0551。

消息标识：ANNEX_INTRINSIC_FUNCTION

## “F”是内在子例程，因此它能用 SAVE 属性声明。

此消息是其它消息的一部分，如 #551 ERROR_0551。

消息标识：ANNEX_INTRINSIC_SUBROUTINE

## “F”是块数据，因此它不能使用 SAVE 属性声明。

此消息是其它消息的一部分，如 #551 ERROR_0551。

消息标识：ANNEX_BLOCK_DATA

## “F”是内在函数，因此它不能使用 SAVE 属性声明。

此消息是其它消息的一部分，如 #551 ERROR_0551。

消息标识：ANNEX_INTERNAL_FUNCTION

## “F”是内在子例程，因此它不能使用 SAVE 属性声明。

此消息是其它消息的一部分，如 #551 ERROR_0551。

消息标识：ANNEX_INTERNAL_SUBROUTINE

## “B”是函数入口，因此它不能声明为指针对象。

此消息是其它消息的一部分，如 #553 ERROR_0553。

消息标识：ANNEX_FUNCTION_ENTRY

## “B”是子例程入口，因此它不能声明为指针对象。

此消息是其它消息的一部分，如 #553 ERROR_0553。

消息标识：ANNEX_SUBROUTINE_ENTRY

## “B”是模块过程函数，所以它不能声明为指针对象。

此消息是其它消息的一部分，如 #553 ERROR_0553。

消息标识：ANNEX_PROCEDURE_FUNCTION

## “B”是模块过程子例程，所以它不能声明为指针对象。

此消息是其它消息的一部分，如 #553 ERROR_0553。

消息标识：ANNEX_PROCEDURE_SUBROUTINE

## “B”是语句函数伪参数，所以它不能声明为指针对象。

此消息是其它消息的一部分，如 #553 ERROR_0553。

消息标识：ANNEX_SF_DARG

## 意外语法：应该是“OpenMP 指令关键字”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_OPENMP_DIRECTIVE_KEYWORD

## 意外语法：应该是“数组名称”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_ARRAY_NAME

## 意外语法：应该是“SPAN”或“EOS”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_SPAN_OR_EOS

## 意外语法：应该是“POINT”、“SPAN”或“EOS”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_POINT_SPAN_OR_EOS

## 意外语法：应该是“IF”或“EOS”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_IF_OR_EOS

## 意外语法：应该是“MP_SCHEDTYPE 模式”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_MP_SCHEDTYPE_MODE

## 意外语法：应该是“RD”或“WR”，，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_RD_OR_WR

## 意外语法：应该是“PREFETCH_REF 子句”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_PREFETCH_REF_CLAUSE

## 意外语法：应该是“ORDERED 子句”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_ORDERED_CLAUSE

## 意外语法：应该是“mp 子句”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_MP_CLAUSE

## 为此 PARALLEL 指令指定了多个 CHUNK 或 BLOCKED 子句。

此消息是其它消息的一部分，如 #1360 ERROR_1360。

消息标识：ANNEX_CHUNK_OR_BLOCKED

## AFFINITY 子句是 OpenMP 标准的一个扩展。应该具有 !$SGI 标记。

此消息是其它消息的一部分，如 #1564 WARNING_1518。

消息标识：ANNEX_AFFINITY_CLAUSE

## 意外语法：应该是“DATA”或“THREAD”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_DATA_OR_THREAD

## mp 指令不允许使用 LOCAL 或 PRIVATE 子句。

此消息是其它消息的一部分，如 #1370 ERROR_1370。

消息标识：ANNEX_LOCAL_OR_PRIVATE

## 意外语法：应该是“ONTO”或“EOS”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_ONTO_OR_EOS

## 意外语法：应该是“逗号”、“数据 stmt 对象”或“EOS”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_COMMA_DSTMT_OBJECT_EOS

## 意外语法：应该是“公共块名称”或“/”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_CBLOCK_NAME_OR_SLASH

## 意外语法：应该是“公共块对象”或“/”，，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_CBLOCK_OBJECT_OR_SLASH

## 意外语法：应该是“data-i-do-object”或“data-i-do-variable”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_DATA_I_DO_OBJ_OR_VAR

## 意外语法：应该是“data-stmt-repeat”或“data-stmt-constant”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_DATA_STMT_REPT_OR_CONS

## 意外语法：应该是“=”、“,”或“(subscript-list)”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_EQ_COMMA_SUBLIST_W_PARS

## 意外语法：应该是“(”、“,”、“::”或“类型名称”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_LP_COMMA_DOTS_TYPE_NAME

## 意外语法：应该是“ONLY”或“使用名称”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_ONLY_OR_USE_NAME

## 意外语法：应该是“实体名称”或“/公共块名称/”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_BIND_ENTITY

## 意外语法：应该是“隐含 do 对象”或“do 变量”，但找到的是“EOS”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_IMPLIED_DO_OBJ_OR_VAR

## 意外语法：应该是“构造名称”或“EOS”，但找到的是“)”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_CONSTRUCT_NAME_OR_EOS

## 意外语法：应该是“do 变量”或“WHILE”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_DO_VARIABLE_OR_WHILE

## 意外语法：应该是“对象名称”或“/”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_OBJECT_NAME_OR_SLASH

## 意外语法：应该是“OPERATOR”、“ASSIGNMENT”或“一般名称”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_OP_ASG_GENERIC_NAME

## 意外语法：应该是“标量整型文字常量”或“(”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_SCALAR_INT_LIT_CONS_LP

## 意外语法：应该是“BLOCK”、“CYCLIC”或“*”，但找到的是“,”。

此消息是其它消息的一部分，如 #197 ERROR_0197。

消息标识：ANNEX_D_DIST_FORMAT

## Ansi：将 TYPE 语句用作输出语句是 Fortran 标准的一个扩展。

消息标识：ANSI_TYPE_AS_PRINT

## 警告：非内在模块的此名称可能会模仿内在模块 ISO_C_BINDING 的名称。

消息标识：NON_INTRINSIC_MODULE

## Error:如果 io-unit 是外部文件单元或“*”，则不允许在纯子程序“FUNC”中使用 READ 语句。

消息标识：READ_WRITE_EXT_UNIT_IN_PURE

## 警告：派生类型的“CMPN_NAME”组件对齐错误 “DER_TYPE_NAME”可能会导致结果错误。

消息标识：BAD_DER_TYPE_ALIGN_WARN

## 注意：对齐派生类型的“CMPN_NAME”组件 “DER_TYPE_NAME”可能会导致性能下降。

消息标识：BAD_DER_TYPE_ALIGN_CAUT

## 警告：空的嵌套结构声明将被忽略。

消息标识：EMPTY_SUBSTRUCT_DECLARE

## Ansi：在绑定说明表达式中使用非纯外部函数“NONPURE_EXT_FUNC”是 Fortran 标准的一个扩展。

消息标识：NONPURE_FUNC_SPEC_EXPR

## Ansi：在绑定说明表达式中使用递归外部函数“RECURSIVE_EXT_FUNC”是 Fortran 标准的一个扩展。

消息标识：RECURSIVE_FUNC_SPEC_EXPR

## Ansi：包含嵌套括号的隐含 DO 对象使用表达式或隐含 DO 循环列表是 Fortran 标准的一个扩展。

消息标识：IMPLIED_DO_NESTED_PARENT

## Error:入口点都必须具有 ALLOCATABLE 属性。

PP 如果带有一个或更多 ENTRY 语句的函数的某入口点的结果具有 ALLOCATABLE 属性，那么该函数的所有入口点都必须返回具有 ALLOCATABLE 属性的结果。

消息标识：ERROR_ENTRY_ALLOC

## Error:入口点都必须具有 ALLOCATABLE 属性。

消息标识：ERROR_ENTRY_ALLOC