## 错误文件 *.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 上作为 integer*4 被引用，但在第 #14 行被 sa 设置为 integer*2

    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 上作为 integer*4 被引用，但在第 #14 行被 sa 设置为 integer*2

    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 上作为 integer*4 被引用，但在第 #1 行被 MAIN 设置为 integer*2

    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”作为 integer*2 被引用，但在第 #16 被 MAIN/sbb 设置为 integer*4

    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”作为 integer*2 被引用，但在第 #13 行被 MAIN/sbb 设置为 integer*4

    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”作为 integer*2 被引用，但在第 #2 行被设置为 integer*4

    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”作为 integer*2 被引用，但在第 #5 行被设置为 integer*4

    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