错误文件 *.fln %s

访问文件时出错。通常其原因是文件
权限或因为文件不存在。

消息标识：FTL_IN_FLN_FILE

错误库%s

访问库时出错。通常其原因是文件
权限或因为库不存在。

消息标识：E_LIB_FILE

"EDECL_NEG_DIM.f", line 1:Error:数组“m”的非正维数

[dd1:]dd2 格式的维数边界表达式，用于指定
数组的下界和上界
值。它们可以是整数或实数类型的
算术表达式。可以使用 COMMON 语句中定义的常量、符号常量、
形式参数或变量来确定它们的格式。 
数组引用以及对自定义函数的引用都不能
在维数边界表达式中使用。dd2 也可以表示为星号。 
如果未指定 dd1，则会假设其中一个值。dd1 的值
必须小于或等于 dd2。

示例：由于第一个维数边界大于
第二个维数边界，因此出现错误。
dimension m(5:2)

消息标识：EDECL_NEG_DIM

"EDATA_0_POW_NEG.F", line 2:Error:零的负乘幂

c f77 EDATA_0_POW_NEG.F -Xlistv3
#define m -5
parameter (z=0**m)
print *, z
end

消息标识：EDATA_0_POW_NEG

**** WAR #101:整数的负乘幂

c f77 EDATA_INT_POW_NEG.F -Xlistv3
#define m -5
parameter (z=2**m)
print *, z
end

消息标识：EDATA_INT_POW_NEG

"EDATA_DIV_0.f", line 1:Error:除数为零

parameter ( n = 2 / 0 )
end

消息标识：EDATA_DIV_0

"EEXPR_SUBS.f", line 2:Error:“c”上的下标表达式溢出

real c(2,2)
data c(3,2) / 0.0 /
end

消息标识：EEXPR_SUBS_BOUNDS_SCR

"EEXPR_TYPE_1.f", line 8:Error:整数数据赋值给字符类型变量

不能将整数值赋值给字符类型变量。

示例：
character j
j = 1       
end

消息标识：EEXPR_TYPE

"EEXPR_TYPE_NONARITH_AOP.f", line 8:Error:算术操作符的非算术操作数

示例：由于子例程名不能在算术表达式中使用，
因此出现编译错误。
subroutine jim
jim = jim + 1
end

消息标识：EEXPR_TYPE_NONARITH_AOP

"EEXPR_TYPE.f", line 1:Error:逻辑操作符的非逻辑操作数

示例：
if ( 2.55 .and.1.45 .gt.2.99999 ) print *, 3.0
end

消息标识：EEXPR_TYPE_NONLOGICAL

"EEXPR_TYPE.f", line 1:Error:并置的非字符操作数


示例：
if ( 3 // 6 .eq.0.5 ) print *, 3/6
end

消息标识：EEXPR_TYPE_NONCHAR

"EEXPR_TYPE.f", line 5:Error:复合数据的顺序比较


示例：
if ( (2.5,0.0).gt.(0.0,2.5) ) print *, "Huh?"
end

消息标识：EEXPR_COMPARE_COMPLEX

"EDATA.f", line 2:Error:“d24”上的子串表达式溢出


示例：
character*10 d24
data d24(24:24) /'a'/

消息标识：EEXPR_SUBS_BOUNDS_STR

**** ERR #141:“s”调用中零的负乘幂


示例：
call s(0,-2)
end
subroutine s0(i,j)
integer i,j
j = abs(j)
entry s(i,j)
k= i**j
c            ^
c**** ERR  #141:zero raised to a negative power on "s" invocation
print *, k
end

消息标识：EDATA_0_POW_NEG_E

"EEXEC_DO.f", line 2:Error:零循环增量


示例：
real x(5)
do i=1, 5,0
x(i) = i + 5.0
enddo
end

消息标识：EEXEC_DO_ZERO_STEP

**** ERR #189:无法打开文件“no_file”

include "no_file"
C                     ^
C**** ERR  #189:cannot open file "no_file"
end

消息标识：ELEX_FILE

**** ERR #192:外部名称“f”已在使用参见："EJUNK_COMMON_GPC.f" line #1

用于公共块名的外部符号必须唯一
并且不能与另一个外部符号（例如过程名）
发生冲突。

示例：
subroutine f
return
end
common/f/f
f=1
end

消息标识：EJUNK_COMMON_GPC

"WSTRUCT.f", line 2:警告：无法执行语句

当 GOTO 语句导致跳过某些未标记的语句组时，
将出现此警告消息。

示例：
goto 10
print *, i
10   continue
end

消息标识：WSTRUCT_NREACH

**** ERR #202:“f2”调用中零循环增量

只有 -Xlistv3 编译选项才会发生这一错误。
当循环增量为伪参数并且相应的实际
参数为零时，会出现该错误。

示例：由于使用作为实际参数的 '0' 来调用 'f2'，
因此循环增量 'n3' 对应于 '0'。
call f2(0)
end
subroutine f(n3)
entry f2(n3)
do i=1, 2, n3	! Warning over here
C                     ^
C**** ERR  #202:zero loop increment on "f2" invocation
print *, i
enddo
end

消息标识：EEXEC_DO_ZERO_STEP_E

"WDATA.f", line 2:警告：重叠初始化

内存地址只能初始化一次。如果对同一个地址
执行多次初始化操作，则最后一次
初始化将覆盖前面的初始化结果，并且
编译器会发出警告消息。

示例：
real m(3) /1e+1,1e+2,1e+3/
data m(2) /-1e+2/
end

消息标识：WDATA_OVERLAP

"WDATA.f", line 7:警告：记录“t”中的重叠初始化

内存地址只能初始化一次。如果对同一个地址
执行多次初始化操作，则最后一次
初始化将覆盖前面的初始化结果，并且
编译器会发出警告消息。

示例：
structure /s/
联合
map
real t / 2.55 /
endmap
map
real q / 5.22 /
endmap
endunion
endstructure
record /s/ t(5)
t(1).q = 2.52
end

消息标识：WDATA_STRUCT_OVERLAP

"WDATA.f", line 1:零的零次乘幂


示例：
parameter (zz=0.0**0.0)
print *, zz

消息标识：WDATA_0_POW_0

**** ERR #217:“e”调用中除数为零

call e(0)
call s(1)
end
subroutine s(i)
j = 2/i
entry e(i)
j = 3/i
C**** ERR  #217:division by zero on "e" invocation
print *, j
end

消息标识：EDATA_DIV_0_E

"WEXEC.f", line 1:警告：从未执行 DO 范围

如果由于下边界大于上边界且
步骤大小大于零，或由于下边界小于上边界且
步骤大小小于零，
则不会执行 DO 循环，此时将发出这一警告消息。

示例：由于步骤大小为“1”且下边界“5”已
大于上边界“2”，因此该循环从不被执行。
do i=5,2
print *, i
enddo

消息标识：WEXEC_DO_ZERO_ITER

"WEXEC.f", line 2:警告：赋值给 do 循环计数器“j”

如果修改循环内的 DO 循环变量，则会影响
迭代次数。出现这种情况下时会发出警告消息
。

示例：
do j=1,5
j = j+1
enddo
end

消息标识：WEXEC_ASSIGN_COUNTER

"WCON_BIG_BIT.f", line 1:警告：转换过程中位值被截断

当位常数中的位数大于
目标变量中的位数时，最左边的位将被截断，
同时将发出一条警告消息。

示例：
integer*2 k / z'12345' /
end

消息标识：WCON_BIG_BIT

"WANSI_4.f", line 1:ANSI 扩展：整型操作数的逻辑操作

X = 4 .OR. 1

消息标识：WANSI_LOGOP_INT

"WANSI_4.f", line 4:ANSI 扩展：逻辑操作数的算术操作

LOGICAL Z, Z1
Z = .TRUE.
Z1 = .NOT.Z
Z = Z1 * Z

消息标识：WANSI_NUMOP_LOG

"WEXPR_VAL_TOOBIG.f", line 1:警告：值超出范围

parameter (x=2.5e+255+2.5e-255)
print *, x

消息标识：WEXPR_VAL_TOOBIG

**** ERR #312:重复声明“foo”，在文件 E_DUP_MAIN.f 的第 2 行中已经声明

C-# E_DUP_MAIN.f:
function foo(x)
foo = x
end
C-# E_DUP_MAIN_1.f:
function foo(x)
C                     ^
C**** ERR  #312:duplicate declaration of "foo", it is declared in file
C                E_DUP_MAIN.f, line 2
foo = x*x
end

消息标识：FDECL_DUP_PROC

**** ERR #313:重复声明主程序参见："E_DUP_MAIN.f" line #1

program X
end
program Z
C**** ERR  #313:duplicate declaration of main program
C                 参见："E_DUP_MAIN.f" line #1
end

消息标识：E_DUP_MAIN

**** WAR #314:该子程序中没有使用公共 /bl/ 的成员

subroutine s
common /bm/ z
common /bl/ a, x
C                     ^
C**** WAR  #314:members of common /bl/ not used in this subprogram
z = 2.0
end

消息标识：W_NOUSED_COMM

**** WAR #315:变量“a”已声明但从未使用

CFILE FDECL_UNUSED_TX.f
real a
C                     ^
C**** WAR  #315:variable "a" declared but never used
end

消息标识：FDECL_UNUSED_TX

**** ERR #316:在设置之前可能引用了函数“f”

print *,f1(10), f(1)
end
function f(l)
f = 3
return
entry f1(l)
f1=f+l
C                     ^
C**** ERR  #316:function "f" may be referenced before set
end

消息标识：FREF_UNSET_0

**** ERR #318:从未对引用的基于指针的数组“arr”设置指针

integer arr
pointer (p1, arr(10))
arr(1) = 0
C                     ^
C**** ERR  #318:pointer never set for referenced pointer-based array "arr" 
end

消息标识：F_NO_MEM_0

**** WAR #319:可疑的指针“cctptr”赋值

CFILE F_NO_SET_PNT.f
POINTER(CCTPTR, WRK01V)
INTEGER*4  CCTPTR
CCTPTR=3
C                     ^
C**** WAR  #319:possible suspicious pointer "cctptr" assignment
END

消息标识：F_NO_SET_PNT_0

**** WAR #320:变量“x”已设置但从未被引用

CFILE FDECL_UNUSED_TX.f
x = 2.5
C                     ^
C**** WAR  #320:variable "x" set but never referenced
end

消息标识：FSET_UNUSED

**** ERR #322:未设置“foo”函数结果

CFILE FFUN_UNSET.f
function foo(j)
j=j+1
end
C**** ERR  #322:"foo" function result is not set

消息标识：FFUN_UNSET

**** ERR #323:参数 #2 是表达式，但伪参数是函数

CFILE "EEXEC_CLARG.f"
intrinsic sin
i = foo (sin(0.0), 0.0)
C                     ^
C**** ERR  #323:argument #1 is expression, but dummy argument is function
C                 参见："EEXEC_CLARG.f" line #8
print *, i
end
function foo (sincos, x)
external sincos
if (sincos(x) .gt.0.0) foo=0
end

消息标识：EEXEC_CLARG

**** ERR #324:实际“s”的参数 #2 是值，但伪参数是子例程参见："EEXEC_CLARGF.f" line #5

C FILE  "EEXEC_CLARGF.f"
x = 1
call s(x,s)
end
subroutine s(x,soo)
if ( x.gt.1000 ) return
call soo(x,%val(x))
C                     ^
C**** ERR  #324:argument #2 for actual "s" is value, but dummy argument is subroutine
C                 参见："EEXEC_CLARGF.f" line #5
call soo(x,*5)
5   print *, x
end

消息标识：EEXEC_CLARGF

**** ERR #325:参数“y”是变量，但伪参数是函数参见："EEXEC_CLARG_ID.f" line #1

function foo( x, y )
real x, y
external x
foo = x(y)
end
x = foo(y, 5.0)
C                     ^
C**** ERR  #325:argument "y" is variable, but dummy argument is function
C                 参见："EEXEC_CLARG_ID.f" line #1
end

消息标识：EEXEC_CLARG_ID

**** ERR #326:实际“sin”的参数“j”是变量，但伪参数是数组参见："EEXEC_CLARG_IDF.f" line #6

CFILE  "EEXEC_CLARG_IDF.f"
external sin
i = foo(sin, 9)
print *,i, sin(1)
end
function sin(z)
real z(5)
sin = z(1)
end
function foo(sincos, j)
external sincos
if (sincos(j) .gt.0.0) foo=0
C                     ^
C**** ERR  #326:argument "j" for actual "sin" is variable, but dummy argument is array
C                 参见："EEXEC_CLARG_IDF.f" line #6
end

消息标识：EEXEC_CLARG_IDF

**** ERR #327:子例程“s”作为函数调用参见："EEXEC_NOFUN.f" line #8

CFILE "EEXEC_NOFUN.f"
call s(0.0)
x = s(0.1)
C                     ^
C**** ERR  #327:subroutine "s" called as function
C                 参见："EEXEC_NOFUN.f" line #8
end
subroutine s(x)
print *, x
end

消息标识：EEXEC_NOFUN

**** ERR #328:实际子例程“z”作为函数调用参见："EEXEC_NOFUN.f" line #14

CFILE  EEXEC_NOFUN.f
call z(x)
call s (0.0, z)
x = s (0.1, z)
end
subroutine s(x, z)
y = z(x) 
C                     ^
C**** ERR  #328:actual subroutine "z" called as function
C                 参见："EEXEC_NOFUN.f" line #14
call z(x)
print *, x
end
subroutine z(x)
x = 2.0
end

消息标识：EEXEC_NOFUNF

**** ERR #329:函数“z”作为子例程调用参见："EEXEC_NOSUB.f" line #9

CFILE  "EEXEC_NOSUB.f"
call z(x)
C                     ^
C**** ERR  #329:function "z" is called as subroutine
C                 参见："EEXEC_NOSUB.f" line #9
call s (0.0, z)
x = s (0.1, z)
end
real function z(x)
z = -x
end

消息标识：EEXEC_NOSUB

**** ERR #330:实际函数“z”作为子例程调用参见："EEXEC_NOSUB.f" line #12

CFILE  "EEXEC_NOSUB.f"
call z(x)
x = s (0.1, z)
end
subroutine s(x, z)
call z(x)
C                     ^
C**** ERR  #330:actual function "z" called as subroutine
C                 参见："EEXEC_NOSUB.f" line #12
print *, x
end
real function z(x)
z = -x
end

消息标识：EEXEC_NOSUBF

**** ERR #331:实际内在函数“cos”作为子例程调用

program p
intrinsic cos
call s(cos)
end
subroutine s(f)
external f
real f
call f(3.1415926*0.25)
C                     ^
C**** ERR  #331:actual intrinsic "cos" called as subroutine
end

消息标识：ECALL_INTR

**** ERR #332:实际内在函数“cos”的错误参数 #1

program p
intrinsic cos
call s(cos)
end
subroutine s(f)
external f
real f
print *, f(3,1415926)
C                     ^
C**** ERR  #332:bad number of arguments for actual intrinsic "cos"
end

消息标识：ENARG_INTR

实际内在函数 \"%s\" 的错误参数 #%d

program p
intrinsic cos
call s(cos)
end
subroutine s(f)
external f
real f
print *, f(20)
C                     ^
C**** ERR  #333:bad argument #1 for actual intrinsic "cos"
end

消息标识：ETYPE_IN_INTR

**** ERR #334:实际内在函数“cos”的错误参数“i”

program p
intrinsic cos
call s(cos)
end
subroutine s(f)
external f
real f
i = 3/1415926
print *,f(i)
C                     ^
C**** ERR  #334:bad argument "i" for actual intrinsic "cos"
end

消息标识：ETYPE_IN_INTR_ID

**** ERR #335:“s”的不同参数数参见："EEXEC_NARG_VAR.f" line #2

intrinsic sin
call s(sin)
call s(sin,x)
C                     ^
C**** ERR  #335:various number of arguments to "s"
C                 参见："EEXEC_NARG_VAR.f" line #2
end

消息标识：EEXEC_NARG_VAR

**** WAR #337:未定义的子程序“s”

call s(x)
C                     ^
C**** WAR  #337:undefined subprogram "s"
end

消息标识：WFYI_PROC_MISSING

**** WAR #338:从未从程序调用子例程“s”

print *, "Hello!"
end
subroutine s
C                     ^
C**** WAR  #338:subroutine "s" never called from program
print *, "Bye!"
end

消息标识：WFYI_NOACCESS

**** ERR #339:公共 /cb/ 的不兼容长度参见："EDCL_LENG_COMMON.f" line #1

common /cb/ a(10)
a(10) = 0.2
call s
end
subroutine s
common /cb/ a(9)
C                     ^
C**** ERR  #339:incompatible lengths for common /cb/
C                 参见："EDCL_LENG_COMMON.f" line #1
do i=1,9
a(i) = 0.1
enddo
print *, a
end

消息标识：EDCL_LENG_COMMON

**** WAR #341:在公共 /b/ 中，设置但未在程序中引用“i”

blockdata bld
common /b/ l,i
data i /0/, l /.true./
C                     ^
C**** WAR  #341:in common /b/, "i" set but not referenced in program
end
program main
common /b/ l,i
if (l) then
l = .not. l
end if
end

消息标识：WFYI_SET_NOUSE_COM

**** WAR #342:在“j”（偏移 = 4）中公共 /c/ 的不兼容类型参见："WFYI_TYPE_COM.f" line #4

call s0
end
subroutine s1
common /c/a,b,k
print *,a,b,k
end
subroutine s0
common /c/a,j,k
C                     ^
C**** WAR  #342:incompatible types for common /c/ at "j" (offset = 4)
C                 参见："WFYI_TYPE_COM.f" line #15
a=1.0
j=2
k=3
call s1
end

消息标识：WFYI_TYPE_COM

**** WAR #345:可能是零的负乘幂

i = -2
iz = 0
if ( irand(1) .gt.125 ) i = -i
if ( irand(1) .gt.125 ) j = iz**i
C                     ^
C**** WAR  #345:可能是零的负乘幂
end

消息标识：EDATA_0_POW_NEG_P

**** ERR #346:“se”调用中的参数 #2 已修改参见："WFYI_ARGLET.f" line #10

a = 3.5
call se (a, 3.0)
C                     ^
C**** ERR  #346:argument #2 in "se" call is modified
C                 参见："WFYI_ARGLET.f" line #10
print *, a
end
subroutine soo (x, y)
x = y+1
entry se (x, y)
y = x+1
end

消息标识：WFYI_ARGLET

**** ERR #347:实际“soo”的参数 #2 已修改参见："WFYI_ARGLET.f" line #8

a = 3.5
call soo (b, a)
call se (a, 3.0)
call ss (soo, b, 3.5)
call ss (se, 3.0, a)
print *,a,b
end
subroutine soo (x, y)
x = y+1
entry se (x, y)
y = x+1
end
subroutine ss (s, x, y)
external s
call s (x, y)
call s (1.0, y)
call s (x, 1.0)
C                     ^
C**** ERR  #347:argument #2 for actual "soo" is modified
C                 参见："WFYI_ARGLET.f" line #8
C       call s (x, 1.0)
C                     ^
C**** ERR  #347:argument #2 for actual "se" is modified
C                 参见："WFYI_ARGLET.f" line #10
end

消息标识：WFYI_ARGLETF

**** WAR #348:“fct”的递归调用。请参见动态调用："WANSI.f" line #6

FUNCTION FCT(I)
INTEGER FCT, FC1
IF (I.EQ.1) THEN
FCT = I
ELSE
FCT = FC1(I-1)
ENDIF
END
FUNCTION FC1(I)
INTEGER FC1, FCT
FC1 = FCT(I)
C                     ^
C**** WAR  #348:recursive call for "fct".See dynamic calls:
C                 "WANSI.f" line #6
END

消息标识：WANSI_RECURS

**** WAR #350:可能是“s”调用中零循环增量

i = 0
call s(i)
call se(i)
end
subroutine s(ii)
if ( irand(0) .gt.125 ) ii = 2
entry se(ii)
if ( irand(0) .gt.125 ) ii = ii+1
do  1 i=1,10,ii
C                     ^
C**** WAR  #350:possibly may be zero loop increment on "s" invocation
1    print *, i
end

消息标识：EEXEC_DO_ZERO_STEP_E_P

**** ERR #351:类型不匹配：“ss1”调用中的参数“p1” 参见："WFYI_TYARG_ID.f" line #13

structure /s1/
logical flag
end structure
record /s1/ s1(2),v1(1)
pointer (p1,v1)
p1=loc(s1)
call ss1(p1,1)
C                     ^
C**** ERR  #351:类型不匹配：argument "p1" in "ss1" call
C                 参见："WFYI_TYARG_ID.f" line #13
print *, v1(1).flag
end
subroutine ss1(p1,ilen)
structure /s1/
integer age
end structure
record /s1/v1(1)
pointer (p1,v1)
v1(1).age  = 16
end

消息标识：WFYI_TYARG_ID

**** ERR #352:类型不匹配：实际“ss1”的参数“p1” 参见："WFYI_TYARG_ID_F.f" line #19

external ss1
call ss(ss1)
end
subroutine ss(soo)
structure /s1/
logical flag
end structure
record /s1/ s1(2),v1(1)
pointer (p1,v1)
external soo
p1=loc(s1)
call soo(p1,1)
C                     ^
C**** ERR  #352:类型不匹配：argument "p1" for actual "ss1"
C                 参见："WFYI_TYARG_ID_F.f" line #18
print *, v1(1).flag
end
subroutine ss1(p1,ilen)
structure /s1/
integer age
end structure
record /s1/v1(1)
pointer (p1,v1)
v1(1).age  = 16
end

消息标识：WFYI_TYARG_ID_F

"WANSI.f", line 24:ANSI 扩展：操作符中的不兼容操作数类型

doubleprecision r / 123d+12 /
complex cx / ( 34.5, 6.78 ) /
x = cx * r

消息标识：WANSI_INCOM_OP

**** WAR #354:GOTO 语句中的常量表达式

5   GOTO (5,5) 5

消息标识：W_CONST_COND_G

**** WAR #355:if 语句中的常量表达式

if (.NOT..TRUE.) i=2

消息标识：W_CONST_COND

**** WAR #356:乘以零

a=a*0
end

消息标识：WDATA_MUL_0

**** WAR #357:乘以一

a=1*a
end

消息标识：WDATA_MUL_1

**** WAR #358:除以一

a=a/1
end

消息标识：WDATA_DIV_1

**** WAR #359:零加法

a=a+0
end

消息标识：WDATA_ADD_0

**** WAR #360:零减法

a=a-0
end

消息标识：WDATA_SUB_0

**** WAR #361:零作为幂参数

a=a**0
end

消息标识：WDATA_POW_0

**** WAR #362:冗余幂

i=i**1
i=1**i
end

消息标识：WDATA_POW_1

**** WAR #363:可能是零循环增量

subroutine f
common k
n1=1
if (k.eq.1) n1=0
do i=1, 2, n1
C                     ^
C**** WAR  #363:可能是零循环增量
print *, i
enddo
end

消息标识：EEXEC_DO_ZERO_STEP_P

**** WAR #364:.NOT. 运算的常量参数

logical l
l = .not..false.
end

消息标识：WDATA_NOT_CONS

**** WAR #365:.NOT. 运算的常量参数

logical l
l = l.and..false.
end

消息标识：WDATA_AND_FALSE

**** WAR #366:.NOT. 运算的常量参数

logical l
l = l.and..true.
end

消息标识：WDATA_AND_TRUE

**** WAR #367:.OR. 运算的常量参数

logical l
l = l.or..false.
end

消息标识：WDATA_OR_FALSE

**** WAR #368:.OR. 运算的常量参数

logical l
l = l.or..true.
end

消息标识：WDATA_OR_TRUE

**** WAR #369:可能是“g1”调用中除数为零

subroutine g()
common k
n=-1
if (k.eq.1) n = 0
m=1/n
1        m = n/m
C**** WAR  #369:possibly may be division by zero on "g1" invocation
return
entry g1()
m=1
if (k.eq.1) m = 0
n=1
goto 1
end
C
common k
read (5,*) k
call g()
call g1()
end

消息标识：EDATA_DIV_0_E_P

**** WAR #373:“s”中实际参数大小比伪参数小参见："E_ARRAY_SIZE.f" line #9

program err
integer*2 j(2)
call s(j,2)
C                     ^
C**** WAR  #373:size of actual argument less than size of dummy in "s"
C                 参见："E_ARRAY_SIZE.f" line #9
end
subroutine s(j,k)
integer*2 j(4)
print *, j, k
end

消息标识：E_ARRAY_SIZE

**** WAR #374:实际参数大小比实际“s”的伪参数小参见："E_ARRAY_SIZE.f" line #7

program err
integer*2 j(2)
external s
call ss(s,j,2)
end	
subroutine s(j,k)
integer*2 j(4)
print *, j, k
end
subroutine ss(foo,j,k)
external foo
integer*2 j(2)
call foo(j,k)
C                     ^
C**** WAR  #374:size of actual argument less than size of dummy for
C                 actual "s421"
end

消息标识：E_ARRAY_SIZE_F

**** WAR #375:在“ss”调用中，修改“ar”（参数 #1 和 #2）可能不正确

real ar(10)
real ar1(25)
call ss(ar, ar)
C                     ^
C**** WAR  #375:possible incorrect modification of "ar" (arguments #1 and #2) in "ss" call
call ss(ar1(10), ar(8))
end
subroutine ss(x, y)
real x(5), y(20)
x(1) = y(1)
end

消息标识：WFYI_SECOND_ARG

**** WAR #376:修改实际“acs”的“nn”（参数 #1 和 #2）可能不正确

external acs
double precision mm  
mm = -5.D+00
call s(acs,3.D+00,mm)
end
subroutine s(dms,mm,nn)
external dms 
double precision mm, nn, ii2  
common /bl2/ ii2
ii2 = 3.D+00 
call dms(nn,nn)
C                     ^
C**** WAR  #376:possible incorrect modification "nn" (arguments #1 and #2) for actual "acs"
end
subroutine acs(jj,ll)
double precision jj,ll,kk,ii2 
common /bl2/ ii2
kk = jj * ii2
ll = kk + 1.D+00
end

消息标识：WFYI_SECOND_ARG_F

**** WAR #377:“sample4_1”调用中，可能不正确地设置/使用公共区中的“x”

subroutine sample 4_1 (a, b, c, d)
common /s_4/ x
a = 1.
c = 1.
x = 1.
print *, a, b, c, d, x
end
subroutine sample 4
common /s_4/ x
call sample 4_1 (1., a, a, x)
C                     ^
C**** WAR  #377:possible incorrect sets/uses "x" from common in "sample4_1" call
end

消息标识：WFYI_COM_ARG

**** WAR #378:实际“as”中，可能不正确地设置/使用公共区中的“x”

subroutine AS (a)
common /cb/ x
a = 1.0
x = 1.0
print *, a, x
end
subroutine S (DS, a)
common /cb/ x
call DS (x) 
C                     ^
C**** WAR  #378:possible incorrect sets/uses "x" from common in actual "as"
print *, a
end
external AS
common /cb/ x
call S (AS, 1.0)
print *, x
end

消息标识：WFYI_COM_ARGF

**** WAR #379:“d”的下标表达式可能溢出

real c(2,2)
call s(c,2,2)
end
subroutine s(d,m,n)
real d(m,n)
i = 2
if ( irand(1) .gt.1234567 ) i = 3
d(i,2) = 0.0
C                     ^
C**** WAR  #379:subscript expression on "d" possibly may be out of bounds
end

消息标识：EEXPR_SUBS_BOUNDS_SCR_P

**** WAR #380:对于入口“f”，变量“l”仅在未执行的代码中使用

print *,f1(10), f(1)
end
function f(l)
C**** WAR  #380:variable "l" used only in unreached code for entry "f"
f = 3
return
entry f1(l)
f1=f+l
end

消息标识：FDECL_UNUSED_E

**** WAR #381:对于入口“f1”，变量“h”已设置但从未被引用

print *,f1(10), f(1)
end
function f(l)
h = 3
f = h
return
entry f1(l)
f1 = l+1
h = l
C                     ^
C**** WAR  #381:variable "h" set but never referenced for entry "f1"
end

消息标识：FSET_UNUSED_E

**** WAR #382:公共 /c382/ 中不存在变量“a” 参见："W_COM_NONAME.f" line #2

blockdata
common /c382/b(5),a,d(2)
data (b(i),i=1,5)/1.0,4*2.0/,a/7.77/,d/3.33,-3.33/
end
program w382
common /c382/b(5)
c            ^
c #382:in common /c382/ no variable "a"
c        See:"W_COM_NONAME.f" line #10
print *, (b(i),i=1,5)
end

消息标识：W_COM_NONAME

**** WAR #383:公共 /c382/ 中的附加变量“z” 参见："W_COM_NONAME.f" line #2

blockdata
common /c383/b(5),a,d(2)
data (b(i),i=1,5)/1.0,4*2.0/,a/7.77/,d/3.33,-3.33/
end
program w383
common /c383/b(5)a,d(2),z
c            ^
c #383:in common /c383/ additional variable "a"
c        See:"W_COM_NONAME.f" line #10
print *, (b(i),i=1,5), z
end

消息标识：W_COM_ADDNAME

**** WAR #384:公共 /cmm/ 中“imset”的长度不兼容参见："W_COM_SIZE.f" line #4

subroutine gtest
integer *2 ,imset(4),imused(4)
common /cmm/ imset,imused
imset(1)=imused(1)
print *,imset
end
integer *2 ,imset(5),imused(5)
common /cmm/ imset,imused
C                     ^
C**** WAR  #384:in common /cmm/ incompatible lengths for "imset"
C                 参见："W_COM_SIZE.f" line #3
call gtest
print *,imset,imused ! iset,iused
end

消息标识：W_COM_SIZE

**** WAR #385:公共 /cmm/（在“is.x”中）中的不兼容类型参见："W_COM_TYPE.f" line #8

subroutine gtest
structure /s/
integer imset(4)
real x
integer imused(4)
endstructure
record /s/ is
common /cmm/ is
is.x=1.0
print *, is.x
end
subroutine g007
structure /s/
integer imset(4)
integer x
integer imused(4)
endstructure
record /s/ is
common /cmm/ is
C                     ^
C**** WAR  #385:incompatible types in common /cmm/ (at "is.x")
C                 参见："W_COM_TYPE.f" line #8
call gtest
print *,is.x
end

消息标识：W_COM_TYPE

**** WAR #386:公共 /cmm/（在“im”中）中的不兼容名称参见："W_COM_NAME.f" line #3

subroutine gtest
integer *2 imset(2),imused(4)
common /cmm/ imset,imused
imset(1)=1
imset(2)=imset(1)+1
print *,imset
end
integer *2 im(2),imused(4)
common  /cmm/ im,imused
C                     ^
C**** WAR  #386:incompatible names in common /cmm/ (at "im")
C                 参见："W_COM_NAME.f" line #3
call gtest
print *,im
end

消息标识：W_COM_NAME

**** WAR #387:公共 /c/（在“j”中）中的不兼容布局参见："W_COM_LAYOUT.f" line #2

subroutine s1
common /c/k,j,i
integer*4 i,j(2),k
print *, i,j(2)
end
common /c/k,j,i
C                     ^
C**** WAR  #387:incompatible layouts in common /c/ (at "j")
C                 参见："W_COM_LAYOUT.f" line #2
integer*4 j,k
real*4 i(2)
i(2) = 2.0
j=int(i(2))
call s1
end

消息标识：W_COM_LAYOUT

**** WAR #388:可能除数为零

subroutine g()
common k
m=1
if (k.eq.1) m = 0
n=1
goto 1
entry g1()
n=-1
if (k.eq.1) n = 0
m=1/n
C                     ^
C**** WAR  #388:可能除数为零
1  m = n/m
return
end
common k
read (5,*) k
call g()
call g1()
end

消息标识：EDATA_DIV_0_P

**** WAR #389:类型不匹配：“ss1”调用中的记录“s1”，字段“s1.data” 参见："WFYI_TYARG_REC.f" line #12

S T R U C T U R E /s1/
integer data
character*2 age
end S T R U C T U R E
parameter (len=2)
record /s1/ st(len)
call ss1(st)
C                     ^
C**** WAR  #389:类型不匹配：record "s1", field "s1.data", in "ss1" call
C                 参见："WFYI_TYARG_REC.f" line #12
end
subroutine ss1(s1)
common /c/ len
S T R U C T U R E /s1/
character*9 data
integer age
end structure
record /s1/s1(2)
external f
i=1
s1(i).data  = '960904'
s1(i).age = 16
end

消息标识：WFYI_TYARG_REC

**** WAR #390:类型不匹配：实际“f”的记录“rp1”，字段“rp1.a” 参见："f.f" line #17

external f
call x(f)
end
subroutine x(fun)
structure /s1/
real a, r
end structure
record /s1/ rp1(10)
external fun
real fun
r = fun(rp1)
C                     ^
C**** WAR  #390:类型不匹配：record "rp1", field "rp1.a", for actual "f"
C                 参见："f.f" line #17
print *, r
end
function f(rp1)
structure /s1/
double precision r
end structure
record /s1/ rp1(10)
f = rp1(1).r
end

消息标识：WFYI_TYARG_REC_F

**** WAR #391:格式“6010”仅在未执行的代码中使用

CHARACTER *80 FILE
INQUIRE (5, NAME=FILE, IOSTAT=IOSTAT) 
GO TO 700
WRITE (6, 6010) FILE, IOSTAT
6010 FORMAT ( ' ERROR READING FILE "', A, '".',I )
C                     ^
C**** WAR  #391:format "6010" used only in unreached code
GO TO 700
700 WRITE (6, *) FILE 
END

消息标识：FDECL_UNUSED

**** WAR #393:无法执行逻辑 IF 的语句

if (.NOT..TRUE.) i=2
end

消息标识：WSTRUCT_NREACH_L

**** ERR #394:修改“soo”调用中的 DO 变量“i” 参见："E_DOVAR_CH.f" line #6

external soo
do i = 1,5
call soo(i)
C                     ^
C**** ERR  #394:DO-variable "i" modified in "soo" call
C                 参见："E_DOVAR_CH.f" line #6
enddo
end
subroutine soo(k)
k = k+1
end

消息标识：E_DOVAR_CH

**** ERR #395:修改实际“soo”中的 DO 变量“m” 参见："E_DOVAR_CH.f" line #5

external soo
call too(soo)
end
subroutine soo(k)
k = k+1
end
subroutine too(s,n)
do m=2,5
call s(m)
C                     ^
C**** ERR  #395:DO-variable "m" modified in actual "soo"
C                 参见："E_DOVAR_CH.f" line #5
enddo
end

消息标识：E_DOVAR_CH_F

"WANSI.f", line 1:ANSI 扩展：字符操作数的算术运算

if ( 'abc' .ne.3 ) print *, 1

消息标识：WANSI_NUMOP_CHAR

"WANSI.f", line 2:ANSI 扩展：字符操作数的逻辑运算

character str*3 /'adc'/
print *, .not.str(1:2)

消息标识：WANSI_LOGOP_CHAR

**** WAR #400:字段“j”的不兼容类型。参见：line 5

structure /s/
联合
map
real*4 i
integer j
endmap
map
integer*2 ii/1/
real j /2.87/
C                     ^
C**** WAR  #400:incompatible type of field "j".参见：line 6
endmap
endunion
endstructure
record /s/ x
print *, x.j, x.ii, x.i
end

消息标识：W_FIELD_TYPE

**** WAR #401:各种字段“age”的偏移。参见：line 5

structure /s/
联合
map
integer*4 i
character*5 age
endmap
map
integer*2 ii/1/
character*5 age / "5 yrs" /
C                     ^
C**** WAR  #401:various field "age" offset.参见：line 5
endmap
endunion
endstructure
record /s/ x
print *, x.i, x.ii, x.age
end

消息标识：W_FIELD_OFFSET

**** WAR #402:字段“ch”的各种长度。参见：line 20

structure /ss/
联合
map
integer i /1/
character ch/'*'/
endmap
map
integer i
character*4 ch
C                     ^
C**** WAR  #402:various length of field "ch".参见：line 20
endmap
endunion
endstructure
record /ss/ xx
print *, xx.i, xx.ch
end

消息标识：W_FIELD_SIZE

**** ERR #407:“sss”调用中使用不一致的伪参数

external f
call sss(f)
end
subroutine ss(foo,x)
external foo
x = 2.5
entry sss(foo)
x = foo(x*x)
C                     ^
C**** ERR  #407:inconsistent usage of dummy argument on "sss" invocation
end
function f(z)
f = -z
end

消息标识：EINC_US_D_A

**** WAR #408:“sss”调用中无法执行逻辑 IF 的语句

call sss(0)
end
subroutine ss(x)
integer x
x = 2
entry sss(x)
if ( x .gt.1.0 ) print *, x*x
C**** WAR  #408:statement in logical IF cannot be reached on "sss" invocation
end

消息标识：WSTRUCT_NREACH_L_E

**** WAR #409:“sss”调用中从未执行 DO 范围

call sss(0)
end
subroutine ss(x)
integer x
x = 2
entry sss(x)
do i=1,x
C                     ^
C**** WAR  #409:DO range never executed on "sss" invocation
print *, i+x
enddo
end

消息标识：WEXEC_DO_ZERO_ITER_E

**** WAR #411:主程序不包含可执行语句

program X
end
**** WAR  #411:主程序不包含可执行语句

消息标识：W_NO_EXEC_ST_MAIN

**** ERR #412:函数“fct”用作实数但声明为整数

J = FCT(0)
C                     ^
C**** ERR  #412:function "fct" used as real but declared as integer
END
FUNCTION FCT(I)
INTEGER FCT
FCT = I
END

消息标识：W_TY_DEFFUN

**** ERR #413:实际函数“fct”用作实数但声明为整数参见："W_TY_DEFFUNF.f" line #7

EXTERNAL FCT
CALL S(FCT)
END
SUBROUTINE S(F)
C                     ^
C**** ERR  #413:actual function "fct" used as real but declared as integer
C                 参见："W_TY_DEFFUNF.f" line #7
J = F(0)
END
FUNCTION FCT(I)
INTEGER FCT
FCT = I
END

消息标识：W_TY_DEFFUNF

**** ERR #416:参数 #1 是复数，但伪参数是字符参见："E_LTYARG.f" line #4

complex cc / (55.0,1.0) /
call s(cc*cc,54)
C                     ^
C**** ERR  #416:argument #1 is complex, but dummy argument is character
C                 参见："E_LTYARG.f" line #4
end
subroutine s(st,i)
character st*55
print *, st(i:i)
end

消息标识：E_LTYARG

**** ERR #417:实际“sincos”的参数 #1 是整数，但伪参数是实数参见："E_LTYARGF.f" line #1

CFILE  "E_LTYARGF.f"
function sincos( x )
real x
sincos = sin(x) + cos(x)
end
function foo(cs, i)
integer i
external cs
if (cs(i*2) .gt.0.0) foo=0
C                     ^
C**** ERR  #417:argument #1 for actual "sincos" is integer, but dummy argument is real
C                 参见："E_LTYARGF.f" line #1
end
external sincos
x = foo(sincos, 2)
call soo(*5)
call soo(6)
5   print *, x
end
subroutine soo(*)
return 1
end

消息标识：E_LTYARGF

**** ERR #418:参数“cc”是复数，但伪参数是字符参见："E_LTYARG_ID.f" line #4

C FILE  "E_LTYARG_ID.f"
complex cc / (55.0,1.0) /
call s(cc,54)
C                     ^
C**** ERR  #418:argument "cc" is complex, but dummy argument is character
C                 参见："E_LTYARG_ID.f" line #4
end
subroutine s(st,i)
character st*55
st(55:55)=st(i:i)
end

消息标识：E_LTYARG_ID

**** ERR #419:实际“sincos”的参数“i”是整数，但伪参数是实数参见："EEXEC_CLARGF.f" line #1

CFILE  EEXEC_CLARGF.f
function sincos( x )
real x
sincos = sin(x) + cos(x)
end
function foo(cs, i)
integer i
external cs
if (cs(i) .gt.0.0) foo=0
C                     ^
C**** ERR  #419:argument "i" for actual "sincos" is integer, but dummy argument is real
C                 参见："E_LTYARG_IDF.f" line #1
end
external sincos
x = foo(sincos, 2)
end

消息标识：E_LTYARG_IDF

**** WAR #423:可能是在“s”调用中零的负乘幂

iz = 0
call s(iz)
if ( irand(0) .gt.125 ) call se(0)
end
subroutine s(ii)
if ( irand(1) .gt.125 ) ii = 2
entry se(ii)
kk = -2
ij = ii
if ( irand(0) .gt.125 ) kk = 2
if ( irand(0) .gt.125 ) ij = ii+1
i = ii**kk
C                     ^
C**** WAR  #423:possibly may be zero raised to a negative power on "s" invocation
print *, i
end

消息标识：EDATA_0_POW_NEG_E_P

**** WAR #424:变量“n”缺省情况下设置为零值

print *, i
C                     ^
C**** WAR  #424:variable "i" is set to zero value by default
end

消息标识：E_SET_ZERO_0

**** WAR #425:在“sss”调用中，“x”中的下标表达式溢出

CALL SSS(11)
CALL SS(10)
END
SUBROUTINE SS(I)
REAL X(10)
COMMON /BL/X
X(I)=1
ENTRY SSS(I)
X(I)=2
C                     ^
C**** WAR  #425:subscript expression on "x" out of bounds on "sss" invocation
END

消息标识：EEXPR_SUBS_BOUNDS_E

**** WAR #426:在“sss”调用中，“x”中的下标表达式可能溢出

J=11
IF (IRAND(1).GT.12345) J=J-2
CALL SSS(J)
CALL SS(10)
END
SUBROUTINE SS(I)
REAL X(10)
COMMON /BL/X
X(I)=1
ENTRY SSS(I)
X(I)=2
C                     ^
C**** WAR  #426:subscript expression on "x" possibly may be out of bounds
C                 on "sss" invocation
END

消息标识：EEXPR_SUBS_BOUNDS_E_P

**** WAR #427:在该语句中通过“f”调用更改“i”

i = f(i) + i
C                     ^
C**** WAR  #427:"i" changed in this statement, via "f" call
print *, i
end
function f(i)
i = 3
f = i - 1
end

消息标识：F_SET_FUN_USED

**** WAR #428:通过“i”，该语句中的“g”调用取决于“f”调用

i = f(i) + g(i)
C                     ^
C**** WAR  #428:"g" call depended on "f" call in this statement, via "i"
print *, i
end
function f(i)
i = 3
f = i - 1
end
function g(k)
g = -k
end

消息标识：F_FUN_INF_FUN

i = f(i) + g(i)
C                     ^
C**** WAR  #429:"g" call may be depended on "f" call in this statement, via "i"
print *, i
end
function f(i)
if (irand(1).gt.12345) i = 3
f = i - 1
end
function g(i)
g = 1 - i
end

消息标识：F_FUN_INF_FUN_MAYBE

"EEXPR_TYPE_LOG.f", line 2:Error:逻辑数据赋值给复数类型变量

complex c
c = .true.
end

消息标识：EEXPR_TYPE_LOG_CMPL

"EEXPR_TYPE_LOG.f", line 2:Error:逻辑数据赋值给两倍复数类型变量

complex*16 cc
cc = .true.
end

消息标识：EEXPR_TYPE_LOG_DCMPL

"EEXPR_TYPE_LOG1.f", line 2:Error:逻辑数据赋值给四倍复数类型变量

complex*32 cc
cc = .true.
end

消息标识：EEXPR_TYPE_LOG_QCMPL

"EEXPR_TYPE_NUM_CHAR.f", line 2:Error:数值数据赋值给字符类型变量

character s
parameter ( s = 5.5 )
print *, s
end

消息标识：EEXPR_TYPE_NUM_CHAR

"EEXPR_TYPE_NONARITH.f", line 5:Error:负数的非算术操作数

structure /ss/
logical l/.true./,l1/.false./
endstructure
record /ss/ ll
print *, -ll
end

消息标识：EEXPR_TYPE_NONARITH_NEG

"EEXPR_TYPE_NONARITH.f", line 6:Error:比较的非算术操作数

structure /ss/
logical l/.true./,l1/.false./
endstructure
record /ss/ ll
print *, (11.gt.ll)
end

消息标识：EEXPR_TYPE_NONARITH_CMP

"EEXPR_TYPE_NONARITH.f", line 7:Error:NOT 的非逻辑操作数

structure /ss/
logical l/.true./,l1/.false./
endstructure
record /ss/ ll
print *, .not.ll
end

消息标识：EEXPR_TYPE_NONLOGICAL_NOT

"WEXPR_OVERFLOW1.f", line 3:警告：表达式中溢出

parameter (k=200)
parameter (k1=2**214, k2=-2**(-k))
print *,k,k1,k2
end

消息标识：WEXPR_OVERFLOW1

**** ERR #556:对于入口 sa，公共 /bl/ 中的变量“i”在整个 sa/sbb 上作为 integer4 被引用，但在第 #14 行被 sa 设置为 integer2

CFILE  "F_PIU_1.f"
CALL SB
CALL SA
END
SUBROUTINE SBA
INTEGER*4 I
COMMON /BL/ I
I = I - 10000
C                     ^
C**** ERR  #556:variable "i" in common /bl/ referenced as integer*4 across
C                 sa/sba but set as integer*2 by sa in line #14 for entry sa
END
SUBROUTINE SA
COMMON /BL/ I, J
INTEGER*2 I, J
IF (IRAND(0).GT.0) RETURN
ENTRY SB
J = -16383
CALL SBA
END

消息标识：F_PIU_1

**** WAR #557:对于入口 sa，公共 /bl/ 中的可能变量“i”在整个 sa/sba 上作为 integer4 被引用，但在第 #14 行被 sa 设置为 integer2

CFILE  "F_PIU_1_P.f"
CALL SB
CALL SA
END
SUBROUTINE SBA
INTEGER*4 I
COMMON /BL/ I
I = I - 10000
C                     ^
C**** WAR  #557:possibly variable "i" in common /bl/ referenced as integer*4
C                 across sa/sba but set as integer*2 by sa in line #14 for
C                 entry sa 
I = I - 10000
END
SUBROUTINE SA
COMMON /BL/ I, J
INTEGER*2 I, J
IF (IRAND(0).GT.0) RETURN
ENTRY SB
IF (IRAND(0).GT.0) J = -16383
CALL SBA
END

消息标识：F_PIU_1_P

**** ERR #560:变量“i”在第 #8 行的整个 MAIN/sbb 上作为 integer4 被引用，但在第 #1 行被 MAIN 设置为 integer2

INTEGER*2 I/16383/
CALL SBB(I)
C                     ^
C**** ERR  #560:variable "i" referenced as integer*4 across MAIN/sbb in line #8 but set as integer*2 by MAIN in line #1
I=I+1
PRINT *,I
END
SUBROUTINE SBB(I)
INTEGER*4 I
IF (I.GT.0) I = I - 10000
END

消息标识：F_PIU_3

**** WAR #561:可能变量“x”在第 #14 行的整个 MAIN/sbb/ 上作为指针被引用，但在第 #4 被 MAIN 设置为 real*4

CFILE  "F_PIU_3_P.f"
COMMON /BL/ I
INTEGER*2 I/16383/
CALL SSS
END
SUBROUTINE SSS
COMMON /BL/ I
INTEGER*4 I
CALL SBB(I)
C                     ^
C**** WAR  #561:possibly variable "i" in common /bl/ referenced as integer*4 across MAIN/sss but set as integer*2 by MAIN in line #2
I=I+1
PRINT *,I
END
SUBROUTINE SBB(I)
INTEGER*4 I
IF (IRAND(0).GT.0) I = I - 10000
END

消息标识：F_PIU_3_P

**** ERR #562:公共 /bl/ 中的变量“i”作为 integer2 被引用，但在第 #16 被 MAIN/sbb 设置为 integer4

CFILE  "F_PIU_4.f"
COMMON /BL/ I,J, II
INTEGER*2 I, J
INTEGER*4 II
I = -255*63
J = 1
CALL SBB
I=I+1
C                     ^
C**** ERR  #562:variable "i" in common /bl/ referenced as integer*2 but set
C                 as integer*4 by MAIN/sbb in line #16
PRINT *, I, J, II
C                     ^
C**** ERR  #562:variable "j" in common /bl/ referenced as integer*2 but set
C                 as integer*4 by MAIN/sbb in line #16
END
SUBROUTINE SBB
COMMON /BL/ I, II
INTEGER*4 I
INTEGER*4 II
INTEGER*2 M(2)
EQUIVALENCE (I,M)
I = M(1)+M(2)
II = 99
END

消息标识：F_PIU_4

**** WAR #563:公共 /bl/ 中的可能变量“j”作为 integer2 被引用，但在第 #13 行被 MAIN/sbb 设置为 integer4

CFILE  "F_PIU_4_P.f"
COMMON /BL/ I,J
INTEGER*2 I, J
I = -255*63
J = 1
IF (IRAND(0).GT.12345) CALL SBB
PRINT *, I, J
C                     ^
C**** WAR  #563:possibly variable "i" in common /bl/ referenced as integer*2
C                 but set as integer*4 by MAIN/sbb in line #13
PRINT *, I, J
C                     ^
C**** WAR  #563:possibly variable "j" in common /bl/ referenced as integer*2
C                 but set as integer*4 by MAIN/sbb in line #13
END
SUBROUTINE SBB
COMMON /BL/ I
INTEGER*4 I
INTEGER*2 M(2)
EQUIVALENCE (I,M)
IF (IRAND(0).GT.12345) I = M(1)+M(2)
END

消息标识：F_PIU_4_P

**** ERR #570:变量“i”作为 integer2 被引用，但在第 #2 行被设置为 integer4

INTEGER*2 I/16383/
CALL SBB(I)
I=I+1
C                     ^
C**** ERR  #570:variable "i" referenced as integer*2 but set as integer*4 in line #8
PRINT *,I
END
SUBROUTINE SBB(I)
INTEGER*4 I
IF (I.GT.0) I = I - 10000
END

消息标识：F_PIU_8

**** WAR #571:公共 /bl/ 中的可能变量“i”作为 integer2 被引用，但在第 #5 行被设置为 integer4

COMMON /BL/ I, J
INTEGER*2 I/16383/ , J
INTEGER *4 K
EQUIVALENCE (I, K)
IF (IRAND(1).GT.0) K = 16383
IF (IRAND(0).GT.0) CALL SSS
PRINT *,I
C                     ^
C**** WAR  #571:possibly variable "i" in common /bl/ referenced as integer*2 but set as integer*4 in line #5
END
SUBROUTINE SSS
COMMON /BL/ I
INTEGER*4 I
IF (IRAND(0).GT.0) I=I+1
END

消息标识：F_PIU_8_P

**** ERR #580:在第 #13 行中，从未通过 sse 对公共 /bl/ 中引用的基于指针的变量“j”设置指针

POINTER (IP, J)
CALL SSE(J)
C                     ^
C**** ERR  #580:pointer never set for referenced pointer-based variable "j" by sse in line #13
IP = MALLOC(4)
CALL SSS(J)
PRINT *, J
END
SUBROUTINE SSS(J)
COMMON /BL/ I
I = 0
RETURN
ENTRY SSE(J)
PRINT *, J
END

消息标识：F_NO_MEM_2

**** WAR #581:在第 #13 行中，从未通过 sse 对公共 /bl/ 中引用的基于指针的变量“j”设置可能指针

POINTER (IP, J)
IF ( IRAND(1) .GT.12345 ) IP = MALLOC(4)
CALL SSE(J)
C                     ^
C**** WAR  #581:possibly pointer never set for referenced pointer-based variable "j"  by sse in line #13
IP = MALLOC(4)
CALL SSS(J)
PRINT *, J
END
SUBROUTINE SSS(J)
COMMON /BL/ I
I = 0
RETURN
ENTRY SSE(J)
PRINT *, J
END

消息标识：F_NO_MEM_2_P

**** WAR #588:未设置可能的“f”函数结果

y = irand(1)
x = f(y)
print *, x
end
real function f(y)
if (y.ne.0) f = -y
end

消息标识：FFUN_UNSET_PSBL

**** ERR #1008:修改“soo”调用中的常量“i” 参见："E_CONST_CH.f" line #7

parameter (i = 2)
call soo(i)
C                     ^
C**** ERR  #1008:constant "i" is modified in "soo" call
C                 参见："E_CONST_CH.f" line #7
end
subroutine soo(k)
k = k+1
end

消息标识：E_CONST_CH

**** ERR #1009:修改实际“soo”中的常量“m” 参见："E_CONST_CH.f" line #11

external soo
call too(soo)
end
subroutine soo(k)
k = k+1
end
subroutine too(s)
parameter (m = 5)
call s(m)
C                     ^
C**** ERR  #1009:constant "m" is modified in actual "soo"
C                 参见："E_CONST_CH.f" line #4
end

消息标识：E_CONST_CH_F

Error:检查有效的串行许可时出现致命错误。

此消息由许可证库产生。

消息标识：LICENSE_ERROR

自

i2       int*4  from module d058
         DU     16:D     18:U

消息标识：XREF_WRD_FROM

**** WAR #1082:名称从未引用等价变量“k”

program locvar7
equivalence (i,k)
                      ^
**** WAR  #1082:equivalent variable "k" never referenced by the name
i = -1
print *, i
end

消息标识：W_NOUSED_EQU

**** WAR #1083:使用变量“i”的值可能是错误的，因为它可能被设置为整型和标签参见："f.f" line #2 参见："f.f" line #3

integer i, lbl
read *, i
if (i .eq.0) 将 10 赋值给 i
lbl = i
            ^
**** WAR  #1083:变量“i”的值用法可能错误，因为它可能
be set as integer and as label
参见："f.f" line #2
参见："f.f" line #3
10   print *, lbl
end

消息标识：W_INT_LBL

**** WAR #1084:使用变量“i”的值可能是错误的，因为它可能被设置为整型和格式参见："f.f" line #2 参见："f.f" line #3

integer i, lbl
read *, i
if (i .eq.0) 将 10 赋值给 i
lbl = i
            ^
**** WAR  #1084:变量“i”的值用法可能错误，因为它可能
be set as integer and as format
参见："f.f" line #2
参见："f.f" line #3
write(*, fmt=lbl) 10
10   format(i)
end

消息标识：W_INT_FMT

**** WAR #1085:使用变量“i”的值可能是错误的，因为它可能被设置为标签和格式参见："f.f" line #2 参见："f.f" line #4

integer i, j, lbl
assign 20 to i
read *, j
if (j .eq.0) 将 10 赋值给 i
lbl = i
            ^
**** WAR  #1085:变量“i”的值用法可能错误，因为它可能
be set as label and as format
参见："f.f" line #2
参见："f.f" line #4
write(*, fmt=lbl) 10
10   format(i)
20   print *, lbl
end

消息标识：W_LBL_FMT

**** WAR #1090:可能“s”中实际参数大小比伪参数小参见："f.f" line #8

program err
integer j(6), k
read *, k
if (k .lt. 4) k = 3
j = 1       
call s(j(1:k))
              ^
**** WAR  #1090:possibly size of actual argument less than size of dummy in "s"
参见："f.f" line #8
end
subroutine s(j)
integer j(4)
print *, j
end

消息标识：E_ARRAY_SIZE_P

**** WAR #1091:可能实际参数的大小比实际“s”的伪参数小参见："f.f" line #7

program err
integer j(6)
external s
j = 1       
call ss(s,j)
end	
subroutine s(j)
integer j(4)
print *, j
end
subroutine ss(foo,j)
external foo
integer j(6), k
read *, k
if (k .lt. 4) k = 3
call foo(j(1:k))
                  ^
**** WAR  #1091:possibly size of actual argument less than size of dummy for
actual "s"
参见："f.f" line #7
end

消息标识：E_ARRAY_SIZE_F_P

**** WAR #1092:不用检查是否存在就可以使用可选伪参数“j”

call s(k)
print *,k
end
subroutine s(i,j)
integer, optional ::j
i = j
          ^
**** WAR  #1092:optional dummy argument "j" is used without checking of its
presence
end

消息标识：W_OPT_NOT_CHECK