Return to fm061.f CVS log

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

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

1.1     ! root        1: c     comment section
        !             2: c
        !             3: c     fm061
        !             4: c
        !             5: c          this routine tests arithmetic assignment statements of the
        !             6: c     form
        !             7: c                   integer variable = real constant
        !             8: c                   integer variable = real variable
        !             9: c                   real variable = integer variable
        !            10: c                   real variable = integer constant
        !            11: c
        !            12: c     the constants and variables contain both positive and negative
        !            13: c     values.
        !            14: c
        !            15: c           a real datum is a processor approximation to the value of a
        !            16: c     real number.  it may assume positive, negative and zero values.
        !            17: c
        !            18: c          a basic real constant is written as an integer part, a
        !            19: c     decimal point, and a decimal fraction part in that order.  both
        !            20: c     the integer part and the decimal part are strings of digits;
        !            21: c     either one of these strings may be empty but not both.  the
        !            22: c     constant is an approximation to the digit string interpreted as a
        !            23: c     decimal numeral.
        !            24: c
        !            25: c         a decimal exponent is written as the letter e, followed by an
        !            26: c     optionally signed integer constant.
        !            27: c
        !            28: c         a real constant is indicated by writing a basic real constant,
        !            29: c     a basic real constant followed by a decimal exponent, or an
        !            30: c     integer constant followed by a decimal exponent.
        !            31: c
        !            32: c      references
        !            33: c        american national standard programming language fortran,
        !            34: c              x3.9-1978
        !            35: c
        !            36: c        section 4.4, real type
        !            37: c        section 4.4.1, real constant
        !            38: c        section 6.1, arithmetic expressions
        !            39: c        section 6.6, evaluation of expressions
        !            40: c        section 10.1, arithmetic assignment statement
        !            41: c        section 11.4, arithmetic if statement
        !            42: c
        !            43: c      **********************************************************
        !            44: c
        !            45: c         a compiler validation system for the fortran language
        !            46: c     based on specifications as defined in american national standard
        !            47: c     programming language fortran x3.9-1978, has been developed by the
        !            48: c     federal cobol compiler testing service.  the fortran compiler
        !            49: c     validation system (fcvs) consists of audit routines, their related
        !            50: c     data, and an executive system.  each audit routine is a fortran
        !            51: c     program, subprogram or function which includes tests of specific
        !            52: c     language elements and supporting procedures indicating the result
        !            53: c     of executing these tests.
        !            54: c
        !            55: c         this particular program/subprogram/function contains features
        !            56: c     found only in the subset as defined in x3.9-1978.
        !            57: c
        !            58: c         suggestions and comments should be forwarded to -
        !            59: c
        !            60: c                  department of the navy
        !            61: c                  federal cobol compiler testing service
        !            62: c                  washington, d.c.  20376
        !            63: c
        !            64: c      **********************************************************
        !            65: c
        !            66: c
        !            67: c
        !            68: c     initialization section
        !            69: c
        !            70: c     initialize constants
        !            71: c      **************
        !            72: c     i01 contains the logical unit number for the card reader.
        !            73:       i01 = 5
        !            74: c     i02 contains the logical unit number for the printer.
        !            75:       i02 = 6
        !            76: c     system environment section
        !            77: c
        !            78: cx010    this card is replaced by contents of fexec x-010 control card.
        !            79: c     the cx010 card is for overriding the program default i01 = 5
        !            80: c     (unit number for card reader).
        !            81: cx011    this card is replaced by contents of fexec x-011 control card.
        !            82: c     the cx011 card is for systems which require additional
        !            83: c     fortran statements for files associated with cx010 above.
        !            84: c
        !            85: cx020    this card is replaced by contents of fexec x-020 control card.
        !            86: c     the cx020 card is for overriding the program default i02 = 6
        !            87: c     (unit number for printer).
        !            88: cx021    this card is replaced by contents of fexec x-021 control card.
        !            89: c     the cx021 card is for systems which require additional
        !            90: c     fortran statements for files associated with cx020 above.
        !            91: c
        !            92:       ivpass=0
        !            93:       ivfail=0
        !            94:       ivdele=0
        !            95:       iczero=0
        !            96: c
        !            97: c     write page headers
        !            98:       write (i02,90000)
        !            99:       write (i02,90001)
        !           100:       write (i02,90002)
        !           101:       write (i02, 90002)
        !           102:       write (i02,90003)
        !           103:       write (i02,90002)
        !           104:       write (i02,90004)
        !           105:       write (i02,90002)
        !           106:       write (i02,90011)
        !           107:       write (i02,90002)
        !           108:       write (i02,90002)
        !           109:       write (i02,90005)
        !           110:       write (i02,90006)
        !           111:       write (i02,90002)
        !           112: c
        !           113: c     test section
        !           114: c
        !           115: c     test 32 through test 42 contain arithmetic assignment
        !           116: c     statements of the form
        !           117: c
        !           118: c                   integer variable = real variable
        !           119: c
        !           120:       ivtnum =  32
        !           121: c
        !           122: c      ****  test  32  ****
        !           123: c
        !           124:       if (iczero) 30320,  320, 30320
        !           125:   320 continue
        !           126:       rvon01 = 44.5
        !           127:       ivcomp = rvon01
        !           128:       go to 40320
        !           129: 30320 ivdele = ivdele + 1
        !           130:       write (i02,80003) ivtnum
        !           131:       if (iczero) 40320,  331, 40320
        !           132: 40320 if (ivcomp - 44) 20320,10320,20320
        !           133: 10320 ivpass = ivpass + 1
        !           134:       write (i02,80001) ivtnum
        !           135:       go to  331
        !           136: 20320 ivfail = ivfail + 1
        !           137:       ivcorr = 44
        !           138:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           139:   331 continue
        !           140:       ivtnum =  33
        !           141: c
        !           142: c      ****  test  33  ****
        !           143: c
        !           144:       if (iczero) 30330,  330, 30330
        !           145:   330 continue
        !           146:       rvon01 = -2.0005
        !           147:       ivcomp = rvon01
        !           148:       go to 40330
        !           149: 30330 ivdele = ivdele + 1
        !           150:       write (i02,80003) ivtnum
        !           151:       if (iczero) 40330,  341, 40330
        !           152: 40330 if (ivcomp + 2) 20330,10330,20330
        !           153: 10330 ivpass = ivpass + 1
        !           154:       write (i02,80001) ivtnum
        !           155:       go to  341
        !           156: 20330 ivfail = ivfail + 1
        !           157:       ivcorr = -2
        !           158:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           159:   341 continue
        !           160:       ivtnum =  34
        !           161: c
        !           162: c      ****  test  34  ****
        !           163: c
        !           164:       if (iczero) 30340,  340, 30340
        !           165:   340 continue
        !           166:       rvon01 = .32767
        !           167:       ivcomp = rvon01
        !           168:       go to 40340
        !           169: 30340 ivdele = ivdele + 1
        !           170:       write (i02,80003) ivtnum
        !           171:       if (iczero) 40340,  351, 40340
        !           172: 40340 if (ivcomp) 20340,10340,20340
        !           173: 10340 ivpass = ivpass + 1
        !           174:       write (i02,80001) ivtnum
        !           175:       go to  351
        !           176: 20340 ivfail = ivfail + 1
        !           177:       ivcorr = 0
        !           178:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           179:   351 continue
        !           180:       ivtnum =  35
        !           181: c
        !           182: c      ****  test  35  ****
        !           183: c
        !           184:       if (iczero) 30350,  350, 30350
        !           185:   350 continue
        !           186:       rvon01 = 1.999
        !           187:       ivcomp = rvon01
        !           188:       go to 40350
        !           189: 30350 ivdele = ivdele + 1
        !           190:       write (i02,80003) ivtnum
        !           191:       if (iczero) 40350,  361, 40350
        !           192: 40350 if (ivcomp - 1) 20350,10350,20350
        !           193: 10350 ivpass = ivpass + 1
        !           194:       write (i02,80001) ivtnum
        !           195:       go to  361
        !           196: 20350 ivfail = ivfail + 1
        !           197:       ivcorr = 1
        !           198:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           199:   361 continue
        !           200:       ivtnum =  36
        !           201: c
        !           202: c      ****  test  36  ****
        !           203: c
        !           204:       if (iczero) 30360,  360, 30360
        !           205:   360 continue
        !           206:       rvon01 = .25e+1
        !           207:       ivcomp = rvon01
        !           208:       go to 40360
        !           209: 30360 ivdele = ivdele + 1
        !           210:       write (i02,80003) ivtnum
        !           211:       if (iczero) 40360,  371, 40360
        !           212: 40360 if (ivcomp - 2) 20360,10360,20360
        !           213: 10360 ivpass = ivpass + 1
        !           214:       write (i02,80001) ivtnum
        !           215:       go to  371
        !           216: 20360 ivfail = ivfail + 1
        !           217:       ivcorr = 2
        !           218:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           219:   371 continue
        !           220:       ivtnum =  37
        !           221: c
        !           222: c      ****  test  37  ****
        !           223: c
        !           224:       if (iczero) 30370,  370, 30370
        !           225:   370 continue
        !           226:       rvon01 = 445.0e-01
        !           227:       ivcomp = rvon01
        !           228:       go to 40370
        !           229: 30370 ivdele = ivdele + 1
        !           230:       write (i02,80003) ivtnum
        !           231:       if (iczero) 40370,  381, 40370
        !           232: 40370 if (ivcomp - 44) 20370,10370,20370
        !           233: 10370 ivpass = ivpass + 1
        !           234:       write (i02,80001) ivtnum
        !           235:       go to  381
        !           236: 20370 ivfail = ivfail + 1
        !           237:       ivcorr = 44
        !           238:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           239:   381 continue
        !           240:       ivtnum =  38
        !           241: c
        !           242: c      ****  test  38  ****
        !           243: c
        !           244:       if (iczero) 30380,  380, 30380
        !           245:   380 continue
        !           246:       rvon01 = -651.1e-0
        !           247:       ivcomp = rvon01
        !           248:       go to 40380
        !           249: 30380 ivdele = ivdele + 1
        !           250:       write (i02,80003) ivtnum
        !           251:       if (iczero) 40380,  391, 40380
        !           252: 40380 if (ivcomp + 651) 20380,10380,20380
        !           253: 10380 ivpass = ivpass + 1
        !           254:       write (i02,80001) ivtnum
        !           255:       go to  391
        !           256: 20380 ivfail = ivfail + 1
        !           257:       ivcorr = -651
        !           258:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           259:   391 continue
        !           260:       ivtnum =  39
        !           261: c
        !           262: c      ****  test  39  ****
        !           263: c
        !           264:       if (iczero) 30390,  390, 30390
        !           265:   390 continue
        !           266:       rvon01 = .3266e4
        !           267:       ivcomp = rvon01
        !           268:       go to 40390
        !           269: 30390 ivdele = ivdele + 1
        !           270:       write (i02,80003) ivtnum
        !           271:       if (iczero) 40390,  401, 40390
        !           272: 40390 if (ivcomp - 3266) 20390,10390,20390
        !           273: 10390 ivpass = ivpass + 1
        !           274:       write (i02,80001) ivtnum
        !           275:       go to  401
        !           276: 20390 ivfail = ivfail + 1
        !           277:       ivcorr = 3266
        !           278:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           279:   401 continue
        !           280:       ivtnum =  40
        !           281: c
        !           282: c      ****  test  40  ****
        !           283: c
        !           284:       if (iczero) 30400,  400, 30400
        !           285:   400 continue
        !           286:       rvon01 = 35.43e-01
        !           287:       ivcomp = rvon01
        !           288:       go to 40400
        !           289: 30400 ivdele = ivdele + 1
        !           290:       write (i02,80003) ivtnum
        !           291:       if (iczero) 40400,  411, 40400
        !           292: 40400 if (ivcomp - 3) 20400,10400,20400
        !           293: 10400 ivpass = ivpass + 1
        !           294:       write (i02,80001) ivtnum
        !           295:       go to  411
        !           296: 20400 ivfail = ivfail + 1
        !           297:       ivcorr = 3
        !           298:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           299:   411 continue
        !           300:       ivtnum =  41
        !           301: c
        !           302: c      ****  test  41  ****
        !           303: c
        !           304:       if (iczero) 30410,  410, 30410
        !           305:   410 continue
        !           306:       rvon01 = -7.001e2
        !           307:       ivcomp = rvon01
        !           308:       go to 40410
        !           309: 30410 ivdele = ivdele + 1
        !           310:       write (i02,80003) ivtnum
        !           311:       if (iczero) 40410,  421, 40410
        !           312: 40410 if (ivcomp + 700) 20410,10410,20410
        !           313: 10410 ivpass = ivpass + 1
        !           314:       write (i02,80001) ivtnum
        !           315:       go to  421
        !           316: 20410 ivfail = ivfail + 1
        !           317:       ivcorr = -700
        !           318:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           319:   421 continue
        !           320:       ivtnum =  42
        !           321: c
        !           322: c      ****  test  42  ****
        !           323: c
        !           324:       if (iczero) 30420,  420, 30420
        !           325:   420 continue
        !           326:       rvon01 = 4.45e-02
        !           327:       ivcomp = rvon01
        !           328:       go to 40420
        !           329: 30420 ivdele = ivdele + 1
        !           330:       write (i02,80003) ivtnum
        !           331:       if (iczero) 40420,  431, 40420
        !           332: 40420 if (ivcomp) 20420,10420,20420
        !           333: 10420 ivpass = ivpass + 1
        !           334:       write (i02,80001) ivtnum
        !           335:       go to  431
        !           336: 20420 ivfail = ivfail + 1
        !           337:       ivcorr = 0
        !           338:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           339: c     test 43 through test 48 contain arithmetic assignment
        !           340: c     statements of the form
        !           341: c
        !           342: c                   real variable = integer variable
        !           343: c
        !           344:   431 continue
        !           345:       ivtnum =  43
        !           346: c
        !           347: c      ****  test  43  ****
        !           348: c
        !           349:       if (iczero) 30430,  430, 30430
        !           350:   430 continue
        !           351:       ivon01 = 2
        !           352:       rvcomp = ivon01
        !           353:       go to 40430
        !           354: 30430 ivdele = ivdele + 1
        !           355:       write (i02,80003) ivtnum
        !           356:       if (iczero) 40430,  441, 40430
        !           357: 40430 if (rvcomp - 1.9995) 20430,10430,40431
        !           358: 40431 if (rvcomp - 2.0005) 10430,10430,20430
        !           359: 10430 ivpass = ivpass + 1
        !           360:       write (i02,80001) ivtnum
        !           361:       go to  441
        !           362: 20430 ivfail = ivfail + 1
        !           363:       rvcorr = 2.0000
        !           364:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           365:   441 continue
        !           366:       ivtnum =  44
        !           367: c
        !           368: c      ****  test  44  ****
        !           369: c
        !           370:       if (iczero) 30440,  440, 30440
        !           371:   440 continue
        !           372:       ivon01 = 25
        !           373:       rvcomp = ivon01
        !           374:       go to 40440
        !           375: 30440 ivdele = ivdele + 1
        !           376:       write (i02,80003) ivtnum
        !           377:       if (iczero) 40440,  451, 40440
        !           378: 40440 if (rvcomp - 24.995) 20440,10440,40441
        !           379: 40441 if (rvcomp - 25.005) 10440,10440,20440
        !           380: 10440 ivpass = ivpass + 1
        !           381:       write (i02,80001) ivtnum
        !           382:       go to  451
        !           383: 20440 ivfail = ivfail + 1
        !           384:       rvcorr = 25.000
        !           385:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           386:   451 continue
        !           387:       ivtnum =  45
        !           388: c
        !           389: c      ****  test  45  ****
        !           390: c
        !           391:       if (iczero) 30450,  450, 30450
        !           392:   450 continue
        !           393:       ivon01 = 357
        !           394:       rvcomp = ivon01
        !           395:       go to 40450
        !           396: 30450 ivdele = ivdele + 1
        !           397:       write (i02,80003) ivtnum
        !           398:       if (iczero) 40450,  461, 40450
        !           399: 40450 if (rvcomp - 356.95) 20450,10450,40451
        !           400: 40451 if (rvcomp - 357.05) 10450,10450,20450
        !           401: 10450 ivpass = ivpass + 1
        !           402:       write (i02,80001) ivtnum
        !           403:       go to  461
        !           404: 20450 ivfail = ivfail + 1
        !           405:       rvcorr = 357.00
        !           406:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           407:   461 continue
        !           408:       ivtnum =  46
        !           409: c
        !           410: c      ****  test  46  ****
        !           411: c
        !           412:       if (iczero) 30460,  460, 30460
        !           413:   460 continue
        !           414:       ivon01 = 4968
        !           415:       rvcomp = ivon01
        !           416:       go to 40460
        !           417: 30460 ivdele = ivdele + 1
        !           418:       write (i02,80003) ivtnum
        !           419:       if (iczero) 40460,  471, 40460
        !           420: 40460 if (rvcomp - 4967.5) 20460,10460,40461
        !           421: 40461 if (rvcomp - 4968.5) 10460,10460,20460
        !           422: 10460 ivpass = ivpass + 1
        !           423:       write (i02,80001) ivtnum
        !           424:       go to  471
        !           425: 20460 ivfail = ivfail + 1
        !           426:       rvcorr = 4968.0
        !           427:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           428:   471 continue
        !           429:       ivtnum =  47
        !           430: c
        !           431: c      ****  test  47  ****
        !           432: c
        !           433:       if (iczero) 30470,  470, 30470
        !           434:   470 continue
        !           435:       ivon01 = 32767
        !           436:       rvcomp = ivon01
        !           437:       go to 40470
        !           438: 30470 ivdele = ivdele + 1
        !           439:       write (i02,80003) ivtnum
        !           440:       if (iczero) 40470,  481, 40470
        !           441: 40470 if (rvcomp - 32762.) 20470,10470,40471
        !           442: 40471 if (rvcomp - 32772.) 10470,10470,20470
        !           443: 10470 ivpass = ivpass + 1
        !           444:       write (i02,80001) ivtnum
        !           445:       go to  481
        !           446: 20470 ivfail = ivfail + 1
        !           447:       rvcorr = 32767.
        !           448:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           449:   481 continue
        !           450:       ivtnum =  48
        !           451: c
        !           452: c      ****  test  48  ****
        !           453: c
        !           454:       if (iczero) 30480,  480, 30480
        !           455:   480 continue
        !           456:       ivon01 = -2
        !           457:       rvcomp = ivon01
        !           458:       go to 40480
        !           459: 30480 ivdele = ivdele + 1
        !           460:       write (i02,80003) ivtnum
        !           461:       if (iczero) 40480,  491, 40480
        !           462: 40480 if (rvcomp + 2.0005) 20480,10480,40481
        !           463: 40481 if (rvcomp + 1.9995) 10480,10480,20450
        !           464: 10480 ivpass = ivpass + 1
        !           465:       write (i02,80001) ivtnum
        !           466:       go to  491
        !           467: 20480 ivfail = ivfail + 1
        !           468:       rvcorr = -2.0000
        !           469:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           470: c
        !           471: c     test 49 through test 51 contain arithmetic assignment statements
        !           472: c     of the form
        !           473: c                   integer variable = real constant
        !           474: c     where constant is basic real constant
        !           475: c
        !           476:   491 continue
        !           477:       ivtnum =  49
        !           478: c
        !           479: c      ****  test  49  ****
        !           480: c
        !           481:       if (iczero) 30490,  490, 30490
        !           482:   490 continue
        !           483:       ivcomp = 44.5
        !           484:       go to 40490
        !           485: 30490 ivdele = ivdele + 1
        !           486:       write (i02,80003) ivtnum
        !           487:       if (iczero) 40490,  501, 40490
        !           488: 40490 if (ivcomp - 44) 20490,10490,20490
        !           489: 10490 ivpass = ivpass + 1
        !           490:       write (i02,80001) ivtnum
        !           491:       go to  501
        !           492: 20490 ivfail = ivfail + 1
        !           493:       ivcorr = 44
        !           494:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           495:   501 continue
        !           496:       ivtnum =  50
        !           497: c
        !           498: c      ****  test  50  ****
        !           499: c
        !           500:       if (iczero) 30500,  500, 30500
        !           501:   500 continue
        !           502:       ivcomp = 6500.1
        !           503:       go to 40500
        !           504: 30500 ivdele = ivdele + 1
        !           505:       write (i02,80003) ivtnum
        !           506:       if (iczero) 40500,  511, 40500
        !           507: 40500 if (ivcomp - 6500)  20500,10500,20500
        !           508: 10500 ivpass = ivpass + 1
        !           509:       write (i02,80001) ivtnum
        !           510:       go to  511
        !           511: 20500 ivfail = ivfail + 1
        !           512:       ivcorr = 6500
        !           513:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           514:   511 continue
        !           515:       ivtnum =  51
        !           516: c
        !           517: c      ****  test  51  ****
        !           518: c
        !           519:       if (iczero) 30510,  510, 30510
        !           520:   510 continue
        !           521:       ivcomp = -.33333
        !           522:       go to 40510
        !           523: 30510 ivdele = ivdele + 1
        !           524:       write (i02,80003) ivtnum
        !           525:       if (iczero) 40510,  521, 40510
        !           526: 40510 if (ivcomp) 20510,10510,20510
        !           527: 10510 ivpass = ivpass + 1
        !           528:       write (i02,80001) ivtnum
        !           529:       go to  521
        !           530: 20510 ivfail = ivfail + 1
        !           531:       ivcorr = 0
        !           532:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           533: c
        !           534: c     test 52 through test 55 contain arithmetic assignment statements
        !           535: c     of the form
        !           536: c                   integer variable = real constant
        !           537: c
        !           538: c     where constant is basic real constant followed by decimal exponent
        !           539: c
        !           540:   521 continue
        !           541:       ivtnum =  52
        !           542: c
        !           543: c      ****  test  52  ****
        !           544: c
        !           545:       if (iczero) 30520,  520, 30520
        !           546:   520 continue
        !           547:       ivcomp = .21e+1
        !           548:       go to 40520
        !           549: 30520 ivdele = ivdele + 1
        !           550:       write (i02,80003) ivtnum
        !           551:       if (iczero) 40520,  531, 40520
        !           552: 40520 if (ivcomp - 2) 20520,10520,20520
        !           553: 10520 ivpass = ivpass + 1
        !           554:       write (i02,80001) ivtnum
        !           555:       go to  531
        !           556: 20520 ivfail = ivfail + 1
        !           557:       ivcorr = 2
        !           558:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           559:   531 continue
        !           560:       ivtnum =  53
        !           561: c
        !           562: c      ****  test  53  ****
        !           563: c
        !           564:       if (iczero) 30530,  530, 30530
        !           565:   530 continue
        !           566:       ivcomp = 445.0e-01
        !           567:       go to 40530
        !           568: 30530 ivdele = ivdele + 1
        !           569:       write (i02,80003) ivtnum
        !           570:       if (iczero) 40530,  541, 40530
        !           571: 40530 if (ivcomp - 44) 20530,10530,20530
        !           572: 10530 ivpass = ivpass + 1
        !           573:       write (i02,80001) ivtnum
        !           574:       go to  541
        !           575: 20530 ivfail = ivfail + 1
        !           576:       ivcorr = 44
        !           577:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           578:   541 continue
        !           579:       ivtnum =  54
        !           580: c
        !           581: c      ****  test  54  ****
        !           582: c
        !           583:       if (iczero) 30540,  540, 30540
        !           584:   540 continue
        !           585:       ivcomp = 4.450e1
        !           586:       go to 40540
        !           587: 30540 ivdele = ivdele + 1
        !           588:       write (i02,80003) ivtnum
        !           589:       if (iczero) 40540,  551, 40540
        !           590: 40540 if (ivcomp - 44) 20540,10540,20540
        !           591: 10540 ivpass = ivpass + 1
        !           592:       write (i02,80001) ivtnum
        !           593:       go to  551
        !           594: 20540 ivfail = ivfail + 1
        !           595:       ivcorr = 44
        !           596:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           597:   551 continue
        !           598:       ivtnum =  55
        !           599: c
        !           600: c      ****  test  55  ****
        !           601: c
        !           602:       if (iczero) 30550,  550, 30550
        !           603:   550 continue
        !           604:       ivcomp = -4.45e0
        !           605:       go to 40550
        !           606: 30550 ivdele = ivdele + 1
        !           607:       write (i02,80003) ivtnum
        !           608:       if (iczero) 40550,  561, 40550
        !           609: 40550 if (ivcomp + 4) 20550,10550,20550
        !           610: 10550 ivpass = ivpass + 1
        !           611:       write (i02,80001) ivtnum
        !           612:       go to  561
        !           613: 20550 ivfail = ivfail + 1
        !           614:       ivcorr = -4
        !           615:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           616: c
        !           617: c     test 56 and 57 contain arithmetic assignment statements of the
        !           618: c     form          integer variable = real constant
        !           619: c     where constant is integer constant followed by decimal exponent
        !           620: c
        !           621:   561 continue
        !           622:       ivtnum =  56
        !           623: c
        !           624: c      ****  test  56  ****
        !           625: c
        !           626:       if (iczero) 30560,  560, 30560
        !           627:   560 continue
        !           628:       ivcomp = 445e-02
        !           629:       go to 40560
        !           630: 30560 ivdele = ivdele + 1
        !           631:       write (i02,80003) ivtnum
        !           632:       if (iczero) 40560,  571, 40560
        !           633: 40560 if (ivcomp - 4) 20560,10560,20560
        !           634: 10560 ivpass = ivpass + 1
        !           635:       write (i02,80001) ivtnum
        !           636:       go to  571
        !           637: 20560 ivfail = ivfail + 1
        !           638:       ivcorr = 4
        !           639:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           640:   571 continue
        !           641:       ivtnum =  57
        !           642: c
        !           643: c      ****  test  57  ****
        !           644: c
        !           645:       if (iczero) 30570,  570, 30570
        !           646:   570 continue
        !           647:       ivcomp = -701e-1
        !           648:       go to 40570
        !           649: 30570 ivdele = ivdele + 1
        !           650:       write (i02,80003) ivtnum
        !           651:       if (iczero) 40570,  581, 40570
        !           652: 40570 if (ivcomp + 70) 20570,10570,20570
        !           653: 10570 ivpass = ivpass + 1
        !           654:       write (i02,80001) ivtnum
        !           655:       go to  581
        !           656: 20570 ivfail = ivfail + 1
        !           657:       ivcorr = -70
        !           658:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           659: c
        !           660: c     test 58 through test 62 contain arithmetic assignment statements
        !           661: c     of the form   real variable = integer constant
        !           662: c
        !           663:   581 continue
        !           664:       ivtnum =  58
        !           665: c
        !           666: c      ****  test  58  ****
        !           667: c
        !           668:       if (iczero) 30580,  580, 30580
        !           669:   580 continue
        !           670:       rvcomp = 23
        !           671:       go to 40580
        !           672: 30580 ivdele = ivdele + 1
        !           673:       write (i02,80003) ivtnum
        !           674:       if (iczero) 40580,  591, 40580
        !           675: 40580 if (rvcomp - 22.995) 20580,10580,40581
        !           676: 40581 if (rvcomp - 23.005) 10580,10580,20580
        !           677: 10580 ivpass = ivpass + 1
        !           678:       write (i02,80001) ivtnum
        !           679:       go to  591
        !           680: 20580 ivfail = ivfail + 1
        !           681:       rvcorr = 23.000
        !           682:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           683:   591 continue
        !           684:       ivtnum =  59
        !           685: c
        !           686: c      ****  test  59  ****
        !           687: c
        !           688:       if (iczero) 30590,  590, 30590
        !           689:   590 continue
        !           690:       rvcomp = 32645
        !           691:       go to 40590
        !           692: 30590 ivdele = ivdele + 1
        !           693:       write (i02,80003) ivtnum
        !           694:       if (iczero) 40590,  601, 40590
        !           695: 40590 if (rvcomp - 32640.) 20590,10590,40591
        !           696: 40591 if (rvcomp - 32650.) 10590,10590,20590
        !           697: 10590 ivpass = ivpass + 1
        !           698:       write (i02,80001) ivtnum
        !           699:       go to  601
        !           700: 20590 ivfail = ivfail + 1
        !           701:       rvcorr = 32645.
        !           702:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           703:   601 continue
        !           704:       ivtnum =  60
        !           705: c
        !           706: c      ****  test  60  ****
        !           707: c
        !           708:       if (iczero) 30600,  600, 30600
        !           709:   600 continue
        !           710:       rvcomp = 0
        !           711:       go to 40600
        !           712: 30600 ivdele = ivdele + 1
        !           713:       write (i02,80003) ivtnum
        !           714:       if (iczero) 40600,  611, 40600
        !           715: 40600 if (rvcomp) 20600,10600,20600
        !           716: 10600 ivpass = ivpass + 1
        !           717:       write (i02,80001) ivtnum
        !           718:       go to  611
        !           719: 20600 ivfail = ivfail + 1
        !           720:       rvcorr = 00000.
        !           721:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           722:   611 continue
        !           723:       ivtnum =  61
        !           724: c
        !           725: c      ****  test  61  ****
        !           726: c
        !           727:       if (iczero) 30610,  610, 30610
        !           728:   610 continue
        !           729:       rvcomp = -15
        !           730:       go to 40610
        !           731: 30610 ivdele = ivdele + 1
        !           732:       write (i02,80003) ivtnum
        !           733:       if (iczero) 40610,  621, 40610
        !           734: 40610 if (rvcomp -14.995) 40611,10610,20610
        !           735: 40611 if (rvcomp + 15.005) 20610,10610,10610
        !           736: 10610 ivpass = ivpass + 1
        !           737:       write (i02,80001) ivtnum
        !           738:       go to  621
        !           739: 20610 ivfail = ivfail + 1
        !           740:       rvcorr = -15.000
        !           741:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           742:   621 continue
        !           743: c
        !           744: c      ****    end of tests    ****
        !           745: c
        !           746: c
        !           747: c     write page footings and run summaries
        !           748: 99999 continue
        !           749:       write (i02,90002)
        !           750:       write (i02,90006)
        !           751:       write (i02,90002)
        !           752:       write (i02,90002)
        !           753:       write (i02,90007)
        !           754:       write (i02,90002)
        !           755:       write (i02,90008)  ivfail
        !           756:       write (i02,90009) ivpass
        !           757:       write (i02,90010) ivdele
        !           758: c
        !           759: c
        !           760: c     terminate routine execution
        !           761:       stop
        !           762: c
        !           763: c     format statements for page headers
        !           764: 90000 format (1h1)
        !           765: 90002 format (1h )
        !           766: 90001 format (1h ,10x,34hfortran compiler validation system)
        !           767: 90003 format (1h ,21x,11hversion 1.0)
        !           768: 90004 format (1h ,10x,38hfor official use only - copyright 1978)
        !           769: 90005 format (1h ,5x,4htest,5x,9hpass/fail, 5x,8hcomputed,8x,7hcorrect)
        !           770: 90006 format (1h ,5x,46h----------------------------------------------)
        !           771: 90011 format (1h ,18x,17hsubset level test)
        !           772: c
        !           773: c     format statements for run summaries
        !           774: 90008 format (1h ,15x,i5,19h errors encountered)
        !           775: 90009 format (1h ,15x,i5,13h tests passed)
        !           776: 90010 format (1h ,15x,i5,14h tests deleted)
        !           777: c
        !           778: c     format statements for test results
        !           779: 80001 format (1h ,4x,i5,7x,4hpass)
        !           780: 80002 format (1h ,4x,i5,7x,4hfail)
        !           781: 80003 format (1h ,4x,i5,7x,7hdeleted)
        !           782: 80004 format (1h ,4x,i5,7x,4hfail,10x,i6,9x,i6)
        !           783: 80005 format (1h ,4x,i5,7x,4hfail,4x,e12.5,3x,e12.5)
        !           784: c
        !           785: 90007 format (1h ,20x,20hend of program fm061)
        !           786:       end

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