Annotation of researchv10no/cmd/spitbol/test2.spt, revision 1.1

1.1     ! root        1: -TITLE  SPITBOL TEST PROGRAM #2 -- DIAGNOSTICS PHASE TWO
        !             2: -IN80
        !             3: *
        !             4:         OUTPUT  = 'TEST #2 '
        !             5: *
        !             6: *
        !             7: *   THIS IS THE STANDARD TEST PROGRAM FOR SPITBOL WHICH
        !             8: *   TESTS PATTERN MATCHING
        !             9: *
        !            10:         &ANCHOR = 0
        !            11:         &ANCHOR = 0
        !            12:         DEFINE('ERROR()')
        !            13:         &TRACE  = 1000
        !            14:         &ERRLIMIT = 100
        !            15:         TRACE(.ERRTYPE,'KEYWORD')
        !            16:         OUTPUT  = '**********************************************'
        !            17:         OUTPUT  = '**** SPITBOL DIAGNOSTICS -- PHASE TWO     ****'
        !            18:         OUTPUT  = '**********************************************'
        !            19: FLOOP   ERRCOUNT = 0
        !            20:         TEST    = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        !            21: *
        !            22: *   TEST PATTERN MATCHING AGAINST SIMPLE STRING
        !            23: *
        !            24:         TEST  'ABC'                                     :S(S01) ; ERROR()
        !            25: S01     TEST 'BCD'                                      :S(S02) ; ERROR()
        !            26: S02     TEST 'XYZ'                                      :S(S03) ; ERROR()
        !            27: S03     TEST 'ABD'                                      :F(S04) ; ERROR()
        !            28: S04     &ANCHOR = 1
        !            29:         TEST 'ABC'                                      :S(S05) ; ERROR()
        !            30: S05     TEST 'BCD'                                      :F(S06) ; ERROR()
        !            31: S06     TEST TEST                                       :S(S06A) ; ERROR()
        !            32: *
        !            33: *   TEST SIMPLE CASES OF $
        !            34: *
        !            35: S06A    TEST 'ABC' $ VAR                                :S(S07) ; ERROR()
        !            36: S07     IDENT(VAR,'ABC')                                :S(S08) ; ERROR()
        !            37: S08     TEST 'ABC' . VARD                               :S(S09) ; ERROR()
        !            38: S09     IDENT(VARD,'ABC')                               :S(S10) ; ERROR()
        !            39: *
        !            40: *   TEST LEN
        !            41: *
        !            42: S10     &ANCHOR = 0
        !            43:         TEST LEN(3) $ VARL                              :S(S11) ; ERROR()
        !            44: S11     IDENT(VARL,'ABC')                               :S(S12) ; ERROR()
        !            45: S12     TEST LEN(26) $ VARL                             :S(S13) ; ERROR()
        !            46: S13     IDENT(VARL,TEST)                                :S(S14) ; ERROR()
        !            47: S14     TEST LEN(27)                                    :F(S15) ; ERROR()
        !            48: *
        !            49: *   TEST TAB
        !            50: *
        !            51: S15     TEST TAB(3) $ VART                              :S(S16) ; ERROR()
        !            52: S16     IDENT(VART,'ABC')                               :S(S17) ; ERROR()
        !            53: S17     TEST TAB(26) $ VART                             :S(S18) ; ERROR()
        !            54: S18     IDENT(TEST,VART)                                :S(S19) ; ERROR()
        !            55: S19     TEST TAB(0) $ VART                              :S(S20) ; ERROR()
        !            56: S20     IDENT(VART)                                     :S(S21) ; ERROR()
        !            57: *
        !            58: *   TEST ARB
        !            59: *
        !            60: S21     TEST ARB $ VARA 'C'                             :S(S22) ; ERROR()
        !            61: S22     IDENT(VARA,'AB')                                :S(S23) ; ERROR()
        !            62: S23     &ANCHOR = 1
        !            63:         TEST ARB $ VARA POS(60)                         :F(S24) ; ERROR()
        !            64: S24     IDENT(VARA,TEST)                                :S(S25) ; ERROR()
        !            65: *
        !            66: *   TEST POS
        !            67: *
        !            68: S25     TEST ARB $ VARA POS(2) $ VARP                   :S(S26) ; ERROR()
        !            69: S26     (IDENT(VARA,'AB') IDENT(VARP))                  :S(S27) ; ERROR()
        !            70: S27     &ANCHOR = 0
        !            71:         TEST ARB $ VARA POS(26) $ VARP                  :S(S28) ; ERROR()
        !            72: S28     (IDENT(VARA,TEST) IDENT(VARP)) : S(S29) ; ERROR()
        !            73: S29     TEST ARB $ VARA POS(0) $ VARP                   :S(S30) ; ERROR()
        !            74: S30     IDENT(VARA VARP)                                :S(S31) ; ERROR()
        !            75: S31     TEST POS(0) ARB $ VARA POS(26)                  :S(S32) ; ERROR()
        !            76: S32     IDENT(TEST,VARA)                                :S(S33) ; ERROR()
        !            77: S33     TEST POS(2) ARB $ VARA POS(3)                   :S(S34) ; ERROR()
        !            78: S34     IDENT(VARA,'C')                                 :S(S35) ; ERROR()
        !            79: S35     TEST POS(27)                                    :F(S36) ; ERROR()
        !            80: *
        !            81: *   TEST RPOS
        !            82: *
        !            83: S36     TEST ARB $ VARA RPOS(25)                        :S(S37) ; ERROR()
        !            84: S37     IDENT(VARA,'A')                                 :S(S38) ; ERROR()
        !            85: S38     TEST ARB $ VARA RPOS(0)                         :S(S39) ; ERROR()
        !            86: S39     IDENT(TEST,VARA)                                :S(S39A) ; ERROR()
        !            87: S39A    TEST ARB $ VARA RPOS(26)                        :S(S40) ; ERROR()
        !            88: S40     IDENT(VARA)                                     :S(S41) ; ERROR()
        !            89: S41     TEST RPOS(27)                                   :F(S42) ; ERROR()
        !            90: *
        !            91: *   TEST RTAB
        !            92: *
        !            93: S42     TEST RTAB(26) $ VARA                            :S(S43) ; ERROR()
        !            94: S43     IDENT(VARA)                                     :S(S44) ; ERROR()
        !            95: S44     TEST RTAB(27)                                   :F(S45) ; ERROR()
        !            96: S45     TEST RTAB(0) $ VARA                             :S(S46) ; ERROR()
        !            97: S46     IDENT(VARA,TEST)                                :S(S47) ; ERROR()
        !            98: S47     TEST RTAB(25) $ VARA                            :S(S48) ; ERROR()
        !            99: S48     IDENT(VARA,'A')                                 :S(S49) ; ERROR()
        !           100: *
        !           101: *   TEST @
        !           102: *
        !           103: S49     TEST LEN(6) @VARA                               :S(S50) ; ERROR()
        !           104: S50     IDENT(VARA,6)                                   :S(S51) ; ERROR()
        !           105: S51     TEST @VARA                                      :S(S52) ; ERROR()
        !           106: S52     IDENT(VARA,0)                                   :S(S53) ; ERROR()
        !           107: S53     TEST LEN(26) @VARA                              :S(S54) ; ERROR()
        !           108: S54     IDENT(VARA,26)                                  :S(S55) ; ERROR()
        !           109: *
        !           110: *   TEST BREAK
        !           111: *
        !           112: S55     TEST BREAK('C') $ VARA                          :S(S56) ; ERROR()
        !           113: S56     IDENT(VARA,'AB')                                :S(S57) ; ERROR()
        !           114: S57     TEST BREAK('Z()') $ VARA                        :S(S58)     ; ERROR()
        !           115: S58     IDENT(VARA,'ABCDEFGHIJKLMNOPQRSTUVWXY')         :S(S59) ; ERROR()
        !           116: S59     TEST BREAK(',')                                 :F(S60) ; ERROR()
        !           117: S60     LPAD(TEST,1000) BREAK('A') $ VARA               :S(S61) ; ERROR()
        !           118: S61     IDENT(LPAD(' ',1000 - 26),VARA)                 :S(S62) ; ERROR()
        !           119: S62     LPAD(TEST,1000) BREAK(',')                      :F(S63) ; ERROR()
        !           120: *
        !           121: *   TEST SPAN
        !           122: *
        !           123: S63     TEST SPAN(TEST) $ VARA                          :S(S64) ; ERROR()
        !           124: S64     IDENT(TEST,VARA)                                :S(S65) ;ERROR()
        !           125: S65     TEST SPAN('CDQ') $ VARA                         :S(S66) ; ERROR()
        !           126: S66     IDENT(VARA,'CD')                                :S(S67) ; ERROR()
        !           127: S67     TEST SPAN(',')                                  :F(S68) ; ERROR()
        !           128: S68     LPAD(TEST,1000) SPAN(' ') $ VARA                :S(S69) ; ERROR()
        !           129: S69     IDENT(VARA,LPAD(' ',1000 - 26))                 :S(S70) ; ERROR()
        !           130: *
        !           131: *   TEST BREAKX
        !           132: *
        !           133: S70     (TEST TEST) POS(0) BREAKX('E') $ VARA '.'       :F(S71) ; ERROR()
        !           134: S71     IDENT(VARA,TEST 'ABCD')                         :S(S72) ; ERROR()
        !           135: S72     TEST BREAKX('.')                                :F(S73) ; ERROR()
        !           136: *
        !           137: *   TEST ANY
        !           138: *
        !           139: S73     TEST ANY('MXZ') $ VARA                          :S(S74) ; ERROR()
        !           140: S74     IDENT(VARA,'M')                                 :S(S75) ; ERROR()
        !           141: S75     TEST ANY(',.')                                  :F(S76) ; ERROR()
        !           142: *
        !           143: *   TEST NOTANY
        !           144: *
        !           145: S76     TEST NOTANY('ABCDEFGHJKLMPQRSTUWXYZ') $ VARA    :S(S77) ; ERROR()
        !           146: S77     IDENT(VARA,'I')                                 :S(S78) ; ERROR()
        !           147: S78     TEST NOTANY(TEST)                               :F(S79) ; ERROR()
        !           148: *
        !           149: *   TEST REM
        !           150: *
        !           151: S79     TEST REM $ VARA                                 :S(S80) ; ERROR()
        !           152: S80     IDENT(VARA,TEST)                                :S(S81) ; ERROR()
        !           153: S81     TEST LEN(26) REM $ VARA                         :S(S82) ; ERROR()
        !           154: S82     IDENT(VARA)                                     :S(S83) ; ERROR()
        !           155: *
        !           156: *   TEST ALTERNATION
        !           157: *
        !           158: S83     TEST ('ABD' | 'AB') $ VARA                      :S(D84) ; ERROR()
        !           159: D84     IDENT(VARA,'AB')                                :S(D85) ; ERROR()
        !           160: D85     TEST (TEST 'A' | TEST) $ VARL                   :S(D86) ; ERROR()
        !           161: D86     IDENT(VARL,TEST)                                :S(D00) ; ERROR()
        !           162: *
        !           163: *   TEST DEFERRED STRINGS
        !           164: *
        !           165: D00     TEST *'ABC'                                     :S(D01) ; ERROR()
        !           166: D01     TEST *'ABD'                                     :F(D06) ; ERROR()
        !           167: *
        !           168: *   TEST $ . WITH DEFERRED NAME ARGUMENTS
        !           169: *
        !           170: D06     TEST 'ABC' $ *VAR                               :S(D07) ; ERROR()
        !           171: D07     IDENT(VAR,'ABC')                                :S(D08) ; ERROR()
        !           172: D08     TEST 'ABC' . *$'VARD'                           :S(D09)  ; ERROR()
        !           173: D09     IDENT(VARD,'ABC')                               :S(D10) ; ERROR()
        !           174: *
        !           175: *   TEST LEN WITH DEFERRED ARGUMENT
        !           176: *
        !           177: D10     &ANCHOR = 0
        !           178:         TEST LEN(*3) $ VARL                             :S(D11) ; ERROR()
        !           179: D11     IDENT(VARL,'ABC')                               :S(D15) ; ERROR()
        !           180: *
        !           181: *   TEST TAB WITH DEFERRED ARGUMENT
        !           182: *
        !           183: D15     TEST TAB(*3) $ VART                             :S(D16) ; ERROR()
        !           184: D16     IDENT(VART,'ABC')                               :S(D21) ; ERROR()
        !           185: *
        !           186: *   TEST POS WITH DEFERRED ARGUMENT
        !           187: *
        !           188: D21     &ANCHOR = 1
        !           189:         TEST ARB $ VARA POS(*2) $ VARP                  :S(D26) ; ERROR()
        !           190: D26     (IDENT(VARA,'AB') IDENT(VARP))                  :S(D27) ; ERROR()
        !           191: D27     &ANCHOR = 0
        !           192:         TEST ARB $ VARA POS(*0) $ VARP                  :S(D35) ; ERROR()
        !           193: D35     IDENT(VARA VARP)                                :S(D36) ; ERROR()
        !           194: *
        !           195: *   TEST RPOS WITH DEFERRED ARGUMENT
        !           196: *
        !           197: D36     TEST ARB $ VARA RPOS(*25)                       :S(D37) ; ERROR()
        !           198: D37     IDENT(VARA,'A')                                 :S(D38) ; ERROR()
        !           199: *
        !           200: *   TEST RTAB WITH DEFERRED ARGUMENT
        !           201: *
        !           202: D38     TEST RTAB(*26) $ VARA                           :S(D43) ; ERROR()
        !           203: D43     IDENT(VARA)                                     :S(D49) ; ERROR()
        !           204: *
        !           205: *   TEST @ WITH DEFERRED ARGUMENT
        !           206: *
        !           207: D49     TEST LEN(6) @*VARA                              :S(D50) ; ERROR()
        !           208: D50     IDENT(VARA,6)                                   :S(D51) ; ERROR()
        !           209: D51     TEST @*$'VARA'                                  :S(D52) ; ERROR()
        !           210: D52     IDENT(VARA,0)                                   :S(D55) ; ERROR()
        !           211: *
        !           212: *   TEST BREAK WITH DEFERRED ARGUMENT
        !           213: *
        !           214: D55     TEST BREAK(*'C') $ VARA                         :S(D56) ; ERROR()
        !           215: D56     IDENT(VARA,'AB')                                :S(D57) ; ERROR()
        !           216: *
        !           217: *   TEST SPAN WITH DEFERRED ARGUMENT
        !           218: *
        !           219: D57     TEST SPAN(*TEST) $ VARA                         :S(D64) ; ERROR()
        !           220: D64     IDENT(TEST,VARA)                                :S(D70) ; ERROR()
        !           221: *
        !           222: *   TEST BREAKX WITH DEFERRED ARGUMENT
        !           223: *
        !           224: D70     (TEST TEST) POS(*0) BREAKX(*'E') $ VARA '.'     :F(D71) ; ERROR()
        !           225: D71     IDENT(VARA,TEST 'ABCD')                         :S(D73) ; ERROR()
        !           226: *
        !           227: *   TEST ANY WITH DEFERRED ARGUMENT
        !           228: *
        !           229: D73     TEST ANY(*'MXZ') $ VARA                         :S(D74) ; ERROR()
        !           230: D74     IDENT(VARA,'M')                                 :S(D75) ; ERROR()
        !           231: *
        !           232: *   TEST NOTANY WITH DEFERRED ARGUMENT
        !           233: *
        !           234: D75     TEST NOTANY(*'ABCDEFGHJKLMPQRSTUWXYZ') $ VARA   :S(D77)
        !           235:         ERROR()
        !           236: D77     IDENT(VARA,'I')                                 :S(D79) ; ERROR()
        !           237: D79                                                     :(ALLDONE)
        !           238:         EJECT
        !           239: *
        !           240: *   ERROR HANDLING ROUTINE
        !           241: *
        !           242: ERROR   OUTPUT  = '****** ERROR DETECTED AT ' &LASTNO ' ********'
        !           243:         OUTPUT  = DIFFER(&ERRTEXT) '      &ERRTEXT = ' &ERRTEXT
        !           244:         ERRCOUNT = ERRCOUNT + 1
        !           245:         DUMP(1)                                         :(RETURN)
        !           246: *
        !           247: *   TERMINATION ROUTINE
        !           248: *
        !           249: ALLDONE
        !           250:         ERRCOUNT = ERRCOUNT + &ERRLIMIT - 100
        !           251:         &ERRLIMIT = 100
        !           252:         OUTPUT  = EQ(ERRCOUNT,0)
        !           253: .           '****           NO ERRORS DETECTED         ****'
        !           254:         OUTPUT  = '**********************************************'
        !           255:         OUTPUT  = '****           END OF DIAGNOSTICS         ****'
        !           256:         OUTPUT  = '**********************************************'
        !           257: END

unix.superglobalmegacorp.com

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