Return to fm060.f CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / f77 / testf77 / tests

Annotation of 43BSDTahoe/usr.bin/f77/testf77/tests/fm060.f, revision 1.1

1.1     ! root        1: c     comment section
        !             2: c
        !             3: c     fm060
        !             4: c
        !             5: c         this routine contains basic arithmetic if statement tests for
        !             6: c     the format
        !             7: c
        !             8: c                   if (e) k1,k2,k3
        !             9: c
        !            10: c     where e is a simple real expression of the form
        !            11: c
        !            12: c            real variable
        !            13: c            real variable - real constant
        !            14: c            real variable + real constant
        !            15: c
        !            16: c     and k1, k2 and k3 are statement labels.
        !            17: c
        !            18: c         this routine also tests arithmetic assignment statements of
        !            19: c     the form
        !            20: c                  real variable = real constant
        !            21: c                  real variable = real variable
        !            22: c                  real variable = -real variable
        !            23: c
        !            24: c     the real constants and real variables contain both positive and
        !            25: c     negative values.
        !            26: c
        !            27: c         a real datum is a processor approximation to the value of a
        !            28: c     real number.  it may assume positive, negative and zero values.
        !            29: c
        !            30: c         a basic real constant is written as an integer part, a decimal
        !            31: c     point, and a decimal fraction part in that order.  both the
        !            32: c     integer part and the decimal part are strings of digits; either
        !            33: c     one of these strings may be empty but not both.  the constant is
        !            34: c     an approximation to the digit string interpreted as a decimal
        !            35: c     numeral.
        !            36: c
        !            37: c         a decimal exponent is written as the letter e, followed by an
        !            38: c     optionally signed integer constant.
        !            39: c
        !            40: c         a real constant is indicated by writing a basic real constant,
        !            41: c     a basic real constant followed by a decimal exponent, or an
        !            42: c     integer constant followed by a decimal exponent.
        !            43: c
        !            44: c      references
        !            45: c        american national standard programming language fortran,
        !            46: c              x3.9-1978
        !            47: c
        !            48: c        section 4.4, real type
        !            49: c        section 4.4.1, real constant
        !            50: c        section 6.1, arithmetic expressions
        !            51: c        section 10.1, arithmetic assignment statement
        !            52: c        section 11.4, arithmetic if statement
        !            53: c
        !            54: c      **********************************************************
        !            55: c
        !            56: c         a compiler validation system for the fortran language
        !            57: c     based on specifications as defined in american national standard
        !            58: c     programming language fortran x3.9-1978, has been developed by the
        !            59: c     federal cobol compiler testing service.  the fortran compiler
        !            60: c     validation system (fcvs) consists of audit routines, their related
        !            61: c     data, and an executive system.  each audit routine is a fortran
        !            62: c     program, subprogram or function which includes tests of specific
        !            63: c     language elements and supporting procedures indicating the result
        !            64: c     of executing these tests.
        !            65: c
        !            66: c         this particular program/subprogram/function contains features
        !            67: c     found only in the subset as defined in x3.9-1978.
        !            68: c
        !            69: c         suggestions and comments should be forwarded to -
        !            70: c
        !            71: c                  department of the navy
        !            72: c                  federal cobol compiler testing service
        !            73: c                  washington, d.c.  20376
        !            74: c
        !            75: c      **********************************************************
        !            76: c
        !            77: c
        !            78: c
        !            79: c     initialization section
        !            80: c
        !            81: c     initialize constants
        !            82: c      **************
        !            83: c     i01 contains the logical unit number for the card reader.
        !            84:       i01 = 5
        !            85: c     i02 contains the logical unit number for the printer.
        !            86:       i02 = 6
        !            87: c     system environment section
        !            88: c
        !            89: cx010    this card is replaced by contents of fexec x-010 control card.
        !            90: c     the cx010 card is for overriding the program default i01 = 5
        !            91: c     (unit number for card reader).
        !            92: cx011    this card is replaced by contents of fexec x-011 control card.
        !            93: c     the cx011 card is for systems which require additional
        !            94: c     fortran statements for files associated with cx010 above.
        !            95: c
        !            96: cx020    this card is replaced by contents of fexec x-020 control card.
        !            97: c     the cx020 card is for overriding the program default i02 = 6
        !            98: c     (unit number for printer).
        !            99: cx021    this card is replaced by contents of fexec x-021 control card.
        !           100: c     the cx021 card is for systems which require additional
        !           101: c     fortran statements for files associated with cx020 above.
        !           102: c
        !           103:       ivpass=0
        !           104:       ivfail=0
        !           105:       ivdele=0
        !           106:       iczero=0
        !           107: c
        !           108: c     write page headers
        !           109:       write (i02,90000)
        !           110:       write (i02,90001)
        !           111:       write (i02,90002)
        !           112:       write (i02, 90002)
        !           113:       write (i02,90003)
        !           114:       write (i02,90002)
        !           115:       write (i02,90004)
        !           116:       write (i02,90002)
        !           117:       write (i02,90011)
        !           118:       write (i02,90002)
        !           119:       write (i02,90002)
        !           120:       write (i02,90005)
        !           121:       write (i02,90006)
        !           122:       write (i02,90002)
        !           123: c
        !           124: c     test section
        !           125: c
        !           126: c         arithmetic if statement
        !           127: c
        !           128: c     test 1 through test 3 contain basic arithmetic if statement tests
        !           129: c     with a real variable as arithmetic expression.
        !           130: c
        !           131:    11 continue
        !           132:       ivtnum =   1
        !           133: c
        !           134: c      ****  test   1  ****
        !           135: c         test 001  - less than zero branch expected
        !           136: c
        !           137:       if (iczero) 30010,   10, 30010
        !           138:    10 continue
        !           139:       rvcomp = 0.0
        !           140:       rvon01 = -1.0
        !           141:       if (rvon01)  12,40010, 40010
        !           142:    12 rvcomp = rvon01
        !           143:       go to 40010
        !           144: 30010 ivdele = ivdele + 1
        !           145:       write (i02,80003) ivtnum
        !           146:       if (iczero) 40010,   21, 40010
        !           147: 40010 if (rvcomp) 10010,20010,20010
        !           148: 10010 ivpass = ivpass + 1
        !           149:       write (i02,80001) ivtnum
        !           150:       go to   21
        !           151: 20010 ivfail = ivfail + 1
        !           152:       rvcorr = -1.0
        !           153:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           154:    21 continue
        !           155:       ivtnum =   2
        !           156: c
        !           157: c      ****  test   2  ****
        !           158: c         test 002  -  equal to zero branch expected
        !           159: c
        !           160:       if (iczero) 30020,   20, 30020
        !           161:    20 continue
        !           162:       rvcomp = 1.0
        !           163:       rvon01 = 0.0
        !           164:       if (rvon01) 40020,22,40020
        !           165:    22 rvcomp = rvon01
        !           166:       go to 40020
        !           167: 30020 ivdele = ivdele + 1
        !           168:       write (i02,80003) ivtnum
        !           169:       if (iczero) 40020,   31, 40020
        !           170: 40020 if (rvcomp)  20020,10020,20020
        !           171: 10020 ivpass = ivpass + 1
        !           172:       write (i02,80001) ivtnum
        !           173:       go to   31
        !           174: 20020 ivfail = ivfail + 1
        !           175:       rvcorr = 0.0
        !           176:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           177:    31 continue
        !           178:       ivtnum =   3
        !           179: c
        !           180: c      ****  test   3  ****
        !           181: c         test 003  -  greater than zero branch expected
        !           182: c
        !           183:       if (iczero) 30030,   30, 30030
        !           184:    30 continue
        !           185:       rvcomp = 0.0
        !           186:       rvon01 = 1.0
        !           187:       if (rvon01) 40030,40030,32
        !           188:    32 rvcomp = rvon01
        !           189:       go to 40030
        !           190: 30030 ivdele = ivdele + 1
        !           191:       write (i02,80003) ivtnum
        !           192:       if (iczero) 40030,   41, 40030
        !           193: 40030 if (rvcomp)  20030,20030,10030
        !           194: 10030 ivpass = ivpass + 1
        !           195:       write (i02,80001) ivtnum
        !           196:       go to   41
        !           197: 20030 ivfail = ivfail + 1
        !           198:       rvcorr = 1.0
        !           199:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           200:    41 continue
        !           201:       ivtnum =   4
        !           202: c
        !           203: c      ****  test   4  ****
        !           204: c     test 004  - basic if statements test
        !           205: c           these if statements are used in real variable test
        !           206: c           verification.  the arithmetic expressions are of the form
        !           207: c                   real variable - real constant
        !           208: c
        !           209:       if (iczero) 30040,   40, 30040
        !           210:    40 continue
        !           211:       rvcomp = 4.0
        !           212:       rvon01 = 1.0
        !           213:       if (rvon01 - .99995) 40040,42,42
        !           214:    42 if (rvon01 - 1.0005) 43,43,40040
        !           215:    43 rvcomp = 0.0
        !           216:       go to 40040
        !           217: 30040 ivdele = ivdele + 1
        !           218:       write (i02,80003) ivtnum
        !           219:       if (iczero) 40040,   51, 40040
        !           220: 40040 if (rvcomp) 20040,10040,20040
        !           221: 10040 ivpass = ivpass + 1
        !           222:       write (i02,80001) ivtnum
        !           223:       go to   51
        !           224: 20040 ivfail = ivfail + 1
        !           225:       rvcorr = 0.0
        !           226:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           227:    51 continue
        !           228:       ivtnum =   5
        !           229: c
        !           230: c      ****  test   5  ****
        !           231: c     test 005  -  basic if statements test
        !           232: c           these if statements are used in real variable test
        !           233: c           verification.  the arithmetic expressions are of the form
        !           234: c                   real variable + real constant
        !           235: c
        !           236:       if (iczero) 30050,   50, 30050
        !           237:    50 continue
        !           238:       rvcomp = -1.0
        !           239:       rvon01 = -1.0
        !           240:       if (rvon01 + 1.0005) 40050,52,52
        !           241:    52 if (rvon01 + .99995) 53,53,40050
        !           242:    53 rvcomp = 0.0
        !           243:       go to 40050
        !           244: 30050 ivdele = ivdele + 1
        !           245:       write (i02,80003) ivtnum
        !           246:       if (iczero) 40050,   61, 40050
        !           247: 40050 if (rvcomp) 20050,10050,20050
        !           248: 10050 ivpass = ivpass + 1
        !           249:       write (i02,80001) ivtnum
        !           250:       go to   61
        !           251: 20050 ivfail = ivfail + 1
        !           252:       rvcorr = 0.0
        !           253:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           254: c
        !           255: c        arithmetic assignment statement
        !           256: c
        !           257: c
        !           258: c     test 006 through test 025 contain arithmetic assignment
        !           259: c     statements of the form
        !           260: c              real variable = real constant
        !           261: c
        !           262: c          the three types of real constants are tested with positive
        !           263: c     and negative values for the constants, and positive and negative
        !           264: c     exponents.
        !           265: c
        !           266: c     test 006 through test 011 - constant is basic real constant
        !           267: c
        !           268:    61 continue
        !           269:       ivtnum =   6
        !           270: c
        !           271: c      ****  test   6  ****
        !           272: c
        !           273:       if (iczero) 30060,   60, 30060
        !           274:    60 continue
        !           275:       rvcomp = 2.0
        !           276:       go to 40060
        !           277: 30060 ivdele = ivdele + 1
        !           278:       write (i02,80003) ivtnum
        !           279:       if (iczero) 40060,   71, 40060
        !           280: 40060 if (rvcomp - 1.9995) 20060,10060,40061
        !           281: 40061 if (rvcomp - 2.0005) 10060,10060,20060
        !           282: 10060 ivpass = ivpass + 1
        !           283:       write (i02,80001) ivtnum
        !           284:       go to   71
        !           285: 20060 ivfail = ivfail + 1
        !           286:       rvcorr = 2.0
        !           287:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           288:    71 continue
        !           289:       ivtnum =   7
        !           290: c
        !           291: c      ****  test   7  ****
        !           292: c
        !           293:       if (iczero) 30070,   70, 30070
        !           294:    70 continue
        !           295:       rvcomp = 44.5
        !           296:       go to 40070
        !           297: 30070 ivdele = ivdele + 1
        !           298:       write (i02,80003) ivtnum
        !           299:       if (iczero) 40070,   81, 40070
        !           300: 40070 if (rvcomp - 44.495) 20070,10070,40071
        !           301: 40071 if (rvcomp - 45.505) 10070,10070,20070
        !           302: 10070 ivpass = ivpass + 1
        !           303:       write (i02,80001) ivtnum
        !           304:       go to   81
        !           305: 20070 ivfail = ivfail + 1
        !           306:       rvcorr = 44.5
        !           307:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           308:    81 continue
        !           309:       ivtnum =   8
        !           310: c
        !           311: c      ****  test   8  ****
        !           312: c
        !           313:       if (iczero) 30080,   80, 30080
        !           314:    80 continue
        !           315:       rvcomp = -2.0
        !           316:       go to 40080
        !           317: 30080 ivdele = ivdele + 1
        !           318:       write (i02,80003) ivtnum
        !           319:       if (iczero) 40080,   91, 40080
        !           320: 40080 if (rvcomp + 2.0005) 20080,10080,40081
        !           321: 40081 if (rvcomp + 1.9995) 10080,10080,20080
        !           322: 10080 ivpass = ivpass + 1
        !           323:       write (i02,80001) ivtnum
        !           324:       go to   91
        !           325: 20080 ivfail = ivfail + 1
        !           326:       rvcorr = -2.0
        !           327:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           328:    91 continue
        !           329:       ivtnum =   9
        !           330: c
        !           331: c      ****  test   9  ****
        !           332: c
        !           333:       if (iczero) 30090,   90, 30090
        !           334:    90 continue
        !           335:       rvcomp = 65001.
        !           336:       go to 40090
        !           337: 30090 ivdele = ivdele + 1
        !           338:       write (i02,80003) ivtnum
        !           339:       if (iczero) 40090,  101, 40090
        !           340: 40090 if (rvcomp - 64996.) 20090,10090,40091
        !           341: 40091 if (rvcomp - 65006.) 10090,10090,20090
        !           342: 10090 ivpass = ivpass + 1
        !           343:       write (i02,80001) ivtnum
        !           344:       go to  101
        !           345: 20090 ivfail = ivfail + 1
        !           346:       rvcorr = 65001.
        !           347:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           348:   101 continue
        !           349:       ivtnum =  10
        !           350: c
        !           351: c      ****  test  10  ****
        !           352: c
        !           353:       if (iczero) 30100,  100, 30100
        !           354:   100 continue
        !           355:       rvcomp = .65001
        !           356:       go to 40100
        !           357: 30100 ivdele = ivdele + 1
        !           358:       write (i02,80003) ivtnum
        !           359:       if (iczero) 40100,  111, 40100
        !           360: 40100 if (rvcomp - .64996) 20100,10100,40101
        !           361: 40101 if (rvcomp - .65006) 10100,10100,20100
        !           362: 10100 ivpass = ivpass + 1
        !           363:       write (i02,80001) ivtnum
        !           364:       go to  111
        !           365: 20100 ivfail = ivfail + 1
        !           366:       rvcorr = .65001
        !           367:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           368:   111 continue
        !           369:       ivtnum =  11
        !           370: c
        !           371: c      ****  test  11  ****
        !           372: c
        !           373:       if (iczero) 30110,  110, 30110
        !           374:   110 continue
        !           375:       rvcomp = -.33333
        !           376:       go to 40110
        !           377: 30110 ivdele = ivdele + 1
        !           378:       write (i02,80003) ivtnum
        !           379:       if (iczero) 40110,  121, 40110
        !           380: 40110 if (rvcomp + .33338) 20110,10110,40111
        !           381: 40111 if (rvcomp + .33328) 10110,10110,20110
        !           382: 10110 ivpass = ivpass + 1
        !           383:       write (i02,80001) ivtnum
        !           384:       go to  121
        !           385: 20110 ivfail = ivfail + 1
        !           386:       rvcorr = -.33333
        !           387:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           388: c
        !           389: c     test 012 through test 19 - real constant is basic real constant
        !           390: c                              - followed by decimal exponent
        !           391: c
        !           392:   121 continue
        !           393:       ivtnum =  12
        !           394: c
        !           395: c      ****  test  12  ****
        !           396: c
        !           397:       if (iczero) 30120,  120, 30120
        !           398:   120 continue
        !           399:       rvcomp = .2e+1
        !           400:       go to 40120
        !           401: 30120 ivdele = ivdele + 1
        !           402:       write (i02,80003) ivtnum
        !           403:       if (iczero) 40120,  131, 40120
        !           404: 40120 if (rvcomp - 1.9995) 20120,10120,40121
        !           405: 40121 if (rvcomp - 2.0005) 10120,10120,20120
        !           406: 10120 ivpass = ivpass + 1
        !           407:       write (i02,80001) ivtnum
        !           408:       go to  131
        !           409: 20120 ivfail = ivfail + 1
        !           410:       rvcorr = 2.0
        !           411:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           412:   131 continue
        !           413:       ivtnum =  13
        !           414: c
        !           415: c      ****  test  13  ****
        !           416: c
        !           417:       if (iczero) 30130,  130, 30130
        !           418:   130 continue
        !           419:       rvcomp = 2.0e+0
        !           420:       go to 40130
        !           421: 30130 ivdele = ivdele + 1
        !           422:       write (i02,80003) ivtnum
        !           423:       if (iczero) 40130,  141, 40130
        !           424: 40130 if (rvcomp - 1.9995) 20130,10130,40131
        !           425: 40131 if (rvcomp - 2.0005) 10130,10130,20130
        !           426: 10130 ivpass = ivpass + 1
        !           427:       write (i02,80001) ivtnum
        !           428:       go to  141
        !           429: 20130 ivfail = ivfail + 1
        !           430:       rvcorr = 2.0
        !           431:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           432:   141 continue
        !           433:       ivtnum =  14
        !           434: c
        !           435: c      ****  test  14  ****
        !           436: c
        !           437:       if (iczero) 30140,  140, 30140
        !           438:   140 continue
        !           439:       rvcomp = 445.0e-01
        !           440:       go to 40140
        !           441: 30140 ivdele = ivdele + 1
        !           442:       write (i02,80003) ivtnum
        !           443:       if (iczero) 40140,  151, 40140
        !           444: 40140 if (rvcomp - 44.495) 20140,10140,40141
        !           445: 40141 if (rvcomp - 44.505) 10140,10140,20140
        !           446: 10140 ivpass = ivpass + 1
        !           447:       write (i02,80001) ivtnum
        !           448:       go to  151
        !           449: 20140 ivfail = ivfail + 1
        !           450:       rvcorr = 44.5
        !           451:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           452:   151 continue
        !           453:       ivtnum =  15
        !           454: c
        !           455: c      ****  test  15  ****
        !           456: c
        !           457:       if (iczero) 30150,  150, 30150
        !           458:   150 continue
        !           459:       rvcomp = 4.450e1
        !           460:       go to 40150
        !           461: 30150 ivdele = ivdele + 1
        !           462:       write (i02,80003) ivtnum
        !           463:       if (iczero) 40150,  161, 40150
        !           464: 40150 if (rvcomp - 44.495) 20150,10150,40151
        !           465: 40151 if (rvcomp - 44.505) 10150,10150,20150
        !           466: 10150 ivpass = ivpass + 1
        !           467:       write (i02,80001) ivtnum
        !           468:       go to  161
        !           469: 20150 ivfail = ivfail + 1
        !           470:       rvcorr = 44.5
        !           471:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           472:   161 continue
        !           473:       ivtnum =  16
        !           474: c
        !           475: c      ****  test  16  ****
        !           476: c
        !           477:       if (iczero) 30160,  160, 30160
        !           478:   160 continue
        !           479:       rvcomp = 2.e+15
        !           480:       go to 40160
        !           481: 30160 ivdele = ivdele + 1
        !           482:       write (i02,80003) ivtnum
        !           483:       if (iczero) 40160,  171, 40160
        !           484: 40160 if (rvcomp - 1.9995e+15) 20160,10160,40161
        !           485: 40161 if (rvcomp - 2.0005e+15) 10160,10160,20160
        !           486: 10160 ivpass = ivpass + 1
        !           487:       write (i02,80001) ivtnum
        !           488:       go to  171
        !           489: 20160 ivfail = ivfail + 1
        !           490:       rvcorr = 2.0e+15
        !           491:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           492:   171 continue
        !           493:       ivtnum =  17
        !           494: c
        !           495: c      ****  test  17  ****
        !           496: c
        !           497:       if (iczero) 30170,  170, 30170
        !           498:   170 continue
        !           499:       rvcomp = 44.5e-15
        !           500:       go to 40170
        !           501: 30170 ivdele = ivdele + 1
        !           502:       write (i02,80003) ivtnum
        !           503:       if (iczero) 40170,  181, 40170
        !           504: 40170 if (rvcomp - 44.495e-15) 20170,10170,40171
        !           505: 40171 if (rvcomp - 44.505e-15) 10170,10170,20170
        !           506: 10170 ivpass = ivpass + 1
        !           507:       write (i02,80001) ivtnum
        !           508:       go to  181
        !           509: 20170 ivfail = ivfail + 1
        !           510:       rvcorr = 44.5e-15
        !           511:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           512:   181 continue
        !           513:       ivtnum =  18
        !           514: c
        !           515: c      ****  test  18  ****
        !           516: c
        !           517:       if (iczero) 30180,  180, 30180
        !           518:   180 continue
        !           519:       rvcomp = -4.45e0
        !           520:       go to 40180
        !           521: 30180 ivdele = ivdele + 1
        !           522:       write (i02,80003) ivtnum
        !           523:       if (iczero) 40180,  191, 40180
        !           524: 40180 if (rvcomp + 4.4505) 20180,10180,40181
        !           525: 40181 if (rvcomp + 4.4495) 10180,10180,20180
        !           526: 10180 ivpass = ivpass + 1
        !           527:       write (i02,80001) ivtnum
        !           528:       go to  191
        !           529: 20180 ivfail = ivfail + 1
        !           530:       rvcorr = -4.45
        !           531:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           532:   191 continue
        !           533:       ivtnum =  19
        !           534: c
        !           535: c      ****  test  19  ****
        !           536: c
        !           537:       if (iczero) 30190,  190, 30190
        !           538:   190 continue
        !           539:       rvcomp = -6511.8e-0
        !           540:       go to 40190
        !           541: 30190 ivdele = ivdele + 1
        !           542:       write (i02,80003) ivtnum
        !           543:       if (iczero) 40190,  201, 40190
        !           544: 40190 if (rvcomp + 6512.3) 20190,10190,40191
        !           545: 40191 if (rvcomp + 6511.3) 10190,10190,20190
        !           546: 10190 ivpass = ivpass + 1
        !           547:       write (i02,80001) ivtnum
        !           548:       go to  201
        !           549: 20190 ivfail = ivfail + 1
        !           550:       rvcorr = -6511.8
        !           551:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           552: c
        !           553: c     test 020 through test 025 - integer constant followed
        !           554: c                               - by a decimal exponent
        !           555: c
        !           556:   201 continue
        !           557:       ivtnum =  20
        !           558: c
        !           559: c      ****  test  20  ****
        !           560: c
        !           561:       if (iczero) 30200,  200, 30200
        !           562:   200 continue
        !           563:       rvcomp = 2e+1
        !           564:       go to 40200
        !           565: 30200 ivdele = ivdele + 1
        !           566:       write (i02,80003) ivtnum
        !           567:       if (iczero) 40200,  211, 40200
        !           568: 40200 if (rvcomp - 19.995) 20200,10200,40201
        !           569: 40201 if (rvcomp - 20.005) 10200,10200,20200
        !           570: 10200 ivpass = ivpass + 1
        !           571:       write (i02,80001) ivtnum
        !           572:       go to  211
        !           573: 20200 ivfail = ivfail + 1
        !           574:       rvcorr = 20.0
        !           575:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           576:   211 continue
        !           577:       ivtnum =  21
        !           578: c
        !           579: c      ****  test  21  ****
        !           580: c
        !           581:       if (iczero) 30210,  210, 30210
        !           582:   210 continue
        !           583:       rvcomp = 445e-02
        !           584:       go to 40210
        !           585: 30210 ivdele = ivdele + 1
        !           586:       write (i02,80003) ivtnum
        !           587:       if (iczero) 40210,  221, 40210
        !           588: 40210 if (rvcomp - 4.4495) 20210,10210,40211
        !           589: 40211 if (rvcomp - 4.4505) 10210,10210,20210
        !           590: 10210 ivpass = ivpass + 1
        !           591:       write (i02,80001) ivtnum
        !           592:       go to  221
        !           593: 20210 ivfail = ivfail + 1
        !           594:       rvcorr = 4.45
        !           595:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           596:   221 continue
        !           597:       ivtnum =  22
        !           598: c
        !           599: c      ****  test  22  ****
        !           600: c
        !           601:       if (iczero) 30220,  220, 30220
        !           602:   220 continue
        !           603:       rvcomp = 7e3
        !           604:       go to 40220
        !           605: 30220 ivdele = ivdele + 1
        !           606:       write (i02,80003) ivtnum
        !           607:       if (iczero) 40220,  231, 40220
        !           608: 40220 if (rvcomp - 6999.0) 20220,10220,40221
        !           609: 40221 if (rvcomp - 7001.0) 10220,10220,20220
        !           610: 10220 ivpass = ivpass + 1
        !           611:       write (i02,80001) ivtnum
        !           612:       go to  231
        !           613: 20220 ivfail = ivfail + 1
        !           614:       rvcorr = 7000.0
        !           615:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           616:   231 continue
        !           617:       ivtnum =  23
        !           618: c
        !           619: c      ****  test  23  ****
        !           620: c
        !           621:       if (iczero) 30230,  230, 30230
        !           622:   230 continue
        !           623:       rvcomp = 214 e 0
        !           624:       go to 40230
        !           625: 30230 ivdele = ivdele + 1
        !           626:       write (i02,80003) ivtnum
        !           627:       if (iczero) 40230,  241, 40230
        !           628: 40230 if (rvcomp - 213.95) 20230,10230,40231
        !           629: 40231 if (rvcomp - 214.05) 10230,10230,20230
        !           630: 10230 ivpass = ivpass + 1
        !           631:       write (i02,80001) ivtnum
        !           632:       go to  241
        !           633: 20230 ivfail = ivfail + 1
        !           634:       rvcorr = 214.0
        !           635:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           636:   241 continue
        !           637:       ivtnum =  24
        !           638: c
        !           639: c      ****  test  24  ****
        !           640: c
        !           641:       if (iczero) 30240,  240, 30240
        !           642:   240 continue
        !           643:       rvcomp = -3276e+6
        !           644:       go to 40240
        !           645: 30240 ivdele = ivdele + 1
        !           646:       write (i02,80003) ivtnum
        !           647:       if (iczero) 40240,  251, 40240
        !           648: 40240 if (rvcomp + .32765e+10) 20240,10240,40241
        !           649: 40241 if (rvcomp + .32755e+10) 10240,10240,20240
        !           650: 10240 ivpass = ivpass + 1
        !           651:       write (i02,80001) ivtnum
        !           652:       go to  251
        !           653: 20240 ivfail = ivfail + 1
        !           654:       rvcorr = -3276e+6
        !           655:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           656:   251 continue
        !           657:       ivtnum =  25
        !           658: c
        !           659: c      ****  test  25  ****
        !           660: c
        !           661:       if (iczero) 30250,  250, 30250
        !           662:   250 continue
        !           663:       rvcomp = -7e3
        !           664:       go to 40250
        !           665: 30250 ivdele = ivdele + 1
        !           666:       write (i02,80003) ivtnum
        !           667:       if (iczero) 40250,  261, 40250
        !           668: 40250 if (rvcomp + 7001.)  20250,10250,40251
        !           669: 40251 if (rvcomp + 6999.) 10250,10250,20250
        !           670: 10250 ivpass = ivpass + 1
        !           671:       write (i02,80001) ivtnum
        !           672:       go to  261
        !           673: 20250 ivfail = ivfail + 1
        !           674:       rvcorr = -7000.0
        !           675:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           676: c
        !           677: c     test 026 through test 028 contain arithmetic assignment statement
        !           678: c     of the form            real variable = real variable
        !           679: c
        !           680:   261 continue
        !           681:       ivtnum =  26
        !           682: c
        !           683: c      ****  test  26  ****
        !           684: c
        !           685:       if (iczero) 30260,  260, 30260
        !           686:   260 continue
        !           687:       rvon01 = .2e+1
        !           688:       rvcomp = rvon01
        !           689:       go to 40260
        !           690: 30260 ivdele = ivdele + 1
        !           691:       write (i02,80003) ivtnum
        !           692:       if (iczero) 40260,  271, 40260
        !           693: 40260 if (rvcomp - 1.9995) 20260,10260,40261
        !           694: 40261 if (rvcomp - 2.0005) 10260,10260,20260
        !           695: 10260 ivpass = ivpass + 1
        !           696:       write (i02,80001) ivtnum
        !           697:       go to  271
        !           698: 20260 ivfail = ivfail + 1
        !           699:       rvcorr = 20.0
        !           700:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           701:   271 continue
        !           702:       ivtnum =  27
        !           703: c
        !           704: c      ****  test  27  ****
        !           705: c
        !           706:       if (iczero) 30270,  270, 30270
        !           707:   270 continue
        !           708:       rvon01 = -445.e-01
        !           709:       rvcomp = rvon01
        !           710:       go to 40270
        !           711: 30270 ivdele = ivdele + 1
        !           712:       write (i02,80003) ivtnum
        !           713:       if (iczero) 40270,  281, 40270
        !           714: 40270 if (rvcomp + 44.505) 20270,10270,40271
        !           715: 40271 if (rvcomp + 44.495) 10270,10270,20270
        !           716: 10270 ivpass = ivpass + 1
        !           717:       write (i02,80001) ivtnum
        !           718:       go to  281
        !           719: 20270 ivfail = ivfail + 1
        !           720:       rvcorr = -44.5
        !           721:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           722:   281 continue
        !           723:       ivtnum =  28
        !           724: c
        !           725: c      ****  test  28  ****
        !           726: c
        !           727:       if (iczero) 30280,  280, 30280
        !           728:   280 continue
        !           729:       rvon01 = 7e3
        !           730:       rvcomp = rvon01
        !           731:       go to 40280
        !           732: 30280 ivdele = ivdele + 1
        !           733:       write (i02,80003) ivtnum
        !           734:       if (iczero) 40280,  291, 40280
        !           735: 40280 if (rvcomp - 6999.0) 20280,10280,40281
        !           736: 40281 if (rvcomp-7001.0) 10280,10280,20280
        !           737: 10280 ivpass = ivpass + 1
        !           738:       write (i02,80001) ivtnum
        !           739:       go to  291
        !           740: 20280 ivfail = ivfail + 1
        !           741:       rvcorr = 7000.0
        !           742: c
        !           743: c     test 029 through test 031 contain arithmetic assignment statement
        !           744: c     of the form            real variable = - real variable
        !           745: c
        !           746:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           747:   291 continue
        !           748:       ivtnum =  29
        !           749: c
        !           750: c      ****  test  29  ****
        !           751: c
        !           752:       if (iczero) 30290,  290, 30290
        !           753:   290 continue
        !           754:       rvon01 = .2e+1
        !           755:       rvcomp = -rvon01
        !           756:       go to 40290
        !           757: 30290 ivdele = ivdele + 1
        !           758:       write (i02,80003) ivtnum
        !           759:       if (iczero) 40290,  301, 40290
        !           760: 40290 if (rvcomp + 2.0005) 20290,10290,40291
        !           761: 40291 if (rvcomp + 1.9995) 10290,10290,20290
        !           762: 10290 ivpass = ivpass + 1
        !           763:       write (i02,80001) ivtnum
        !           764:       go to  301
        !           765: 20290 ivfail = ivfail + 1
        !           766:       rvcorr = -2.0
        !           767:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           768:   301 continue
        !           769:       ivtnum =  30
        !           770: c
        !           771: c      ****  test  30  ****
        !           772: c
        !           773:       if (iczero) 30300,  300, 30300
        !           774:   300 continue
        !           775:       rvon01 = -445.e-01
        !           776:       rvcomp = -rvon01
        !           777:       go to 40300
        !           778: 30300 ivdele = ivdele + 1
        !           779:       write (i02,80003) ivtnum
        !           780:       if (iczero) 40300,  311, 40300
        !           781: 40300 if (rvcomp - 44.495) 20300,10300,40301
        !           782: 40301 if (rvcomp - 44.505) 10300,10300,20300
        !           783: 10300 ivpass = ivpass + 1
        !           784:       write (i02,80001) ivtnum
        !           785:       go to  311
        !           786: 20300 ivfail = ivfail + 1
        !           787:       rvcorr = 44.5
        !           788:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           789:   311 continue
        !           790:       ivtnum =  31
        !           791: c
        !           792: c      ****  test  31  ****
        !           793: c
        !           794:       if (iczero) 30310,  310, 30310
        !           795:   310 continue
        !           796:       rvon01 = -.44559e1
        !           797:       rvcomp = -rvon01
        !           798:       go to 40310
        !           799: 30310 ivdele = ivdele + 1
        !           800:       write (i02,80003) ivtnum
        !           801:       if (iczero) 40310,  321, 40310
        !           802: 40310 if (rvcomp - 4.4554) 20310,10310,40311
        !           803: 40311 if (rvcomp - 4.4564) 10310,10310,20310
        !           804: 10310 ivpass = ivpass + 1
        !           805:       write (i02,80001) ivtnum
        !           806:       go to  321
        !           807: 20310 ivfail = ivfail + 1
        !           808:       rvcorr = 4.4559
        !           809:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           810: c      ****    end of tests    ****
        !           811:   321 continue
        !           812: c
        !           813: c     write page footings and run summaries
        !           814: 99999 continue
        !           815:       write (i02,90002)
        !           816:       write (i02,90006)
        !           817:       write (i02,90002)
        !           818:       write (i02,90002)
        !           819:       write (i02,90007)
        !           820:       write (i02,90002)
        !           821:       write (i02,90008)  ivfail
        !           822:       write (i02,90009) ivpass
        !           823:       write (i02,90010) ivdele
        !           824: c
        !           825: c
        !           826: c     terminate routine execution
        !           827:       stop
        !           828: c
        !           829: c     format statements for page headers
        !           830: 90000 format (1h1)
        !           831: 90002 format (1h )
        !           832: 90001 format (1h ,10x,34hfortran compiler validation system)
        !           833: 90003 format (1h ,21x,11hversion 1.0)
        !           834: 90004 format (1h ,10x,38hfor official use only - copyright 1978)
        !           835: 90005 format (1h ,5x,4htest,5x,9hpass/fail, 5x,8hcomputed,8x,7hcorrect)
        !           836: 90006 format (1h ,5x,46h----------------------------------------------)
        !           837: 90011 format (1h ,18x,17hsubset level test)
        !           838: c
        !           839: c     format statements for run summaries
        !           840: 90008 format (1h ,15x,i5,19h errors encountered)
        !           841: 90009 format (1h ,15x,i5,13h tests passed)
        !           842: 90010 format (1h ,15x,i5,14h tests deleted)
        !           843: c
        !           844: c     format statements for test results
        !           845: 80001 format (1h ,4x,i5,7x,4hpass)
        !           846: 80002 format (1h ,4x,i5,7x,4hfail)
        !           847: 80003 format (1h ,4x,i5,7x,7hdeleted)
        !           848: 80004 format (1h ,4x,i5,7x,4hfail,10x,i6,9x,i6)
        !           849: 80005 format (1h ,4x,i5,7x,4hfail,4x,e12.5,3x,e12.5)
        !           850: c
        !           851: 90007 format (1h ,20x,20hend of program fm060)
        !           852:       end

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.