Return to fm043.f CVS log

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

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

1.1     ! root        1: c     comment section
        !             2: c
        !             3: c     fm043
        !             4: c
        !             5: c         this routine tests arithmetic assignments of the form
        !             6: c
        !             7: c     integer var. = integer var. <op1> integer var. <op2> integer var.
        !             8: c
        !             9: c     where <op1> and <op2> are arithmetic operators, but <op1> is
        !            10: c     not the same as <op2>.
        !            11: c
        !            12: c      references
        !            13: c        american national standard programming language fortran,
        !            14: c              x3.9-1978
        !            15: c
        !            16: c        section 4.3, integer type
        !            17: c        section 4.3.1, integer constant
        !            18: c        section 6.1, arithmetic expressions
        !            19: c        section 6.6, evaluation of expressions
        !            20: c        section 10.1, arithmetic assignment statement
        !            21: c
        !            22: c
        !            23: c      **********************************************************
        !            24: c
        !            25: c         a compiler validation system for the fortran language
        !            26: c     based on specifications as defined in american national standard
        !            27: c     programming language fortran x3.9-1978, has been developed by the
        !            28: c     federal cobol compiler testing service.  the fortran compiler
        !            29: c     validation system (fcvs) consists of audit routines, their related
        !            30: c     data, and an executive system.  each audit routine is a fortran
        !            31: c     program, subprogram or function which includes tests of specific
        !            32: c     language elements and supporting procedures indicating the result
        !            33: c     of executing these tests.
        !            34: c
        !            35: c         this particular program/subprogram/function contains features
        !            36: c     found only in the subset as defined in x3.9-1978.
        !            37: c
        !            38: c         suggestions and comments should be forwarded to -
        !            39: c
        !            40: c                  department of the navy
        !            41: c                  federal cobol compiler testing service
        !            42: c                  washington, d.c.  20376
        !            43: c
        !            44: c      **********************************************************
        !            45: c
        !            46: c
        !            47: c
        !            48: c     initialization section
        !            49: c
        !            50: c     initialize constants
        !            51: c      **************
        !            52: c     i01 contains the logical unit number for the card reader.
        !            53:       i01 = 5
        !            54: c     i02 contains the logical unit number for the printer.
        !            55:       i02 = 6
        !            56: c     system environment section
        !            57: c
        !            58: cx010    this card is replaced by contents of fexec x-010 control card.
        !            59: c     the cx010 card is for overriding the program default i01 = 5
        !            60: c     (unit number for card reader).
        !            61: cx011    this card is replaced by contents of fexec x-011 control card.
        !            62: c     the cx011 card is for systems which require additional
        !            63: c     fortran statements for files associated with cx010 above.
        !            64: c
        !            65: cx020    this card is replaced by contents of fexec x-020 control card.
        !            66: c     the cx020 card is for overriding the program default i02 = 6
        !            67: c     (unit number for printer).
        !            68: cx021    this card is replaced by contents of fexec x-021 control card.
        !            69: c     the cx021 card is for systems which require additional
        !            70: c     fortran statements for files associated with cx020 above.
        !            71: c
        !            72:       ivpass=0
        !            73:       ivfail=0
        !            74:       ivdele=0
        !            75:       iczero=0
        !            76: c
        !            77: c     write page headers
        !            78:       write (i02,90000)
        !            79:       write (i02,90001)
        !            80:       write (i02,90002)
        !            81:       write (i02, 90002)
        !            82:       write (i02,90003)
        !            83:       write (i02,90002)
        !            84:       write (i02,90004)
        !            85:       write (i02,90002)
        !            86:       write (i02,90011)
        !            87:       write (i02,90002)
        !            88:       write (i02,90002)
        !            89:       write (i02,90005)
        !            90:       write (i02,90006)
        !            91:       write (i02,90002)
        !            92: c
        !            93: c     test section
        !            94: c
        !            95: c         arithmetic assignment statement
        !            96: c
        !            97: c     tests 683 through 694 test statements where <op1> is '+' and
        !            98: c     <op2> varies.
        !            99: c
        !           100: c     test 695 through 706 test statements where <op1> is '-' and
        !           101: c     <op2> varies.
        !           102: c
        !           103: c     tests 707 through 718 test statements where <op1> is '*' and
        !           104: c     <op2> varies.
        !           105: c
        !           106: c
        !           107: c
        !           108: c     tests 683 through  685 test '+' followed by '-'.
        !           109: c
        !           110:       ivtnum = 683
        !           111: c
        !           112: c      ****  test 683  ****
        !           113: c
        !           114:       if (iczero) 36830, 6830, 36830
        !           115:  6830 continue
        !           116:       ivon01 = 45
        !           117:       ivon02 =  9
        !           118:       ivon03 =  3
        !           119:       ivcomp = ivon01 + ivon02 - ivon03
        !           120:       go to 46830
        !           121: 36830 ivdele = ivdele + 1
        !           122:       write (i02,80003) ivtnum
        !           123:       if (iczero) 46830, 6841, 46830
        !           124: 46830 if (ivcomp - 51) 26830,16830,26830
        !           125: 16830 ivpass = ivpass + 1
        !           126:       write (i02,80001) ivtnum
        !           127:       go to 6841
        !           128: 26830 ivfail = ivfail + 1
        !           129:       ivcorr = 51
        !           130:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           131:  6841 continue
        !           132:       ivtnum = 684
        !           133: c
        !           134: c      ****  test 684  ****
        !           135: c
        !           136:       if (iczero) 36840, 6840, 36840
        !           137:  6840 continue
        !           138:       ivon01 = 45
        !           139:       ivon02 =  9
        !           140:       ivon03 =  3
        !           141:       ivcomp = (ivon01 + ivon02) - ivon03
        !           142:       go to 46840
        !           143: 36840 ivdele = ivdele + 1
        !           144:       write (i02,80003) ivtnum
        !           145:       if (iczero) 46840, 6851, 46840
        !           146: 46840 if (ivcomp - 51) 26840,16840,26840
        !           147: 16840 ivpass = ivpass + 1
        !           148:       write (i02,80001) ivtnum
        !           149:       go to 6851
        !           150: 26840 ivfail = ivfail + 1
        !           151:       ivcorr = 51
        !           152:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           153:  6851 continue
        !           154:       ivtnum = 685
        !           155: c
        !           156: c      ****  test 685  ****
        !           157: c
        !           158:       if (iczero) 36850, 6850, 36850
        !           159:  6850 continue
        !           160:       ivon01 = 45
        !           161:       ivon02 = 9
        !           162:       ivon03 = 3
        !           163:       ivcomp = ivon01 + (ivon02 - ivon03)
        !           164:       go to 46850
        !           165: 36850 ivdele = ivdele + 1
        !           166:       write (i02,80003) ivtnum
        !           167:       if (iczero) 46850, 6861, 46850
        !           168: 46850 if (ivcomp - 51) 26850,16850,26850
        !           169: 16850 ivpass = ivpass + 1
        !           170:       write (i02,80001) ivtnum
        !           171:       go to 6861
        !           172: 26850 ivfail = ivfail + 1
        !           173:       ivcorr = 51
        !           174:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           175:  6861 continue
        !           176: c
        !           177: c     tests 686 through 688 test '+' followed by '*'.
        !           178: c
        !           179:       ivtnum = 686
        !           180: c
        !           181: c      ****  test 686  ****
        !           182: c
        !           183:       if (iczero) 36860, 6860, 36860
        !           184:  6860 continue
        !           185:       ivon01 = 45
        !           186:       ivon02 =  9
        !           187:       ivon03 =  3
        !           188:       ivcomp =  ivon01 + ivon02 * ivon03
        !           189:       go to 46860
        !           190: 36860 ivdele = ivdele + 1
        !           191:       write (i02,80003) ivtnum
        !           192:       if (iczero) 46860, 6871, 46860
        !           193: 46860 if (ivcomp - 72) 26860,16860,26860
        !           194: 16860 ivpass = ivpass + 1
        !           195:       write (i02,80001) ivtnum
        !           196:       go to 6871
        !           197: 26860 ivfail = ivfail + 1
        !           198:       ivcorr = 72
        !           199:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           200:  6871 continue
        !           201:       ivtnum = 687
        !           202: c
        !           203: c      ****  test 687  ****
        !           204: c
        !           205:       if (iczero) 36870, 6870, 36870
        !           206:  6870 continue
        !           207:       ivon01 = 45
        !           208:       ivon02 =  9
        !           209:       ivon03 =  3
        !           210:       ivcomp = (ivon01 + ivon02) * ivon03
        !           211:       go to 46870
        !           212: 36870 ivdele = ivdele + 1
        !           213:       write (i02,80003) ivtnum
        !           214:       if (iczero) 46870, 6881, 46870
        !           215: 46870 if (ivcomp - 162) 26870,16870,26870
        !           216: 16870 ivpass = ivpass + 1
        !           217:       write (i02,80001) ivtnum
        !           218:       go to 6881
        !           219: 26870 ivfail = ivfail + 1
        !           220:       ivcorr = 162
        !           221:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           222:  6881 continue
        !           223:       ivtnum = 688
        !           224: c
        !           225: c      ****  test 688  ****
        !           226: c
        !           227:       if (iczero) 36880, 6880, 36880
        !           228:  6880 continue
        !           229:       ivon01 = 45
        !           230:       ivon02 =  9
        !           231:       ivon03 = 3
        !           232:       ivcomp = ivon01 + (ivon02 * ivon03)
        !           233:       go to 46880
        !           234: 36880 ivdele = ivdele + 1
        !           235:       write (i02,80003) ivtnum
        !           236:       if (iczero) 46880, 6891, 46880
        !           237: 46880 if (ivcomp - 72) 26880,16880,26880
        !           238: 16880 ivpass = ivpass + 1
        !           239:       write (i02,80001) ivtnum
        !           240:       go to 6891
        !           241: 26880 ivfail = ivfail + 1
        !           242:       ivcorr = 72
        !           243:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           244:  6891 continue
        !           245: c
        !           246: c     tests 689 through 691 test '+' followed by '/'.
        !           247: c
        !           248:       ivtnum = 689
        !           249: c
        !           250: c      ****  test 689  ****
        !           251: c
        !           252:       if (iczero) 36890, 6890, 36890
        !           253:  6890 continue
        !           254:       ivon01 = 45
        !           255:       ivon02 =  9
        !           256:       ivon03 = 3
        !           257:       ivcomp = ivon01 + ivon02 / ivon03
        !           258:       go to 46890
        !           259: 36890 ivdele = ivdele + 1
        !           260:       write (i02,80003) ivtnum
        !           261:       if (iczero) 46890, 6901, 46890
        !           262: 46890 if (ivcomp - 48) 26890,16890,26890
        !           263: 16890 ivpass = ivpass + 1
        !           264:       write (i02,80001) ivtnum
        !           265:       go to 6901
        !           266: 26890 ivfail = ivfail + 1
        !           267:       ivcorr = 48
        !           268:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           269:  6901 continue
        !           270:       ivtnum = 690
        !           271: c
        !           272: c      ****  test 690  ****
        !           273: c
        !           274:       if (iczero) 36900, 6900, 36900
        !           275:  6900 continue
        !           276:       ivon01 = 45
        !           277:       ivon02 =  9
        !           278:       ivon03 =  3
        !           279:       ivcomp = (ivon01 + ivon02) / ivon03
        !           280:       go to 46900
        !           281: 36900 ivdele = ivdele + 1
        !           282:       write (i02,80003) ivtnum
        !           283:       if (iczero) 46900, 6911, 46900
        !           284: 46900 if (ivcomp - 18) 26900,16900,26900
        !           285: 16900 ivpass = ivpass + 1
        !           286:       write (i02,80001) ivtnum
        !           287:       go to 6911
        !           288: 26900 ivfail = ivfail + 1
        !           289:       ivcorr = 18
        !           290:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           291:  6911 continue
        !           292:       ivtnum = 691
        !           293: c
        !           294: c      ****  test 691  ****
        !           295: c
        !           296:       if (iczero) 36910, 6910, 36910
        !           297:  6910 continue
        !           298:       ivon01 = 45
        !           299:       ivon02 =  9
        !           300:       ivon03 =  3
        !           301:       ivcomp = ivon01 + (ivon02 / ivon03)
        !           302:       go to 46910
        !           303: 36910 ivdele = ivdele + 1
        !           304:       write (i02,80003) ivtnum
        !           305:       if (iczero) 46910, 6921, 46910
        !           306: 46910 if (ivcomp - 48) 26910,16910,26910
        !           307: 16910 ivpass = ivpass + 1
        !           308:       write (i02,80001) ivtnum
        !           309:       go to 6921
        !           310: 26910 ivfail = ivfail + 1
        !           311:       ivcorr = 48
        !           312:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           313:  6921 continue
        !           314: c
        !           315: c     tests 692 through 694 test '+' followed by '**'.
        !           316: c
        !           317:       ivtnum = 692
        !           318: c
        !           319: c      ****  test 692  ****
        !           320: c
        !           321:       if (iczero) 36920, 6920, 36920
        !           322:  6920 continue
        !           323:       ivon01 = 15
        !           324:       ivon02 =  9
        !           325:       ivon03 =  3
        !           326:       ivcomp = ivon01 + ivon02 ** ivon03
        !           327:       go to 46920
        !           328: 36920 ivdele = ivdele + 1
        !           329:       write (i02,80003) ivtnum
        !           330:       if (iczero) 46920, 6931, 46920
        !           331: 46920 if (ivcomp - 744) 26920,16920,26920
        !           332: 16920 ivpass = ivpass + 1
        !           333:       write (i02,80001) ivtnum
        !           334:       go to 6931
        !           335: 26920 ivfail = ivfail + 1
        !           336:       ivcorr = 744
        !           337:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           338:  6931 continue
        !           339:       ivtnum = 693
        !           340: c
        !           341: c      ****  test 693  ****
        !           342: c
        !           343:       if (iczero) 36930, 6930, 36930
        !           344:  6930 continue
        !           345:       ivon01 = 15
        !           346:       ivon02 =  9
        !           347:       ivon03 =  3
        !           348:       ivcomp = (ivon01 + ivon02) ** ivon03
        !           349:       go to 46930
        !           350: 36930 ivdele = ivdele + 1
        !           351:       write (i02,80003) ivtnum
        !           352:       if (iczero) 46930, 6941, 46930
        !           353: 46930 if (ivcomp - 13824) 26930,16930,26930
        !           354: 16930 ivpass = ivpass + 1
        !           355:       write (i02,80001) ivtnum
        !           356:       go to 6941
        !           357: 26930 ivfail = ivfail + 1
        !           358:       ivcorr = 13824
        !           359:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           360:  6941 continue
        !           361:       ivtnum = 694
        !           362: c
        !           363: c      ****  test 694  ****
        !           364: c
        !           365:       if (iczero) 36940, 6940, 36940
        !           366:  6940 continue
        !           367:       ivon01 = 15
        !           368:       ivon02 =  9
        !           369:       ivon03 =  3
        !           370:       ivcomp = ivon01 + (ivon02 ** ivon03)
        !           371:       go to 46940
        !           372: 36940 ivdele = ivdele + 1
        !           373:       write (i02,80003) ivtnum
        !           374:       if (iczero) 46940, 6951, 46940
        !           375: 46940 if (ivcomp - 744) 26940,16940,26940
        !           376: 16940 ivpass = ivpass + 1
        !           377:       write (i02,80001) ivtnum
        !           378:       go to 6951
        !           379: 26940 ivfail = ivfail + 1
        !           380:       ivcorr = 744
        !           381:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           382:  6951 continue
        !           383: c
        !           384: c     tests 695 through 697 test '-' followed by '+'.
        !           385: c
        !           386:       ivtnum = 695
        !           387: c
        !           388: c      ****  test 695  ****
        !           389: c
        !           390:       if (iczero) 36950, 6950, 36950
        !           391:  6950 continue
        !           392:       ivon01 =  45
        !           393:       ivon02 =   9
        !           394:       ivon03 =   3
        !           395:       ivcomp = ivon01 - ivon02 + ivon03
        !           396:       go to 46950
        !           397: 36950 ivdele = ivdele + 1
        !           398:       write (i02,80003) ivtnum
        !           399:       if (iczero) 46950, 6961, 46950
        !           400: 46950 if (ivcomp - 39) 26950,16950,26950
        !           401: 16950 ivpass = ivpass + 1
        !           402:       write (i02,80001) ivtnum
        !           403:       go to 6961
        !           404: 26950 ivfail = ivfail + 1
        !           405:       ivcorr = 39
        !           406:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           407:  6961 continue
        !           408:       ivtnum = 696
        !           409: c
        !           410: c      ****  test 696  ****
        !           411: c
        !           412:       if (iczero) 36960, 6960, 36960
        !           413:  6960 continue
        !           414:       ivon01 = 45
        !           415:       ivon02 =  9
        !           416:       ivon03 =  3
        !           417:       ivcomp = (ivon01 - ivon02) + ivon03
        !           418:       go to 46960
        !           419: 36960 ivdele = ivdele + 1
        !           420:       write (i02,80003) ivtnum
        !           421:       if (iczero) 46960, 6971, 46960
        !           422: 46960 if (ivcomp - 39) 26960,16960,26960
        !           423: 16960 ivpass = ivpass + 1
        !           424:       write (i02,80001) ivtnum
        !           425:       go to 6971
        !           426: 26960 ivfail = ivfail + 1
        !           427:       ivcorr = 39
        !           428:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           429:  6971 continue
        !           430:       ivtnum = 697
        !           431: c
        !           432: c      ****  test 697  ****
        !           433: c
        !           434:       if (iczero) 36970, 6970, 36970
        !           435:  6970 continue
        !           436:       ivon01 = 45
        !           437:       ivon02 =  9
        !           438:       ivon03 =  3
        !           439:       ivcomp = ivon01 - (ivon02 + ivon03)
        !           440:       go to 46970
        !           441: 36970 ivdele = ivdele + 1
        !           442:       write (i02,80003) ivtnum
        !           443:       if (iczero) 46970, 6981, 46970
        !           444: 46970 if (ivcomp - 33) 26970,16970,26970
        !           445: 16970 ivpass = ivpass + 1
        !           446:       write (i02,80001) ivtnum
        !           447:       go to 6981
        !           448: 26970 ivfail = ivfail + 1
        !           449:       ivcorr = 33
        !           450:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           451:  6981 continue
        !           452: c
        !           453: c     tests 698 through 700 test '-' followed by '*'.
        !           454: c
        !           455:       ivtnum = 698
        !           456: c
        !           457: c      ****  test 698  ****
        !           458: c
        !           459:       if (iczero) 36980, 6980, 36980
        !           460:  6980 continue
        !           461:       ivon01 = 45
        !           462:       ivon02 =  9
        !           463:       ivon03 =  3
        !           464:       ivcomp =  ivon01 - ivon02 * ivon03
        !           465:       go to 46980
        !           466: 36980 ivdele = ivdele + 1
        !           467:       write (i02,80003) ivtnum
        !           468:       if (iczero) 46980, 6991, 46980
        !           469: 46980 if (ivcomp - 18) 26980,16980,26980
        !           470: 16980 ivpass = ivpass + 1
        !           471:       write (i02,80001) ivtnum
        !           472:       go to 6991
        !           473: 26980 ivfail = ivfail + 1
        !           474:       ivcorr = 18
        !           475:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           476:  6991 continue
        !           477:       ivtnum = 699
        !           478: c
        !           479: c      ****  test 699  ****
        !           480: c
        !           481:       if (iczero) 36990, 6990, 36990
        !           482:  6990 continue
        !           483:       ivon01 = 45
        !           484:       ivon02 =  9
        !           485:       ivon03 =  3
        !           486:       ivcomp = (ivon01 - ivon02) * ivon03
        !           487:       go to 46990
        !           488: 36990 ivdele = ivdele + 1
        !           489:       write (i02,80003) ivtnum
        !           490:       if (iczero) 46990, 7001, 46990
        !           491: 46990 if (ivcomp - 108) 26990,16990,26990
        !           492: 16990 ivpass = ivpass + 1
        !           493:       write (i02,80001) ivtnum
        !           494:       go to 7001
        !           495: 26990 ivfail = ivfail + 1
        !           496:       ivcorr = 108
        !           497:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           498:  7001 continue
        !           499:       ivtnum = 700
        !           500: c
        !           501: c      ****  test 700  ****
        !           502: c
        !           503:       if (iczero) 37000, 7000, 37000
        !           504:  7000 continue
        !           505:       ivon01 = 45
        !           506:       ivon02 =  9
        !           507:       ivon03 =  3
        !           508:       ivcomp = ivon01 - (ivon02 * ivon03)
        !           509:       go to 47000
        !           510: 37000 ivdele = ivdele + 1
        !           511:       write (i02,80003) ivtnum
        !           512:       if (iczero) 47000, 7011, 47000
        !           513: 47000 if (ivcomp - 18) 27000,17000,27000
        !           514: 17000 ivpass = ivpass + 1
        !           515:       write (i02,80001) ivtnum
        !           516:       go to 7011
        !           517: 27000 ivfail = ivfail + 1
        !           518:       ivcorr = 18
        !           519:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           520:  7011 continue
        !           521: c
        !           522: c     tests 701 through 703 test '-' followed by '/'.
        !           523: c
        !           524:       ivtnum = 701
        !           525: c
        !           526: c      ****  test 701  ****
        !           527: c
        !           528:       if (iczero) 37010, 7010, 37010
        !           529:  7010 continue
        !           530:       ivon01 = 45
        !           531:       ivon02 =  9
        !           532:       ivon03 =  3
        !           533:       ivcomp = ivon01 - ivon02 / ivon03
        !           534:       go to 47010
        !           535: 37010 ivdele = ivdele + 1
        !           536:       write (i02,80003) ivtnum
        !           537:       if (iczero) 47010, 7021, 47010
        !           538: 47010 if (ivcomp - 42) 27010,17010,27010
        !           539: 17010 ivpass = ivpass + 1
        !           540:       write (i02,80001) ivtnum
        !           541:       go to 7021
        !           542: 27010 ivfail = ivfail + 1
        !           543:       ivcorr = 42
        !           544:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           545:  7021 continue
        !           546:       ivtnum = 702
        !           547: c
        !           548: c      ****  test 702  ****
        !           549: c
        !           550:       if (iczero) 37020, 7020, 37020
        !           551:  7020 continue
        !           552:       ivon01 = 45
        !           553:       ivon02 =  9
        !           554:       ivon03 =  3
        !           555:       ivcomp = (ivon01 - ivon02) / ivon03
        !           556:       go to 47020
        !           557: 37020 ivdele = ivdele + 1
        !           558:       write (i02,80003) ivtnum
        !           559:       if (iczero) 47020, 7031, 47020
        !           560: 47020 if (ivcomp - 12) 27020,17020,27020
        !           561: 17020 ivpass = ivpass + 1
        !           562:       write (i02,80001) ivtnum
        !           563:       go to 7031
        !           564: 27020 ivfail = ivfail + 1
        !           565:       ivcorr = 12
        !           566:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           567:  7031 continue
        !           568:       ivtnum = 703
        !           569: c
        !           570: c      ****  test 703  ****
        !           571: c
        !           572:       if (iczero) 37030, 7030, 37030
        !           573:  7030 continue
        !           574:       ivon01 = 45
        !           575:       ivon02 =  9
        !           576:       ivon03 =  3
        !           577:       ivcomp = ivon01 - (ivon02 / ivon03)
        !           578:       go to 47030
        !           579: 37030 ivdele = ivdele + 1
        !           580:       write (i02,80003) ivtnum
        !           581:       if (iczero) 47030, 7041, 47030
        !           582: 47030 if (ivcomp - 42) 27030,17030,27030
        !           583: 17030 ivpass = ivpass + 1
        !           584:       write (i02,80001) ivtnum
        !           585:       go to 7041
        !           586: 27030 ivfail = ivfail + 1
        !           587:       ivcorr = 42
        !           588:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           589:  7041 continue
        !           590: c
        !           591: c     tests 704 through 706 test '-' followed by '**'.
        !           592: c
        !           593:       ivtnum = 704
        !           594: c
        !           595: c      ****  test 704  ****
        !           596: c
        !           597:       if (iczero) 37040, 7040, 37040
        !           598:  7040 continue
        !           599:       ivon01 = 35
        !           600:       ivon02 =  9
        !           601:       ivon03 =  3
        !           602:       ivcomp = ivon01 - ivon02 ** ivon03
        !           603:       go to 47040
        !           604: 37040 ivdele = ivdele + 1
        !           605:       write (i02,80003) ivtnum
        !           606:       if (iczero) 47040, 7051, 47040
        !           607: 47040 if (ivcomp + 694) 27040,17040,27040
        !           608: 17040 ivpass = ivpass + 1
        !           609:       write (i02,80001) ivtnum
        !           610:       go to 7051
        !           611: 27040 ivfail = ivfail + 1
        !           612:       ivcorr = -694
        !           613:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           614:  7051 continue
        !           615:       ivtnum = 705
        !           616: c
        !           617: c      ****  test 705  ****
        !           618: c
        !           619:       if (iczero) 37050, 7050, 37050
        !           620:  7050 continue
        !           621:       ivon01 = 35
        !           622:       ivon02 =  9
        !           623:       ivon03 =  3
        !           624:       ivcomp = (ivon01 - ivon02) ** ivon03
        !           625:       go to 47050
        !           626: 37050 ivdele = ivdele + 1
        !           627:       write (i02,80003) ivtnum
        !           628:       if (iczero) 47050, 7061, 47050
        !           629: 47050 if (ivcomp - 17576) 27050,17050,27050
        !           630: 17050 ivpass = ivpass + 1
        !           631:       write (i02,80001) ivtnum
        !           632:       go to 7061
        !           633: 27050 ivfail = ivfail + 1
        !           634:       ivcorr = 17576
        !           635:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           636:  7061 continue
        !           637:       ivtnum = 706
        !           638: c
        !           639: c      ****  test 706  ****
        !           640: c
        !           641:       if (iczero) 37060, 7060, 37060
        !           642:  7060 continue
        !           643:       ivon01 = 35
        !           644:       ivon02 =  9
        !           645:       ivon03 =  3
        !           646:       ivcomp = ivon01 - (ivon02 ** ivon03)
        !           647:       go to 47060
        !           648: 37060 ivdele = ivdele + 1
        !           649:       write (i02,80003) ivtnum
        !           650:       if (iczero) 47060, 7071, 47060
        !           651: 47060 if (ivcomp + 694) 27060,17060,27060
        !           652: 17060 ivpass = ivpass + 1
        !           653:       write (i02,80001) ivtnum
        !           654:       go to 7071
        !           655: 27060 ivfail = ivfail + 1
        !           656:       ivcorr = -694
        !           657:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           658:  7071 continue
        !           659: c
        !           660: c     tests 707 through 709 test '*' followed by '+'.
        !           661: c
        !           662:       ivtnum = 707
        !           663: c
        !           664: c      ****  test 707  ****
        !           665: c
        !           666:       if (iczero) 37070, 7070, 37070
        !           667:  7070 continue
        !           668:       ivon01 = 45
        !           669:       ivon02 =  9
        !           670:       ivon03 =  3
        !           671:       ivcomp =  ivon01 * ivon02 + ivon03
        !           672:       go to 47070
        !           673: 37070 ivdele = ivdele + 1
        !           674:       write (i02,80003) ivtnum
        !           675:       if (iczero) 47070, 7081, 47070
        !           676: 47070 if (ivcomp - 408) 27070,17070,27070
        !           677: 17070 ivpass = ivpass + 1
        !           678:       write (i02,80001) ivtnum
        !           679:       go to 7081
        !           680: 27070 ivfail = ivfail + 1
        !           681:       ivcorr = 408
        !           682:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           683:  7081 continue
        !           684:       ivtnum = 708
        !           685: c
        !           686: c      ****  test 708  ****
        !           687: c
        !           688:       if (iczero) 37080, 7080, 37080
        !           689:  7080 continue
        !           690:       ivon01 = 45
        !           691:       ivon02 =  9
        !           692:       ivon03 =  3
        !           693:       ivcomp = (ivon01 * ivon02) + ivon03
        !           694:       go to 47080
        !           695: 37080 ivdele = ivdele + 1
        !           696:       write (i02,80003) ivtnum
        !           697:       if (iczero) 47080, 7091, 47080
        !           698: 47080 if (ivcomp - 408) 27080,17080,27080
        !           699: 17080 ivpass = ivpass + 1
        !           700:       write (i02,80001) ivtnum
        !           701:       go to 7091
        !           702: 27080 ivfail = ivfail + 1
        !           703:       ivcorr = 408
        !           704:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           705:  7091 continue
        !           706:       ivtnum = 709
        !           707: c
        !           708: c      ****  test 709  ****
        !           709: c
        !           710:       if (iczero) 37090, 7090, 37090
        !           711:  7090 continue
        !           712:       ivon01 = 45
        !           713:       ivon02 =  9
        !           714:       ivon03 =  3
        !           715:       ivcomp = ivon01 * (ivon02 + ivon03)
        !           716:       go to 47090
        !           717: 37090 ivdele = ivdele + 1
        !           718:       write (i02,80003) ivtnum
        !           719:       if (iczero) 47090, 7101, 47090
        !           720: 47090 if (ivcomp - 540) 27090,17090,27090
        !           721: 17090 ivpass = ivpass + 1
        !           722:       write (i02,80001) ivtnum
        !           723:       go to 7101
        !           724: 27090 ivfail = ivfail + 1
        !           725:       ivcorr = 540
        !           726:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           727:  7101 continue
        !           728: c
        !           729: c     tests 710 through 712 test '*' followed by '-'.
        !           730: c
        !           731:       ivtnum = 710
        !           732: c
        !           733: c      ****  test 710  ****
        !           734: c
        !           735:       if (iczero) 37100, 7100, 37100
        !           736:  7100 continue
        !           737:       ivon01 = 45
        !           738:       ivon02 =  9
        !           739:       ivon03 =  3
        !           740:       ivcomp = ivon01 * ivon02 - ivon03
        !           741:       go to 47100
        !           742: 37100 ivdele = ivdele + 1
        !           743:       write (i02,80003) ivtnum
        !           744:       if (iczero) 47100, 7111, 47100
        !           745: 47100 if (ivcomp - 402) 27100,17100,27100
        !           746: 17100 ivpass = ivpass + 1
        !           747:       write (i02,80001) ivtnum
        !           748:       go to 7111
        !           749: 27100 ivfail = ivfail + 1
        !           750:       ivcorr = 402
        !           751:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           752:  7111 continue
        !           753:       ivtnum = 711
        !           754: c
        !           755: c      ****  test 711  ****
        !           756: c
        !           757:       if (iczero) 37110, 7110, 37110
        !           758:  7110 continue
        !           759:       ivon01 = 45
        !           760:       ivon02 =  9
        !           761:       ivon03 =  3
        !           762:       ivcomp = (ivon01 * ivon02) - ivon03
        !           763:       go to 47110
        !           764: 37110 ivdele = ivdele + 1
        !           765:       write (i02,80003) ivtnum
        !           766:       if (iczero) 47110, 7121, 47110
        !           767: 47110 if (ivcomp - 402) 27110,17110,27110
        !           768: 17110 ivpass = ivpass + 1
        !           769:       write (i02,80001) ivtnum
        !           770:       go to 7121
        !           771: 27110 ivfail = ivfail + 1
        !           772:       ivcorr = 402
        !           773:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           774:  7121 continue
        !           775:       ivtnum = 712
        !           776: c
        !           777: c      ****  test 712  ****
        !           778: c
        !           779:       if (iczero) 37120, 7120, 37120
        !           780:  7120 continue
        !           781:       ivon01 = 45
        !           782:       ivon02 =  9
        !           783:       ivon03 =  3
        !           784:       ivcomp = ivon01 * (ivon02 - ivon03)
        !           785:       go to 47120
        !           786: 37120 ivdele = ivdele + 1
        !           787:       write (i02,80003) ivtnum
        !           788:       if (iczero) 47120, 7131, 47120
        !           789: 47120 if (ivcomp - 270) 27120,17120,27120
        !           790: 17120 ivpass = ivpass + 1
        !           791:       write (i02,80001) ivtnum
        !           792:       go to 7131
        !           793: 27120 ivfail = ivfail + 1
        !           794:       ivcorr = 270
        !           795:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           796:  7131 continue
        !           797: c
        !           798: c     tests 713 through 715 test '*' followed by '/'.
        !           799: c
        !           800:       ivtnum = 713
        !           801: c
        !           802: c      ****  test 713  ****
        !           803: c
        !           804:       if (iczero) 37130, 7130, 37130
        !           805:  7130 continue
        !           806:       ivon01 = 45
        !           807:       ivon02 =  9
        !           808:       ivon03 =  3
        !           809:       ivcomp = ivon01 * ivon02 / ivon03
        !           810:       go to 47130
        !           811: 37130 ivdele = ivdele + 1
        !           812:       write (i02,80003) ivtnum
        !           813:       if (iczero) 47130, 7141, 47130
        !           814: 47130 if (ivcomp - 135) 27130,17130,27130
        !           815: 17130 ivpass = ivpass + 1
        !           816:       write (i02,80001) ivtnum
        !           817:       go to 7141
        !           818: 27130 ivfail = ivfail + 1
        !           819:       ivcorr = 135
        !           820:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           821:  7141 continue
        !           822:       ivtnum = 714
        !           823: c
        !           824: c      ****  test 714  ****
        !           825: c
        !           826:       if (iczero) 37140, 7140, 37140
        !           827:  7140 continue
        !           828:       ivon01 = 45
        !           829:       ivon02 =  9
        !           830:       ivon03 =  3
        !           831:       ivcomp = (ivon01 * ivon02) / ivon03
        !           832:       go to 47140
        !           833: 37140 ivdele = ivdele + 1
        !           834:       write (i02,80003) ivtnum
        !           835:       if (iczero) 47140, 7151, 47140
        !           836: 47140 if (ivcomp - 135) 27140,17140,27140
        !           837: 17140 ivpass = ivpass + 1
        !           838:       write (i02,80001) ivtnum
        !           839:       go to 7151
        !           840: 27140 ivfail = ivfail + 1
        !           841:       ivcorr = 135
        !           842:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           843:  7151 continue
        !           844:       ivtnum = 715
        !           845: c
        !           846: c      ****  test 715  ****
        !           847: c
        !           848:       if (iczero) 37150, 7150, 37150
        !           849:  7150 continue
        !           850:       ivon01 = 45
        !           851:       ivon02 =  9
        !           852:       ivon03 =  3
        !           853:       ivcomp = ivon01 * (ivon02 / ivon03)
        !           854:       go to 47150
        !           855: 37150 ivdele = ivdele + 1
        !           856:       write (i02,80003) ivtnum
        !           857:       if (iczero) 47150, 7161, 47150
        !           858: 47150 if (ivcomp - 135) 27150,17150,27150
        !           859: 17150 ivpass = ivpass + 1
        !           860:       write (i02,80001) ivtnum
        !           861:       go to 7161
        !           862: 27150 ivfail = ivfail + 1
        !           863:       ivcorr = 135
        !           864:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           865:  7161 continue
        !           866: c
        !           867: c     tests 716 through 718 test '*' followed by '**'.
        !           868: c
        !           869:       ivtnum = 716
        !           870: c
        !           871: c      ****  test 716  ****
        !           872: c
        !           873:       if (iczero) 37160, 7160, 37160
        !           874:  7160 continue
        !           875:       ivon01 = 7
        !           876:       ivon02 = 3
        !           877:       ivon03 = 3
        !           878:       ivcomp = ivon01 * ivon02  ** ivon03
        !           879:       go to 47160
        !           880: 37160 ivdele = ivdele + 1
        !           881:       write (i02,80003) ivtnum
        !           882:       if (iczero) 47160, 7171, 47160
        !           883: 47160 if (ivcomp - 189) 27160,17160,27160
        !           884: 17160 ivpass = ivpass + 1
        !           885:       write (i02,80001) ivtnum
        !           886:       go to 7171
        !           887: 27160 ivfail = ivfail + 1
        !           888:       ivcorr = 189
        !           889:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           890:  7171 continue
        !           891:       ivtnum = 717
        !           892: c
        !           893: c      ****  test 717  ****
        !           894: c
        !           895:       if (iczero) 37170, 7170, 37170
        !           896:  7170 continue
        !           897:       ivon01 = 7
        !           898:       ivon02 = 3
        !           899:       ivon03 = 3
        !           900:       ivcomp = (ivon01 * ivon02) ** ivon03
        !           901:       go to 47170
        !           902: 37170 ivdele = ivdele + 1
        !           903:       write (i02,80003) ivtnum
        !           904:       if (iczero) 47170, 7181, 47170
        !           905: 47170 if (ivcomp - 9261) 27170,17170,27170
        !           906: 17170 ivpass = ivpass + 1
        !           907:       write (i02,80001) ivtnum
        !           908:       go to 7181
        !           909: 27170 ivfail = ivfail + 1
        !           910:       ivcorr = 9261
        !           911:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           912:  7181 continue
        !           913:       ivtnum = 718
        !           914: c
        !           915: c      ****  test 718  ****
        !           916: c
        !           917:       if (iczero) 37180, 7180, 37180
        !           918:  7180 continue
        !           919:       ivon01 = 7
        !           920:       ivon02 = 3
        !           921:       ivon03 = 3
        !           922:       ivcomp = ivon01 * (ivon02 ** ivon03)
        !           923:       go to 47180
        !           924: 37180 ivdele = ivdele + 1
        !           925:       write (i02,80003) ivtnum
        !           926:       if (iczero) 47180, 7191, 47180
        !           927: 47180 if (ivcomp - 189) 27180,17180,27180
        !           928: 17180 ivpass = ivpass + 1
        !           929:       write (i02,80001) ivtnum
        !           930:       go to 7191
        !           931: 27180 ivfail = ivfail + 1
        !           932:       ivcorr = 189
        !           933:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           934:  7191 continue
        !           935: c
        !           936: c     write page footings and run summaries
        !           937: 99999 continue
        !           938:       write (i02,90002)
        !           939:       write (i02,90006)
        !           940:       write (i02,90002)
        !           941:       write (i02,90002)
        !           942:       write (i02,90007)
        !           943:       write (i02,90002)
        !           944:       write (i02,90008)  ivfail
        !           945:       write (i02,90009) ivpass
        !           946:       write (i02,90010) ivdele
        !           947: c
        !           948: c
        !           949: c     terminate routine execution
        !           950:       stop
        !           951: c
        !           952: c     format statements for page headers
        !           953: 90000 format (1h1)
        !           954: 90002 format (1h )
        !           955: 90001 format (1h ,10x,34hfortran compiler validation system)
        !           956: 90003 format (1h ,21x,11hversion 1.0)
        !           957: 90004 format (1h ,10x,38hfor official use only - copyright 1978)
        !           958: 90005 format (1h ,5x,4htest,5x,9hpass/fail, 5x,8hcomputed,8x,7hcorrect)
        !           959: 90006 format (1h ,5x,46h----------------------------------------------)
        !           960: 90011 format (1h ,18x,17hsubset level test)
        !           961: c
        !           962: c     format statements for run summaries
        !           963: 90008 format (1h ,15x,i5,19h errors encountered)
        !           964: 90009 format (1h ,15x,i5,13h tests passed)
        !           965: 90010 format (1h ,15x,i5,14h tests deleted)
        !           966: c
        !           967: c     format statements for test results
        !           968: 80001 format (1h ,4x,i5,7x,4hpass)
        !           969: 80002 format (1h ,4x,i5,7x,4hfail)
        !           970: 80003 format (1h ,4x,i5,7x,7hdeleted)
        !           971: 80004 format (1h ,4x,i5,7x,4hfail,10x,i6,9x,i6)
        !           972: 80005 format (1h ,4x,i5,7x,4hfail,4x,e12.5,3x,e12.5)
        !           973: c
        !           974: 90007 format (1h ,20x,20hend of program fm043)
        !           975:       end

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