![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dif.spt CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / spitbol|
Return to dif.spt CVS log | Up to [Research Unix] / researchv10no / cmd / spitbol |
1.1 ! root 1: -TITLE SPITBOL TEST PROGRAM #10 -- FILE COMPARATOR ! 2: -IN80 ! 3: * THIS PROGRAM PERFORMS THE INVALUABLE SERVICE OF COMPARING TWO ! 4: * TEXT FILES FOR DIFFERENCES WHICH ARE PRINTED OUT IF FOUND. ITS ! 5: * SEMANTICS ARE THOSE OF THE DEC-10 PROGRAM FILCOM, BUT THIS VERSION ! 6: * BEING IN SPITBOL IS PORTABLE. ! 7: * ! 8: ** THE PROGRAM IS BASICALLY THE WORK OF ! 9: ** P.R. TALLETT ! 10: ** DATACALL LTD ! 11: ** KIRKSTALL RD ! 12: ** LEEDS, ENGLAND. ! 13: ** ! 14: ** IT HAS BEEN ELABORATED SOMEWHAT BY A.P. MCCANN. ! 15: * ! 16: ************************************************************************ ! 17: ** INSTRUCTIONS FOR USE * ! 18: ** THE PROGRAM STARTS BY ATTEMPTING TO READ A COMMAND LINE FROM THE * ! 19: ** STANDARD INPUT FILE. IF THIS FAILS, A "*" IS PRINTED ON THE * ! 20: ** TERMINAL AS A PROMPT FOR A REPLY. THE COMMAND LINE SUPPLIED * ! 21: ** EITHER IN A BATCH OR TERMINAL RUN SHOULD CONSIST OF A COMMAND * ! 22: ** LINE OF FORM * ! 23: ** OFILE=INFILE1,INFILE2 * ! 24: ** WHERE OFILE IS THE FILE TO RECEIVE LIST OF DIFFERENCES, INFILE1 * ! 25: ** AND INFILE2 ARE FILES TO BE COMPARED. * ! 26: ** * ! 27: ** IN ADDITION, THE COMMAND LINE MAY CONTAIN AT ANY POINT, * ! 28: ** SWITCHES TO CONTROL OPTIONS. THESE ARE LISTED BELOW, WHERE () * ! 29: ** ENCLOSES OPTIONAL ITEMS AND N STANDS FOR AN INTEGER. * ! 30: ** * ! 31: ** /B BLANK LINES MUST MATCH IN COMPARED FILES. DEFAULT * ! 32: ** IS THAT BLANK LINES ARE IGNORED IN MATCHING PROCESS. * ! 33: ** * ! 34: ** /L(N)(+) N LINES MUST BE FOUND IDENTICAL BEFORE A * ! 35: ** DIFFERENCE LIST IS TERMINATED. DEFAULT IS N=3. * ! 36: ** * ! 37: ** + SIGNIFIES THAT THESE N LINES ARE TO BE LISTED. DEFAULT * ! 38: ** IS THAT ONLY THE FIRST OF THE N LINES IS LISTED. * ! 39: ** * ! 40: ** /D(N)(-) A DOUBLE COLUMN LISTING FORMAT IS USED FOR THE * ! 41: ** DIFFERENCES, GIVING THE FIRST N CHARACTERS OF DIFFERING LINES (OR * ! 42: ** THE WHOLE LINE IF LESS THAN N IN LENGTH). THE TOTAL LINE LENGTH * ! 43: ** IS 2N+2 INCLUDING SEPARATING CHARACTERS. DEFAULT IS N=65. * ! 44: ** * ! 45: ** - SIGNIFIES THAT DIFFERENCES SHOULD BE SEPARATED BY A SHORT * ! 46: ** MARKER LINE. DEFAULT IS TO USE A SUFFICIENTLY LONG MARKER LINE * ! 47: ** TO SEPARATE DIFFERENCES TO GIVE A NEAT "BOXED" PRINTER LISTING. * ! 48: ** THE SHORTER FORMAT IS USEFUL ON SLOW TERMINALS. * ! 49: ** * ! 50: ** /RN ACCEPT INPUT LINES OR PRINT OUTPUT RECORDS OF * ! 51: ** MAXIMUM LENGTH N CHARACTERS. DEFAULT IS 133 CHARACTERS. * ! 52: ** * ! 53: ** AFTER TASK COMPLETION, AN ATTEMPT IS MADE TO READ A NEW * ! 54: ** COMMAND LINE FOR ANOTHER SET OF FILES. THE RUN IS TERMINATED BY * ! 55: ** SUPPLYING A NULL COMMAND LINE. * ! 56: ************************************************************************ ! 57: * ! 58: * IF PROGRAM IS RUN FROM A TERMINAL, ERRORS IN COMMAND LINE ! 59: * CAN BE CORRECTED INTERACTIVELY. IT MAY ALSO BE RUN AS A BATCH JOB, ! 60: * BUT IN THIS CASE ERROR RECOVERY IS NOT POSSIBLE. ! 61: * ! 62: * NOTE IMPORTANT COMMENT PRECEDING START OF MAIN PROGRAM. ! 63: * ! 64: * ! 65: &ANCHOR = &TRIM = 1; &STLIMIT = 999999 ! 66: DIGIT = "0123456789"; BLD = " " DIGIT ! 67: SWPAT = "" $ SL BREAK("/") $ N "/" $ SL ! 68: + ("L" (SPAN(BLD) $ NN | "") ("+" $ NNP | "") ! 69: + *?(NN = CONVERT(NN,"INTEGER")) | ! 70: + "D" (SPAN(BLD) $ LEN *?(LEN = CONVERT(LEN,"INTEGER")) | ! 71: + *?(LEN = 65)) ("-" $ LENM | "") | ! 72: + ("R" SPAN(DIGIT)) $ RECL | ! 73: + "B" $ BLANKS) ! 74: CMDPAT = BREAK("=") $ F1 LEN(1) BREAK(",") $ F2 LEN(1) REM $ F3 ! 75: STARS = "****" ! 76: SETEXIT(.ERR); &ERRLIMIT = 5 ! 77: * ! 78: * HERE ARE THE DATATYPES USED TO MAINTAIN LIST OF LINES WHICH ARE ! 79: * NOT YET COMPLETELY PROCESSED, TOGETHER WITH POINTERS INTO THEM. ! 80: * HEAD, CURRENT, TAIL ARE POINTERS TO INITIAL LINE, CURRENT LINE ! 81: * FOR MATCHING, AND LAST LINE IN THE LINKED LIST OF LINES BUILT ! 82: * FROM ELEMS. ! 83: * COUNT IS NO. OF LINES IN THE LIST. ! 84: * EOF IS SET NON-NULL WHEN END FILE IS MET. ! 85: * INP IS INPUT ASSOCD FOR READING LINES. ! 86: * ! 87: DATA("ELEM(OBJECT,LINK)") ! 88: DATA("LIST(HEAD,CURRENT,TAIL,COUNT,EOF,INP)") ! 89: * ! 90: * ROUTINE TO ADD AN OBJECT TO A LIST. RETURNS A POINTER TO OBJECT. ! 91: * IF BLANKS IS NULL, IT DOES NOT ADD BLANK LINES BUT FINDS ! 92: * AND ADDS NEXT NON-BLANK. FAILS IF INPUT EXHAUSTED IN THIS PROCESS. ! 93: * ! 94: DEFINE("ADD(LISTX,OBJ)") :(ADDEND) ! 95: ADD COUNT(LISTX) = (DIFFER(BLANKS),DIFFER(OBJ)) COUNT(LISTX) + 1:S(ADD0) ! 96: OBJ = $INP(LISTX) :S(ADD)F(FRETURN) ! 97: * ! 98: ADD0 ADD = TAIL(LISTX) = HEAD(LISTX) = ! 99: + IDENT(HEAD(LISTX)) ELEM(OBJ) :S(RETURN) ! 100: * ADD TO EXISTING LIST IF ARRIVE HERE ! 101: ADD = TAIL(LISTX) = LINK(TAIL(LISTX)) = ELEM(OBJ):(RETURN) ! 102: ADDEND ! 103: * ! 104: * ROUTINE TO FIND AN OBJECT IN THATL. FAILS IF NOT FOUND ! 105: * OTHERWISE RETURNS POINTER INTO THATL OF MATCHING ITEM. ! 106: * ! 107: DEFINE("MATCH(OBJ)") :(MATEND) ! 108: MATCH IDENT(THAP = HEAD(THATL)) :S(FRETURN) ! 109: CD = 1 ! 110: * ! 111: * ATTEMPT TO MATCH OBJECT WITH THAT POINTED AT IN THATL. NOTE POINTER. ! 112: * ! 113: MATC1 MATCH = THAPT = IDENT(OBJ,OBJECT(THAP)) THAP :S(MATC3) ! 114: * ! 115: * ADVANCE DOWN THE LIST TO TRY AGAIN. ! 116: * ! 117: MATC2 CD = CD + 1 ! 118: IDENT(THAP = LINK(THAP)) :F(MATC1)S(FRETURN) ! 119: * ! 120: * FIRST LINE MATCHED . CHECK REMAINING ! 121: * NN-1 LINES OR TO END OF THISL. ! 122: * ! 123: MATC3 THIPT = CURRENT(THISL) ! 124: CDEC = CD ! 125: * ! 126: * MATCHED IF RUN OFF END OF THISL BUT NOT OFF END OF THATL. ! 127: * ! 128: MATC4 IDENT(THIPT = LINK(THIPT)) :S(RETURN) ! 129: IDENT(THAPT = LINK(THAPT)) :S(FRETURN) ! 130: CDEC = CDEC + 1 ! 131: IDENT(OBJECT(THIPT),OBJECT(THAPT)) :S(MATC4)F(MATC2) ! 132: MATEND ! 133: * ! 134: * ROUTINE TO PRINT DIFFERENCE WHEN FOUND. IT OUTPUTS BOTH LISTS ! 135: * UP TO FIELD "CURRENT(LISTX)". ON FIRST ENTRY ONLY, IT PLACES ! 136: * INPUT FILE NAMES ON THE LISTING. ! 137: * ! 138: DEFINE("OUTFIL(LISTX,MARK,STARS)X") :(OUTEND) ! 139: OUTFIL OUT = "FILE 1) " F2 ! 140: OUT = "FILE 2) " F3 ! 141: OUT = DEFINE("OUTFIL(LISTX,MARK,STARS)X",.OUTFIL2) ! 142: * ! 143: * THIS ENTRY IS USED ON ALL OCCASIONS AFTER FIRST ! 144: * ! 145: OUTFIL2 OUT = STARS ! 146: OUTFIL3 OUT = MARK OBJECT(DIFFER(X = HEAD(LISTX)) X):F(RETURN) ! 147: HEAD(LISTX) = LINK(X) ! 148: IDENT(CURRENT(LISTX),X) :S(RETURN)F(OUTFIL3) ! 149: OUTEND ! 150: * ! 151: * ROUTINE TO PUT LINES TO OUTPUT FILE. ! 152: * ! 153: DEFINE("PUT()X,Y,XO,YO") :(ERREND) ! 154: PUT DIFFER(LEN) :S(PUTDB) ! 155: DIFFS = DIFFS + 1 ! 156: OUTFIL(FILE1,"1) ",STSTARS) ! 157: OUTFIL(FILE2,"2) ",STARS) :(RETURN) ! 158: * ! 159: * HERE TO OUTPUT DIFFERENCES IN DOUBLE COLUMN FORMAT ! 160: * ! 161: PUTDB OUT = RPAD("FILE 1) " F2,LEN) "| " "FILE 2) " F3 ! 162: DEFINE("PUT()X,Y,XO,YO",.PUTD) ! 163: * ! 164: * ENTRY USED FOR DOUBLE COLUMN FORMAT AFTER INITIAL ENTRY ! 165: * ! 166: PUTD DIFFS = DIFFS + 1; OUT = STSTARS ! 167: XO = X = HEAD(FILE1); YO = Y = HEAD(FILE2) ! 168: * ! 169: * CHECK WHETHER BOTH LISTS FINISHED ! 170: * ! 171: PUTD1 HEAD(FILE1) = IDENT(X,IDENT(Y)) CURRENT(FILE1) :F(PUTD2) ! 172: HEAD(FILE2) = CURRENT(FILE2) :(RETURN) ! 173: * ! 174: * PRINT A LINE GIVING DIFFERENCES IN ADJACENT COLUMNS ! 175: * ! 176: PUTD2 OUT = (DIFFER(X) GT(SIZE(XO = OBJECT(X)),LEN) ! 177: + SUBSTR(XO,1,LEN),RPAD(XO,LEN)) ! 178: + "| " ! 179: + (DIFFER(Y) GT(SIZE(YO = OBJECT(Y)),LEN) SUBSTR(YO,1,LEN),YO) ! 180: X = (IDENT(X),(DIFFER(CURRENT(FILE1),X) LINK(X),XO = )) ! 181: Y = (IDENT(Y),(DIFFER(CURRENT(FILE2),Y) LINK(Y),YO = )):(PUTD1) ! 182: * ! 183: * THIS ROUTINE IS ENTERED IF A SPITBOL ERROR OCCURS - USED FOR BUGS ! 184: * ! 185: ERR SETEXIT(EQ(&ERRTYPE,116) .ERR) :S(CMER) ! 186: TERMINAL = OUTPUT = "ERROR: " &ERRTEXT " IN STMT " &LASTNO ! 187: COLLECT() ! 188: DUMP(2) :(END) ! 189: ERREND ! 190: * ! 191: * ! 192: * MAIN PROGRAM ! 193: * ============ ! 194: * ! 195: * NORMAL ENTRY POINT TO MAIN PROGRAM ! 196: * ! 197: INIT LEN = LENM = NNP = DIFFS = BLANKS = ! 198: NN = 3; RECL = "R133" ! 199: * ! 200: * READ COMMAND LINE EITHER FROM INPUT FILE OR TERMINAL. ! 201: * IF ERROR AND IF BATCH, PRINT ERROR MESSAGE AND STOP. ! 202: * ! 203: OUTPUT = DIFFER(BATCH) TERMINAL :S(END) ! 204: X = BATCH = INPUT :F(TERMI) ! 205: DETACH(.TERMINAL) :(DIFFX) ! 206: * ! 207: * READ COMMAND LINE FROM TERMINAL ! 208: * ! 209: TERMI TERMINAL = "*"; X = TERMINAL :F(END) ! 210: * ! 211: * CHECK FOR NULL COMMAND LINE ! 212: * ! 213: DIFFX DIFFER(X) :F(END) ! 214: * ! 215: * LOOP TO PROCESS SWITCHES. NO. OF LINES IN MATCH IS 3 BY DEFAULT. ! 216: * ! 217: SWPAT X SWPAT = N :S(SWPAT) ! 218: TERMINAL = DIFFER(SL) "? INVALID SWITCH" :S(INIT) ! 219: X CMDPAT :S(GO) ! 220: * ! 221: * MERGE FROM ERR IF BAD FILENAMES ! 222: * ! 223: CMER TERMINAL = "?COMMAND ERROR IN " X :(INIT) ! 224: GO OUTPUT(.OUT,3,F1) :S(GO1) ! 225: TERMINAL = "?CAN'T ENTER OUTPUT FILE " F1 :(INIT) ! 226: GO1 INPUT(.IN1,1,F2) :S(GO2) ! 227: TERMINAL = "?CAN'T READ INPUT FILE 1 " F2 :(INIT) ! 228: GO2 INPUT(.IN2,2,F3) :S(START) ! 229: TERMINAL = "?CAN'T READ INPUT FILE 2 " F3 :(INIT) ! 230: * ! 231: START TERMINAL = ! 232: STSTARS = DUPL("*",(DIFFER(LEN,IDENT(LENM)) 2 * LEN + 2,12)) ! 233: THISL = FILE1 = LIST(,,,,,.IN1) ! 234: THATL = FILE2 = LIST(,,,,,.IN2) ! 235: * ! 236: * HUNT THROUGH FILES TILL DIFFERING LINES FOUND (IF ANY) ! 237: * ! 238: PHASE1 THIS = $INP(THISL) :F(THISEND) ! 239: * ! 240: THAT THAT = $INP(THATL) :F(THATEND) ! 241: * ! 242: IDENT IDENT(THIS,THAT) :S(PHASE1) ! 243: * ! 244: * MAKE SURE DIFFERENCE IS NOT MERELY BLANK LINES IF BLANKS NULL. ! 245: * ! 246: DIFFER(BLANKS) :S(DIFF) ! 247: IDENT(THAT) :S(THAT) ! 248: DIFFER(THIS) :S(DIFF) ! 249: THIS = $INP(THISL) :S(IDENT)F(THISEND) ! 250: * ! 251: * ARRIVE HERE WHEN A DIFFERENCE IS ENCOUNTERED. PHASE 2 ! 252: * ASSESSES HOW MUCH DIFFERENCE THERE IS AND PRINTS DIFFERENCES. ! 253: * IT OPERATES BY READING A LINE ALTERNATELY FROM EACH OF THE ! 254: * TWO INPUT FILES, ADDING IT TO THE APPROPRIATE LIST AND ATTEMPTING ! 255: * TO MATCH A CURRENT LINE AGAINST LINES HELD FOR THE OTHER FILE. ! 256: * AT ALL TIMES SUFFICIENT LINES ARE KEPT FOLLOWING THE CURRENT LINE ! 257: * SO THAT A COMPLETE MATCH CHECK CAN BE MADE. ! 258: * ! 259: DIFF CURRENT(THATL) = ADD(THATL,THAT) ! 260: * ! 261: * MERGE AGAIN AFTER DEALING WITH ONE DIFFERENCE TO DO ANOTHER ! 262: * ! 263: ENTER CURRENT(THISL) = ADD(THISL,THIS) ! 264: * ! 265: * ENTER ANOTHER LINE INTO THISL LIST, ADVANCE CURRENT(THISL) ! 266: * TO CORRESPOND AND SEE IF NEW CURRENT LINE MATCHES ! 267: * ANY LINE IN OTHER LIST. THIS FILE IS EXHAUSTED EITHER IF ! 268: * CURRENT IS ALREADY NULL OR IF LINK OF CURRENT IS NULL. ! 269: * ! 270: PHASE2 ADD(THISL,THIS = $INP(THISL)) ! 271: (IDENT(X = CURRENT(THISL)),IDENT(X = CURRENT(THISL) ! 272: + = LINK(X))) :S(THISEND) ! 273: * ! 274: * LOOP HERE TILL NN LINES AVAILABLE INCLUDING "CURRENT" LINE ! 275: * OF EACH LIST SO THAT MATCH TEST CAN BE DONE. ! 276: * ! 277: ADD1 LE(NN + 1,COUNT(THISL)) :S(ADD2) ! 278: ADD(THISL,$INP(THISL)) :S(ADD1) ! 279: ADD2 LE(NN,COUNT(THATL)) :S(TRYMAT) ! 280: ADD(THATL,$INP(THATL)) :S(ADD2) ! 281: * ! 282: * ATTEMPT A MATCH ! 283: * ! 284: TRYMAT X = MATCH(OBJECT(X)) :S(PHASE3) ! 285: * ! 286: * ARRIVE HERE WHILST STILL ATTEMPTING MATCH. IF END FILE NOT READ ! 287: * ON THAT LIST THEN SWAP LISTS AND TRY MATCHING USING IT INSTEAD. ! 288: * ! 289: DIFFER(EOF(THATL)) :S(PHASE2) ! 290: X = THISL; THISL = THATL; THATL = X :(PHASE2) ! 291: * ! 292: * MATCH ATTEMPT WAS SUCCESSFUL SO OUTPUT THIS LIST ! 293: * AND PORTION OF THAT LIST UP TO AND INCLUDING MATCHING LINE. ! 294: * THEN ADVANCE HEAD OF THATL PAST THE FURTHER NN-1 LINES MATCHED ! 295: * WHICH ARE NO LONGER OF INTEREST AND CLEAR THISL SINCE ALL ITS LINES ! 296: * ARE DEALT WITH. ! 297: * ! 298: PHASE3 Y = CURRENT(THATL) ! 299: CURRENT(THATL) = (IDENT(NNP) X,THAPT) ! 300: CURRENT(THISL) = DIFFER(NNP) TAIL(THISL) ! 301: PUT() ! 302: CURRENT(THATL) = Y ! 303: HEAD(THATL) = LINK(THAPT) ! 304: COUNT = COUNT(THATL) = COUNT(THATL) - CDEC ! 305: CURRENT(THATL) = LT(COUNT,NN) HEAD(THATL) ! 306: HEAD(THISL) = COUNT(THISL) = ! 307: * ! 308: * NOW POSITION FILES TO ANOTHER DIFFERENCE OR UNTIL THATL EMPTY. ! 309: * RIGHT NOW, THISL IS EMPTY. ! 310: * ! 311: POSIT IDENT(X = HEAD(THATL)) :S(PHASE1) ! 312: THIS = $INP(THISL) :F(THISEND) ! 313: IDENT(THIS,OBJECT(X)) :F(ENTER) ! 314: HEAD(THATL) = LINK(X) ! 315: CURRENT(THATL) = LT(COUNT(THATL) = COUNT(THATL) - 1,NN) HEAD(THATL) ! 316: + :(POSIT) ! 317: * ! 318: * HERE TO SET EOF FLAG FOR THISL. DONE BY SWAPPING LISTS ! 319: * AND JUMPING INTO CODE FOR THATL. ! 320: * ! 321: THISEND X = THISL; THISL = THATL; THATL = X :(EOF) ! 322: * ! 323: * MARK ENDFILE OF THATL BY SETTING EOF NON-NULL. ! 324: * ON ARRIVAL HERE FIRST STORE LINE JUST READ FROM THIS FILE ! 325: * ! 326: THATEND CURRENT(THISL) = ADD(THISL,THIS) ! 327: * ! 328: * TEST FOR END CONDITION WHICH IS THAT WE HAVE EOF ON BOTH LISTS. ! 329: * WE KNOW WE HAVE EOF ON THAT LIST SINCE WE ARE ABOUT TO SET FLAG. ! 330: * ! 331: * ! 332: EOF EOF(THATL) = "EOF" ! 333: IDENT(EOF(THISL)) :S(PHASE2) ! 334: * ! 335: * EOF REACHED ON BOTH FILES. OUTPUT BOTH LISTS AND PACK UP. ! 336: * ! 337: IDENT(HEAD(THISL),IDENT(HEAD(THATL))) :S(CLOSE) ! 338: CURRENT(THISL) = TAIL(THISL) ! 339: CURRENT(THATL) = TAIL(THATL) ! 340: PUT() ! 341: * ! 342: * FINISH BY TYPING OUT DIFFERENCE COUNT ! 343: * ! 344: CLOSE TERMINAL = IDENT(DIFFS) "NO DIFFERENCES FOUND" :F(DIFFS) ! 345: OUT = DIFFER(BATCH) TERMINAL :(STOP) ! 346: * ! 347: DIFFS OUT = STSTARS ! 348: TERMINAL = "% " DIFFS " DIFFERENCE" (NE(DIFFS,1) "S",) " FOUND" ! 349: OUT = DIFFER(BATCH) TERMINAL ! 350: * ! 351: STOP TERMINAL = DEFINE("OUTFIL(LISTX,MARK,STARS)X") ! 352: + DEFINE("PUT()X,Y,XO,YO") :(INIT) ! 353: END
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.