Return to fm034.f CVS log

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

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

1.1     ! root        1: c     comment section
        !             2: c
        !             3: c     fm034
        !             4: c
        !             5: c         this routine tests arithmetic assignment statements of the
        !             6: c     form
        !             7: c               integer variable = arithmetic expression
        !             8: c     where the arithmetic expression is formed with the arithmetic
        !             9: c     operator *, integer variable and integer constant.  some of the
        !            10: c     tests use parentheses to group elements in the expression and to
        !            11: c     allow the use of negative constants following the * operator.
        !            12: c     the integer variables contain positive and negative values.
        !            13: c
        !            14: c     there are tests where the arithmetic expression contains
        !            15: c         (1)  integer variable * integer constant
        !            16: c              integer constant * integer variable
        !            17: c         (2)  integer constant * integer variable * integer constant
        !            18: c         (3)  same as (2) but with parens to group elements.
        !            19: c
        !            20: c      references
        !            21: c        american national standard programming language fortran,
        !            22: c              x3.9-1978
        !            23: c
        !            24: c        section 4.3, integer type
        !            25: c        section 4.3.1, integer constant
        !            26: c        section 6.1, arithmetic expressions
        !            27: c        section 10.1, arithmetic assignment statement
        !            28: c
        !            29: c      **********************************************************
        !            30: c
        !            31: c         a compiler validation system for the fortran language
        !            32: c     based on specifications as defined in american national standard
        !            33: c     programming language fortran x3.9-1978, has been developed by the
        !            34: c     federal cobol compiler testing service.  the fortran compiler
        !            35: c     validation system (fcvs) consists of audit routines, their related
        !            36: c     data, and an executive system.  each audit routine is a fortran
        !            37: c     program, subprogram or function which includes tests of specific
        !            38: c     language elements and supporting procedures indicating the result
        !            39: c     of executing these tests.
        !            40: c
        !            41: c         this particular program/subprogram/function contains features
        !            42: c     found only in the subset as defined in x3.9-1978.
        !            43: c
        !            44: c         suggestions and comments should be forwarded to -
        !            45: c
        !            46: c                  department of the navy
        !            47: c                  federal cobol compiler testing service
        !            48: c                  washington, d.c.  20376
        !            49: c
        !            50: c      **********************************************************
        !            51: c
        !            52: c
        !            53: c
        !            54: c     initialization section
        !            55: c
        !            56: c     initialize constants
        !            57: c      **************
        !            58: c     i01 contains the logical unit number for the card reader.
        !            59:       i01 = 5
        !            60: c     i02 contains the logical unit number for the printer.
        !            61:       i02 = 6
        !            62: c     system environment section
        !            63: c
        !            64: cx010    this card is replaced by contents of fexec x-010 control card.
        !            65: c     the cx010 card is for overriding the program default i01 = 5
        !            66: c     (unit number for card reader).
        !            67: cx011    this card is replaced by contents of fexec x-011 control card.
        !            68: c     the cx011 card is for systems which require additional
        !            69: c     fortran statements for files associated with cx010 above.
        !            70: c
        !            71: cx020    this card is replaced by contents of fexec x-020 control card.
        !            72: c     the cx020 card is for overriding the program default i02 = 6
        !            73: c     (unit number for printer).
        !            74: cx021    this card is replaced by contents of fexec x-021 control card.
        !            75: c     the cx021 card is for systems which require additional
        !            76: c     fortran statements for files associated with cx020 above.
        !            77: c
        !            78:       ivpass=0
        !            79:       ivfail=0
        !            80:       ivdele=0
        !            81:       iczero=0
        !            82: c
        !            83: c     write page headers
        !            84:       write (i02,90000)
        !            85:       write (i02,90001)
        !            86:       write (i02,90002)
        !            87:       write (i02, 90002)
        !            88:       write (i02,90003)
        !            89:       write (i02,90002)
        !            90:       write (i02,90004)
        !            91:       write (i02,90002)
        !            92:       write (i02,90011)
        !            93:       write (i02,90002)
        !            94:       write (i02,90002)
        !            95:       write (i02,90005)
        !            96:       write (i02,90006)
        !            97:       write (i02,90002)
        !            98: c
        !            99: c     test section
        !           100: c
        !           101: c         arithmetic assignment statement
        !           102: c
        !           103: c     test 395 through test 414 contain an integer variable, an integer
        !           104: c     constant, and operator * in an arithmetic expression.
        !           105: c
        !           106: c     test 395 through test 406     -  iv= iv * ic
        !           107: c
        !           108: c         test 395 through test 398
        !           109: c              positive integer variable, positive integer constant
        !           110: c
        !           111:  3951 continue
        !           112:       ivtnum = 395
        !           113: c
        !           114: c      ****  test 395  ****
        !           115: c
        !           116:       if (iczero) 33950, 3950, 33950
        !           117:  3950 continue
        !           118:       ivon01 = 2
        !           119:       ivcomp = ivon01 * 3
        !           120:       go to 43950
        !           121: 33950 ivdele = ivdele + 1
        !           122:       write (i02,80003) ivtnum
        !           123:       if (iczero) 43950, 3961, 43950
        !           124: 43950 if (ivcomp -6) 23950,13950,23950
        !           125: 13950 ivpass = ivpass + 1
        !           126:       write (i02,80001) ivtnum
        !           127:       go to 3961
        !           128: 23950 ivfail = ivfail + 1
        !           129:       ivcorr =6
        !           130:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           131:  3961 continue
        !           132:       ivtnum = 396
        !           133: c
        !           134: c      ****  test 396  ****
        !           135: c
        !           136:       if (iczero) 33960, 3960, 33960
        !           137:  3960 continue
        !           138:       ivon01 = 13
        !           139:       ivcomp = ivon01 * 11
        !           140:       go to 43960
        !           141: 33960 ivdele = ivdele + 1
        !           142:       write (i02,80003) ivtnum
        !           143:       if (iczero) 43960, 3971, 43960
        !           144: 43960 if (ivcomp - 143) 23960,13960,23960
        !           145: 13960 ivpass = ivpass + 1
        !           146:       write (i02,80001) ivtnum
        !           147:       go to 3971
        !           148: 23960 ivfail = ivfail + 1
        !           149:       ivcorr = 143
        !           150:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           151:  3971 continue
        !           152:       ivtnum = 397
        !           153: c
        !           154: c      ****  test 397  ****
        !           155: c
        !           156:       if (iczero) 33970, 3970, 33970
        !           157:  3970 continue
        !           158:       ivon01 = 223
        !           159:       ivcomp = ivon01 * 99
        !           160:       go to 43970
        !           161: 33970 ivdele = ivdele + 1
        !           162:       write (i02,80003) ivtnum
        !           163:       if (iczero) 43970, 3981, 43970
        !           164: 43970 if (ivcomp - 22077) 23970,13970,23970
        !           165: 13970 ivpass = ivpass + 1
        !           166:       write (i02,80001) ivtnum
        !           167:       go to 3981
        !           168: 23970 ivfail = ivfail + 1
        !           169:       ivcorr = 22077
        !           170:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           171:  3981 continue
        !           172:       ivtnum = 398
        !           173: c
        !           174: c      ****  test 398  ****
        !           175: c
        !           176:       if (iczero) 33980, 3980, 33980
        !           177:  3980 continue
        !           178:       ivon01 = 11235
        !           179:       ivcomp = ivon01 * 2
        !           180:       go to 43980
        !           181: 33980 ivdele = ivdele + 1
        !           182:       write (i02,80003) ivtnum
        !           183:       if (iczero) 43980, 3991, 43980
        !           184: 43980 if (ivcomp - 22470) 23980,13980,23980
        !           185: 13980 ivpass = ivpass + 1
        !           186:       write (i02,80001) ivtnum
        !           187:       go to 3991
        !           188: 23980 ivfail = ivfail + 1
        !           189:       ivcorr = 22470
        !           190:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           191: c
        !           192: c         test 399 through test 402
        !           193: c             negative integer variable, positive integer constant
        !           194: c
        !           195:  3991 continue
        !           196:       ivtnum = 399
        !           197: c
        !           198: c       ****  test 399  ****
        !           199: c
        !           200:       if (iczero) 33990, 3990, 33990
        !           201:  3990 continue
        !           202:       ivon01 = -2
        !           203:       ivcomp = ivon01 * 3
        !           204:       go to 43990
        !           205: 33990 ivdele = ivdele + 1
        !           206:       write (i02,80003) ivtnum
        !           207:       if (iczero) 43990, 4001, 43990
        !           208: 43990 if (ivcomp +6) 23990,13990,23990
        !           209: 13990 ivpass = ivpass + 1
        !           210:       write (i02,80001) ivtnum
        !           211:       go to 4001
        !           212: 23990 ivfail = ivfail + 1
        !           213:       ivcorr = -6
        !           214:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           215:  4001 continue
        !           216:       ivtnum = 400
        !           217: c
        !           218: c      ****  test 400  ****
        !           219: c
        !           220:       if (iczero) 34000, 4000, 34000
        !           221:  4000 continue
        !           222:       ivon01 = -13
        !           223:       ivcomp =ivon01*11
        !           224:       go to 44000
        !           225: 34000 ivdele = ivdele + 1
        !           226:       write (i02,80003) ivtnum
        !           227:       if (iczero) 44000, 4011, 44000
        !           228: 44000 if (ivcomp +143) 24000,14000,24000
        !           229: 14000 ivpass = ivpass + 1
        !           230:       write (i02,80001) ivtnum
        !           231:       go to 4011
        !           232: 24000 ivfail = ivfail + 1
        !           233:       ivcorr = -143
        !           234:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           235:  4011 continue
        !           236:       ivtnum = 401
        !           237: c
        !           238: c       ****  test 401  ****
        !           239: c
        !           240:       if (iczero) 34010, 4010, 34010
        !           241:  4010 continue
        !           242:       ivon01 = -223
        !           243:       ivcomp = ivon01*99
        !           244:       go to 44010
        !           245: 34010 ivdele = ivdele + 1
        !           246:       write (i02,80003) ivtnum
        !           247:       if (iczero) 44010, 4021, 44010
        !           248: 44010 if (ivcomp + 22077) 24010,14010,24010
        !           249: 14010 ivpass = ivpass + 1
        !           250:       write (i02,80001) ivtnum
        !           251:       go to 4021
        !           252: 24010 ivfail = ivfail + 1
        !           253:       ivcorr = -22077
        !           254:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           255:  4021 continue
        !           256:       ivtnum = 402
        !           257: c
        !           258: c       ****  test 402  ****
        !           259: c
        !           260:       if (iczero) 34020, 4020, 34020
        !           261:  4020 continue
        !           262:       ivon01 = -11235
        !           263:       ivcomp = ivon01*2
        !           264:       go to 44020
        !           265: 34020 ivdele = ivdele + 1
        !           266:       write (i02,80003) ivtnum
        !           267:       if (iczero) 44020, 4031, 44020
        !           268: 44020 if (ivcomp+22470) 24020,14020,24020
        !           269: 14020 ivpass = ivpass + 1
        !           270:       write (i02,80001) ivtnum
        !           271:       go to 4031
        !           272: 24020 ivfail = ivfail + 1
        !           273:       ivcorr = -22470
        !           274:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           275: c
        !           276: c          test 403 and test 404
        !           277: c              negative integer variable, negative integer constant
        !           278: c
        !           279:  4031 continue
        !           280:       ivtnum = 403
        !           281: c
        !           282: c       ****  test 403  ****
        !           283: c
        !           284:       if (iczero) 34030, 4030, 34030
        !           285:  4030 continue
        !           286:       ivon01=-2
        !           287:       ivcomp = ivon01*(-3)
        !           288:       go to 44030
        !           289: 34030 ivdele = ivdele + 1
        !           290:       write (i02,80003) ivtnum
        !           291:       if (iczero) 44030, 4041, 44030
        !           292: 44030 if (ivcomp -6) 24030,14030,24030
        !           293: 14030 ivpass = ivpass + 1
        !           294:       write (i02,80001) ivtnum
        !           295:       go to 4041
        !           296: 24030 ivfail = ivfail + 1
        !           297:       ivcorr =6
        !           298:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           299:  4041 continue
        !           300:       ivtnum = 404
        !           301: c
        !           302: c       ****  test 404  ****
        !           303: c
        !           304:       if (iczero) 34040, 4040, 34040
        !           305:  4040 continue
        !           306:       ivon01 = -13
        !           307:       ivcomp = ivon01 * (-11)
        !           308:       go to 44040
        !           309: 34040 ivdele = ivdele + 1
        !           310:       write (i02,80003) ivtnum
        !           311:       if (iczero) 44040, 4051, 44040
        !           312: 44040 if (ivcomp -143) 24040,14040,24040
        !           313: 14040 ivpass = ivpass + 1
        !           314:       write (i02,80001) ivtnum
        !           315:       go to 4051
        !           316: 24040 ivfail = ivfail + 1
        !           317:       ivcorr = 143
        !           318:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           319: c
        !           320: c          test 405 and test 406
        !           321: c              positive integer variable, negative integer constant
        !           322: c
        !           323:  4051 continue
        !           324:       ivtnum = 405
        !           325: c
        !           326: c       ****  test 405  ****
        !           327: c
        !           328:       if (iczero) 34050, 4050, 34050
        !           329:  4050 continue
        !           330:       ivon01 = 223
        !           331:       ivcomp = ivon01 * (-99)
        !           332:       go to 44050
        !           333: 34050 ivdele = ivdele + 1
        !           334:       write (i02,80003) ivtnum
        !           335:       if (iczero) 44050, 4061, 44050
        !           336: 44050 if (ivcomp + 22077) 24050,14050,24050
        !           337: 14050 ivpass = ivpass + 1
        !           338:       write (i02,80001) ivtnum
        !           339:       go to 4061
        !           340: 24050 ivfail = ivfail + 1
        !           341:       ivcorr = -22077
        !           342:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           343:  4061 continue
        !           344:       ivtnum = 406
        !           345: c
        !           346: c       ****  test 406  ****
        !           347: c
        !           348:       if (iczero) 34060, 4060, 34060
        !           349:  4060 continue
        !           350:       ivon01 = 11235
        !           351:       ivcomp = ivon01 * (-2)
        !           352:       go to 44060
        !           353: 34060 ivdele = ivdele + 1
        !           354:       write (i02,80003) ivtnum
        !           355:       if (iczero) 44060, 4071, 44060
        !           356: 44060 if (ivcomp + 22470) 24060,14060,24060
        !           357: 14060 ivpass = ivpass + 1
        !           358:       write (i02,80001) ivtnum
        !           359:       go to 4071
        !           360: 24060 ivfail = ivfail + 1
        !           361:       ivcorr = -22470
        !           362:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           363: c
        !           364: c      test 407 through test 414    -   iv = ic * iv
        !           365: c
        !           366: c          test 407 and test 408
        !           367: c               positive integer constant, positive integer variable
        !           368: c
        !           369:  4071 continue
        !           370:       ivtnum = 407
        !           371: c
        !           372: c       ****  test 407  ****
        !           373: c
        !           374:       if (iczero) 34070, 4070, 34070
        !           375:  4070 continue
        !           376:       ivon02 = 11
        !           377:       ivcomp = 13*ivon02
        !           378:       go to 44070
        !           379: 34070 ivdele = ivdele + 1
        !           380:       write (i02,80003) ivtnum
        !           381:       if (iczero) 44070, 4081, 44070
        !           382: 44070 if (ivcomp - 143) 24070,14070,24070
        !           383: 14070 ivpass = ivpass + 1
        !           384:       write (i02,80001) ivtnum
        !           385:       go to 4081
        !           386: 24070 ivfail = ivfail + 1
        !           387:       ivcorr = 143
        !           388:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           389:  4081 continue
        !           390:       ivtnum = 408
        !           391: c
        !           392: c       ****  test 408  ****
        !           393: c
        !           394:       if (iczero) 34080, 4080, 34080
        !           395:  4080 continue
        !           396:       ivon02 = +11
        !           397:       ivcomp = +13 * ivon02
        !           398:       go to 44080
        !           399: 34080 ivdele = ivdele + 1
        !           400:       write (i02,80003) ivtnum
        !           401:       if (iczero) 44080, 4091, 44080
        !           402: 44080 if (ivcomp - 143) 24080,14080,24080
        !           403: 14080 ivpass = ivpass + 1
        !           404:       write (i02,80001) ivtnum
        !           405:       go to 4091
        !           406: 24080 ivfail = ivfail + 1
        !           407:       ivcorr = 143
        !           408:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           409: c
        !           410: c          test 409 and test 410
        !           411: c               positive integer constant, negative integer variable
        !           412: c
        !           413:  4091 continue
        !           414:       ivtnum = 409
        !           415: c
        !           416: c       ****  test 409  ****
        !           417: c
        !           418:       if (iczero) 34090, 4090, 34090
        !           419:  4090 continue
        !           420:       ivon02 = -99
        !           421:       ivcomp = 223 * ivon02
        !           422:       go to 44090
        !           423: 34090 ivdele = ivdele + 1
        !           424:       write (i02,80003) ivtnum
        !           425:       if (iczero) 44090, 4101, 44090
        !           426: 44090 if (ivcomp + 22077) 24090,14090,24090
        !           427: 14090 ivpass = ivpass + 1
        !           428:       write (i02,80001) ivtnum
        !           429:       go to 4101
        !           430: 24090 ivfail = ivfail + 1
        !           431:       ivcorr =-22077
        !           432:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           433:  4101 continue
        !           434:       ivtnum = 410
        !           435: c
        !           436: c       ****  test 410  ****
        !           437: c
        !           438:       if (iczero) 34100, 4100, 34100
        !           439:  4100 continue
        !           440:       ivon02 = -99
        !           441:       ivcomp = +223*ivon02
        !           442:       go to 44100
        !           443: 34100 ivdele = ivdele + 1
        !           444:       write (i02,80003) ivtnum
        !           445:       if (iczero) 44100, 4111, 44100
        !           446: 44100 if (ivcomp + 22077) 24100,14100,24100
        !           447: 14100 ivpass = ivpass + 1
        !           448:       write (i02,80001) ivtnum
        !           449:       go to 4111
        !           450: 24100 ivfail = ivfail + 1
        !           451:       ivcorr = -22077
        !           452:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           453: c
        !           454: c          test 411 and test 412
        !           455: c              negative integer constant, positive integer variable
        !           456: c
        !           457:  4111 continue
        !           458:       ivtnum = 411
        !           459: c
        !           460: c       ****  test 411  ****
        !           461: c
        !           462:       if (iczero) 34110, 4110, 34110
        !           463:  4110 continue
        !           464:       ivon02 = 2
        !           465:       ivcomp = (-11235) * ivon02
        !           466:       go to 44110
        !           467: 34110 ivdele = ivdele + 1
        !           468:       write (i02,80003) ivtnum
        !           469:       if (iczero) 44110, 4121, 44110
        !           470: 44110 if (ivcomp + 22470) 24110,14110,24110
        !           471: 14110 ivpass = ivpass + 1
        !           472:       write (i02,80001) ivtnum
        !           473:       go to 4121
        !           474: 24110 ivfail = ivfail + 1
        !           475:       ivcorr = -22470
        !           476:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           477:  4121 continue
        !           478:       ivtnum = 412
        !           479: c
        !           480: c       ****  test 412  ****
        !           481: c
        !           482:       if (iczero) 34120, 4120, 34120
        !           483:  4120 continue
        !           484:       ivon02 = +2
        !           485:       ivcomp = -11235 * ivon02
        !           486:       go to 44120
        !           487: 34120 ivdele = ivdele + 1
        !           488:       write (i02,80003) ivtnum
        !           489:       if (iczero) 44120, 4131, 44120
        !           490: 44120 if (ivcomp + 22470) 24120,14120,24120
        !           491: 14120 ivpass=ivpass + 1
        !           492:       write (i02,80001) ivtnum
        !           493:       go to 4131
        !           494: 24120 ivfail = ivfail + 1
        !           495:       ivcorr = -22470
        !           496:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           497: c
        !           498: c          test 413 and test 414
        !           499: c                negative integer constant, negative integer variable
        !           500: c
        !           501:  4131 continue
        !           502:       ivtnum = 413
        !           503: c
        !           504: c       ****  test 413  ****
        !           505: c
        !           506:       if (iczero) 34130, 4130, 34130
        !           507:  4130 continue
        !           508:       ivon02 = -3
        !           509:       ivcomp = (-2) * ivon02
        !           510:       go to 44130
        !           511: 34130 ivdele = ivdele + 1
        !           512:       write (i02,80003) ivtnum
        !           513:       if (iczero) 44130, 4141, 44130
        !           514: 44130 if (ivcomp - 6) 24130,14130,24130
        !           515: 14130 ivpass = ivpass + 1
        !           516:       write (i02,80001) ivtnum
        !           517:       go to 4141
        !           518: 24130 ivfail = ivfail + 1
        !           519:       ivcorr = 6
        !           520:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           521:  4141 continue
        !           522:       ivtnum = 414
        !           523: c
        !           524: c       ****  test 414  ****
        !           525: c
        !           526:       if (iczero) 34140, 4140, 34140
        !           527:  4140 continue
        !           528:       ivon02 = -3
        !           529:       ivcomp = -2 * ivon02
        !           530:       go to 44140
        !           531: 34140 ivdele = ivdele + 1
        !           532:       write (i02,80003) ivtnum
        !           533:       if (iczero) 44140, 4151, 44140
        !           534: 44140 if (ivcomp - 6) 24140,14140,24140
        !           535: 14140 ivpass = ivpass + 1
        !           536:       write (i02,80001) ivtnum
        !           537:       go to 4151
        !           538: 24140 ivfail = ivfail + 1
        !           539:       ivcorr = 6
        !           540:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           541: c
        !           542: c      test 415  through test 429 contain two integer constants,
        !           543: c      one integer variable and operator * in arithmetic expression.
        !           544: c
        !           545:  4151 continue
        !           546:       ivtnum = 415
        !           547: c
        !           548: c       ****  test 415  ****
        !           549: c
        !           550:       if (iczero) 34150, 4150, 34150
        !           551:  4150 continue
        !           552:       ivon01 = 2
        !           553:       ivcomp = ivon01 * 3 * 4
        !           554:       go to 44150
        !           555: 34150 ivdele = ivdele + 1
        !           556:       write (i02,80003) ivtnum
        !           557:       if (iczero) 44150, 4161, 44150
        !           558: 44150 if (ivcomp - 24) 24150,14150,24150
        !           559: 14150 ivpass = ivpass + 1
        !           560:       write (i02,80001) ivtnum
        !           561:       go to 4161
        !           562: 24150 ivfail = ivfail + 1
        !           563:       ivcorr = 24
        !           564:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           565:  4161 continue
        !           566:       ivtnum = 416
        !           567: c
        !           568: c       ****  test 416  ****
        !           569: c
        !           570:       if (iczero) 34160, 4160, 34160
        !           571:  4160 continue
        !           572:       ivon01 = -2
        !           573:       ivcomp = ivon01 *3*4
        !           574:       go to 44160
        !           575: 34160 ivdele = ivdele + 1
        !           576:       write (i02,80003) ivtnum
        !           577:       if (iczero) 44160, 4171, 44160
        !           578: 44160 if (ivcomp +24) 24160,14160,24160
        !           579: 14160 ivpass = ivpass + 1
        !           580:       write (i02,80001) ivtnum
        !           581:       go to 4171
        !           582: 24160 ivfail = ivfail + 1
        !           583:       ivcorr = -24
        !           584:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           585:  4171 continue
        !           586:       ivtnum = 417
        !           587: c
        !           588: c       ****  test 417  ****
        !           589: c
        !           590:       if (iczero) 34170, 4170, 34170
        !           591:  4170 continue
        !           592:       ivon01 = -2
        !           593:       ivcomp = ivon01*3*(-4)
        !           594:       go to 44170
        !           595: 34170 ivdele = ivdele + 1
        !           596:       write (i02,80003) ivtnum
        !           597:       if (iczero) 44170, 4181, 44170
        !           598: 44170 if (ivcomp -24) 24170,14170,24170
        !           599: 14170 ivpass = ivpass + 1
        !           600:       write (i02,80001) ivtnum
        !           601:       go to 4181
        !           602: 24170 ivfail = ivfail + 1
        !           603:       ivcorr = 24
        !           604:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           605:  4181 continue
        !           606:       ivtnum = 418
        !           607: c
        !           608: c       ****  test 418  ****
        !           609: c
        !           610:       if (iczero) 34180, 4180, 34180
        !           611:  4180 continue
        !           612:       ivon01 = -2
        !           613:       ivcomp = ivon01*(-3)*(-4)
        !           614:       go to 44180
        !           615: 34180 ivdele = ivdele + 1
        !           616:       write (i02,80003) ivtnum
        !           617:       if (iczero) 44180, 4191, 44180
        !           618: 44180 if (ivcomp +24) 24180,14180,24180
        !           619: 14180 ivpass = ivpass + 1
        !           620:       write (i02,80001) ivtnum
        !           621:       go to 4191
        !           622: 24180 ivfail = ivfail + 1
        !           623:       ivcorr = -24
        !           624:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           625:  4191 continue
        !           626:       ivtnum = 419
        !           627: c
        !           628: c       ****  test 419  ****
        !           629: c
        !           630:       if (iczero) 34190, 4190, 34190
        !           631:  4190 continue
        !           632:       ivon02 = 51
        !           633:       ivcomp = 23*ivon02*13
        !           634:       go to 44190
        !           635: 34190 ivdele = ivdele + 1
        !           636:       write (i02,80003) ivtnum
        !           637:       if (iczero) 44190, 4201, 44190
        !           638: 44190 if (ivcomp-15249) 24190,14190,24190
        !           639: 14190 ivpass = ivpass + 1
        !           640:       write (i02,80001) ivtnum
        !           641:       go to 4201
        !           642: 24190 ivfail = ivfail + 1
        !           643:       ivcorr = 15249
        !           644:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           645:  4201 continue
        !           646:       ivtnum = 420
        !           647: c
        !           648: c       ****  test 420  ****
        !           649: c
        !           650:       if (iczero) 34200, 4200, 34200
        !           651:  4200 continue
        !           652:       ivon02 = -51
        !           653:       ivcomp = 23*ivon02*(-13)
        !           654:       go to 44200
        !           655: 34200 ivdele = ivdele + 1
        !           656:       write (i02,80003) ivtnum
        !           657:       if (iczero) 44200, 4211, 44200
        !           658: 44200 if (ivcomp - 15249) 24200,14200,24200
        !           659: 14200 ivpass = ivpass + 1
        !           660:       write (i02,80001) ivtnum
        !           661:       go to 4211
        !           662: 24200 ivfail = ivfail + 1
        !           663:       ivcorr = 15249
        !           664:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           665:  4211 continue
        !           666:       ivtnum = 421
        !           667: c
        !           668: c       ****  test 421  ****
        !           669: c
        !           670:       if (iczero) 34210, 4210, 34210
        !           671:  4210 continue
        !           672:       ivon02 = -51
        !           673:       ivcomp = 23*ivon02*13
        !           674:       go to 44210
        !           675: 34210 ivdele = ivdele + 1
        !           676:       write (i02,80003) ivtnum
        !           677:       if (iczero) 44210, 4221, 44210
        !           678: 44210 if (ivcomp+15249) 24210,14210,24210
        !           679: 14210 ivpass = ivpass + 1
        !           680:       write (i02,80001) ivtnum
        !           681:       go to 4221
        !           682: 24210 ivfail = ivfail + 1
        !           683:       ivcorr = -15249
        !           684:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           685:  4221 continue
        !           686:       ivtnum = 422
        !           687: c
        !           688: c       ****  test 422  ****
        !           689: c
        !           690:       if (iczero) 34220, 4220, 34220
        !           691:  4220 continue
        !           692:       ivon02 = -51
        !           693:       ivcomp =(-23)*ivon02*(-13)
        !           694:       go to 44220
        !           695: 34220 ivdele = ivdele + 1
        !           696:       write (i02,80003) ivtnum
        !           697:       if (iczero) 44220, 4231, 44220
        !           698: 44220 if (ivcomp+15249) 24220,14220,24220
        !           699: 14220 ivpass = ivpass + 1
        !           700:       write (i02,80001) ivtnum
        !           701:       go to 4231
        !           702: 24220 ivfail = ivfail + 1
        !           703:       ivcorr = -15249
        !           704:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           705:  4231 continue
        !           706:       ivtnum = 423
        !           707: c
        !           708: c       ****  test 423  ****
        !           709: c
        !           710:       if (iczero) 34230, 4230, 34230
        !           711:  4230 continue
        !           712:       ivon03 = 5461
        !           713:       ivcomp = 2*3*ivon03
        !           714:       go to 44230
        !           715: 34230 ivdele = ivdele + 1
        !           716:       write (i02,80003) ivtnum
        !           717:       if (iczero) 44230, 4241, 44230
        !           718: 44230 if (ivcomp - 32766) 24230,14230,24230
        !           719: 14230 ivpass = ivpass + 1
        !           720:       write (i02,80001) ivtnum
        !           721:       go to 4241
        !           722: 24230 ivfail = ivfail + 1
        !           723:       ivcorr = 32766
        !           724:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           725:  4241 continue
        !           726:       ivtnum = 424
        !           727: c
        !           728: c       ****  test 424  ****
        !           729: c
        !           730:       if (iczero) 34240, 4240, 34240
        !           731:  4240 continue
        !           732:       ivon03 = -5461
        !           733:       ivcomp = 2*3*ivon03
        !           734:       go to 44240
        !           735: 34240 ivdele = ivdele + 1
        !           736:       write (i02,80003) ivtnum
        !           737:       if (iczero) 44240, 4251, 44240
        !           738: 44240 if (ivcomp +32766) 24240,14240,24240
        !           739: 14240 ivpass = ivpass + 1
        !           740:       write (i02,80001) ivtnum
        !           741:       go to 4251
        !           742: 24240 ivfail = ivfail + 1
        !           743:       ivcorr = -32766
        !           744:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           745:  4251 continue
        !           746:       ivtnum = 425
        !           747: c
        !           748: c       ****  test 425  ****
        !           749: c
        !           750:       if (iczero) 34250, 4250, 34250
        !           751:  4250 continue
        !           752:       ivon03 = -5461
        !           753:       ivcomp = -2*3*ivon03
        !           754:       go to 44250
        !           755: 34250 ivdele = ivdele + 1
        !           756:       write (i02,80003) ivtnum
        !           757:       if (iczero) 44250, 4261, 44250
        !           758: 44250 if (ivcomp - 32766) 24250,14250,24250
        !           759: 14250 ivpass = ivpass + 1
        !           760:       write (i02,80001) ivtnum
        !           761:       go to 4261
        !           762: 24250 ivfail = ivfail + 1
        !           763:       ivcorr = 32766
        !           764:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           765: c
        !           766: c      test 426 through test 429 use parentheses to group elements
        !           767: c      in arithmetic expression.
        !           768: c
        !           769:  4261 continue
        !           770:       ivtnum = 426
        !           771: c
        !           772: c       ****  test 426  ****
        !           773: c
        !           774:       if (iczero) 34260, 4260, 34260
        !           775:  4260 continue
        !           776:       ivon02 = 51
        !           777:       ivcomp = (23*ivon02)*13
        !           778:       go to 44260
        !           779: 34260 ivdele = ivdele + 1
        !           780:       write (i02,80003) ivtnum
        !           781:       if (iczero) 44260, 4271, 44260
        !           782: 44260 if (ivcomp -15249) 24260,14260,24260
        !           783: 14260 ivpass = ivpass + 1
        !           784:       write (i02,80001) ivtnum
        !           785:       go to 4271
        !           786: 24260 ivfail = ivfail + 1
        !           787:       ivcorr = 15249
        !           788:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           789:  4271 continue
        !           790:       ivtnum = 427
        !           791: c
        !           792: c       ****  test 427  ****
        !           793: c
        !           794:       if (iczero) 34270, 4270, 34270
        !           795:  4270 continue
        !           796:       ivon02 = 51
        !           797:       ivcomp = 23*(ivon02*13)
        !           798:       go to 44270
        !           799: 34270 ivdele = ivdele + 1
        !           800:       write (i02,80003) ivtnum
        !           801:       if (iczero) 44270, 4281, 44270
        !           802: 44270 if (ivcomp-15249) 24270,14270,24270
        !           803: 14270 ivpass = ivpass + 1
        !           804:       write (i02,80001) ivtnum
        !           805:       go to 4281
        !           806: 24270 ivfail = ivfail + 1
        !           807:       ivcorr = 15249
        !           808:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           809:  4281 continue
        !           810:       ivtnum = 428
        !           811: c
        !           812: c       ****  test 428  ****
        !           813: c
        !           814:       if (iczero) 34280, 4280, 34280
        !           815:  4280 continue
        !           816:       ivon02 = -51
        !           817:       ivcomp = -23 * (ivon02*(+13))
        !           818:       go to 44280
        !           819: 34280 ivdele = ivdele + 1
        !           820:       write (i02,80003) ivtnum
        !           821:       if (iczero) 44280, 4291, 44280
        !           822: 44280 if (ivcomp - 15249)24280,14280,24280
        !           823: 14280 ivpass = ivpass + 1
        !           824:       write (i02,80001) ivtnum
        !           825:       go to 4291
        !           826: 24280 ivfail = ivfail + 1
        !           827:       ivcorr = 15249
        !           828:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           829:  4291 continue
        !           830:       ivtnum = 429
        !           831: c
        !           832: c       ****  test 429  ****
        !           833: c
        !           834:       if (iczero) 34290, 4290, 34290
        !           835:  4290 continue
        !           836:       ivon02 = -51
        !           837:       ivcomp = (-23)*(ivon02*(-13))
        !           838:       go to 44290
        !           839: 34290 ivdele = ivdele + 1
        !           840:       write (i02,80003) ivtnum
        !           841:       if (iczero) 44290, 4301, 44290
        !           842: 44290 if (ivcomp + 15249) 24290,14290,24290
        !           843: 14290 ivpass = ivpass + 1
        !           844:       write (i02,80001) ivtnum
        !           845:       go to 4301
        !           846: 24290 ivfail = ivfail + 1
        !           847:       ivcorr = -15249
        !           848:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           849: c     ****   end of tests   ****
        !           850:  4301 continue
        !           851: c
        !           852: c     write page footings and run summaries
        !           853: 99999 continue
        !           854:       write (i02,90002)
        !           855:       write (i02,90006)
        !           856:       write (i02,90002)
        !           857:       write (i02,90002)
        !           858:       write (i02,90007)
        !           859:       write (i02,90002)
        !           860:       write (i02,90008)  ivfail
        !           861:       write (i02,90009) ivpass
        !           862:       write (i02,90010) ivdele
        !           863: c
        !           864: c
        !           865: c     terminate routine execution
        !           866:       stop
        !           867: c
        !           868: c     format statements for page headers
        !           869: 90000 format (1h1)
        !           870: 90002 format (1h )
        !           871: 90001 format (1h ,10x,34hfortran compiler validation system)
        !           872: 90003 format (1h ,21x,11hversion 1.0)
        !           873: 90004 format (1h ,10x,38hfor official use only - copyright 1978)
        !           874: 90005 format (1h ,5x,4htest,5x,9hpass/fail, 5x,8hcomputed,8x,7hcorrect)
        !           875: 90006 format (1h ,5x,46h----------------------------------------------)
        !           876: 90011 format (1h ,18x,17hsubset level test)
        !           877: c
        !           878: c     format statements for run summaries
        !           879: 90008 format (1h ,15x,i5,19h errors encountered)
        !           880: 90009 format (1h ,15x,i5,13h tests passed)
        !           881: 90010 format (1h ,15x,i5,14h tests deleted)
        !           882: c
        !           883: c     format statements for test results
        !           884: 80001 format (1h ,4x,i5,7x,4hpass)
        !           885: 80002 format (1h ,4x,i5,7x,4hfail)
        !           886: 80003 format (1h ,4x,i5,7x,7hdeleted)
        !           887: 80004 format (1h ,4x,i5,7x,4hfail,10x,i6,9x,i6)
        !           888: 80005 format (1h ,4x,i5,7x,4hfail,4x,e12.5,3x,e12.5)
        !           889: c
        !           890: 90007 format (1h ,20x,20hend of program fm034)
        !           891:       end

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