COMPILATION LISTING OF SEGMENT compare_text_ Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/15/82 1613.5 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 compare_text_: proc (optr,a_diff,a_brief,segptr); 12 13 /* Modified: 2 May 1977 by RAB to improve IC checking */ 14 /* Modified: 4 May 1977 by SHW to use new calling sequence for display_text_ */ 15 /* Modified: 9 April 1979 by RAB to improve comparison of text references */ 16 17 dcl optr pointer; 18 19 1 1 /* BEGIN INCLUDE FILE ... object_info.incl.pl1 1 2*coded February 8, 1972 by Michael J. Spier */ 1 3 /* modified May 26, 1972 by M. Weaver */ 1 4 /* modified 15 April, 1975 by M. Weaver */ 1 5 1 6 declare 1 object_info aligned based, /* structure containing object info based, returned by object_info_ */ 1 7 2 version_number fixed bin, /* version number of current structure format (=2) */ 1 8 2 textp pointer, /* pointer to beginning of text section */ 1 9 2 defp pointer, /* pointer to beginning of definition section */ 1 10 2 linkp pointer, /* pointer to beginning of linkage section */ 1 11 2 statp pointer, /* pointer to beginning of static section */ 1 12 2 symbp pointer, /* pointer to beginning of symbol section */ 1 13 2 bmapp pointer, /* pointer to beginning of break map (may be null) */ 1 14 2 tlng fixed bin, /* length in words of text section */ 1 15 2 dlng fixed bin, /* length in words of definition section */ 1 16 2 llng fixed bin, /* length in words of linkage section */ 1 17 2 ilng fixed bin, /* length in words of static section */ 1 18 2 slng fixed bin, /* length in words of symbol section */ 1 19 2 blng fixed bin, /* length in words of break map */ 1 20 2 format, /* word containing bit flags about object type */ 1 21 3 old_format bit(1) unaligned, /* on if segment isn't in new format, i.e. has old style object map */ 1 22 3 bound bit(1) unaligned, /* on if segment is bound */ 1 23 3 relocatable bit(1) unaligned, /* on if seg has relocation info in its first symbol block */ 1 24 3 procedure bit(1) unaligned, /* on if segment is an executable object program */ 1 25 3 standard bit(1) unaligned, /* on if seg is in standard format (more than just standard map) */ 1 26 3 gate bit(1) unaligned, /* on if segment is a gate */ 1 27 3 separate_static bit(1) unaligned, /* on if static not in linkage */ 1 28 3 links_in_text bit(1) unaligned, /* on if there are threaded links in text */ 1 29 3 perprocess_static bit (1) unaligned, /* on if static is not to be per run unit */ 1 30 3 pad bit(27) unaligned, 1 31 2 entry_bound fixed bin, /* entry bound if segment is a gate */ 1 32 2 textlinkp pointer, /* ptr to first link in text */ 1 33 1 34 /* LIMIT OF BRIEF STRUCTURE */ 1 35 1 36 2 compiler char(8) aligned, /* name of processor which generated segment */ 1 37 2 compile_time fixed bin(71), /* clock reading of date/time object was generated */ 1 38 2 userid char(32) aligned, /* standard Multics id of creator of object segment */ 1 39 2 cvers aligned, /* generator version name in printable char string form */ 1 40 3 offset bit(18) unaligned, /* offset of name in words relative to base of symbol section */ 1 41 3 length bit(18) unaligned, /* length of name in characters */ 1 42 2 comment aligned, /* printable comment concerning generator or generation of segment */ 1 43 3 offset bit(18) unaligned, /* offset of comment in words relative to base of symbol section */ 1 44 3 length bit(18) unaligned, /* length of comment in characters */ 1 45 2 source_map fixed bin, /* offset, relative to base of symbol section, of source map structure */ 1 46 1 47 /* LIMIT OF DISPLAY STRUCTURE */ 1 48 1 49 2 rel_text pointer, /* pointer to text section relocation info */ 1 50 2 rel_def pointer, /* pointer to definition section relocation info */ 1 51 2 rel_link pointer, /* pointer to linkage section relocation info */ 1 52 2 rel_static pointer, /* pointer to static section relocation info */ 1 53 2 rel_symbol pointer, /* pointer to symbol section relocation info */ 1 54 2 text_boundary fixed bin, /* specifies mod of text section base boundary */ 1 55 2 static_boundary fixed bin, /* specifies mod of internal static base boundary */ 1 56 /* currently not used by system */ 1 57 2 default_truncate fixed bin, /* offset rel to symbp for binder to automatically trunc. symb sect. */ 1 58 2 optional_truncate fixed bin; /* offset rel to symbp for binder to optionally trunc. symb sect. */ 1 59 1 60 declare object_info_version_2 fixed bin int static init(2); 1 61 1 62 /* END INCLUDE FILE ... object_info.incl.pl1 */ 20 21 22 dcl 1 oi(2) based(optr) aligned like object_info; 23 24 dcl a_diff bit(1) unaligned; 25 26 dcl a_brief bit(1) unaligned; 27 28 dcl segptr pointer; 29 30 dcl 1 seg based(segptr), 31 2 p(4) pointer, /* segment pointers */ 32 2 sname(2) char(200) aligned; /* segment names */ 33 34 35 dcl differ bit(1) aligned init("0"b); 36 dcl brief bit(1) aligned; 37 dcl first bit(1) aligned init("1"b); 38 39 dcl (i,j,k) fixed bin(17); 40 dcl limit fixed bin; 41 dcl r pointer; 42 dcl onp pointer; 43 dcl 1 rel_tab based(r) aligned, 44 2 array(limit) unaligned, 45 3 dummy unal bit(13), 46 3 rbits unal bit(5); 47 dcl rptr(2) pointer; /* pointers to unpacked relocation bits */ 48 49 dcl tl(2) fixed bin(17) init(oi.tlng(1),oi.tlng(2)); /* TEXT LENGTHS */ 50 dcl tlmax fixed bin(17); 51 dcl tp(2) pointer init(oi.textp(1),oi.textp(2)); /* TEXT POINTERS */ 52 53 dcl rscan fixed bin (17); /* relocation scanner */ 54 dcl 1 relinfo based, 55 2 decl_vers fixed bin(17), 56 2 n_bits fixed bin (17), 57 2 relbits bit(nb refer(n_bits)); 58 59 dcl rt(2) pointer init(oi.rel_text(1),oi.rel_text(2)); /* pointers to packed relocation bits */ 60 61 dcl minwords fixed bin int static init(5); 62 dcl (af,aj,bf,bj) fixed bin; 63 64 dcl tlen(2) fixed bin; /* LENGTHS LEFT TO BE SCANNED */ 65 dcl ilc(2) fixed bin; /* SCANNERS */ 66 67 dcl word(0:65535) bit(36) aligned based; /* ARRAY USED FOR NORMAL SCANNING */ 68 69 dcl 1 inst(0:65535) based aligned, /* ARRAY OF INSTRUCTIONS FOR IC CHECKING */ 70 2 address fixed bin(17) unal, 71 2 right unaligned, 72 3 op_code bit(10) unal, 73 3 inhibit bit(1) unal, 74 3 ext_base bit(1) unal, 75 3 tag bit(6) unal; 76 77 78 /* function declarations */ 79 80 dcl display_text_ entry(ptr,ptr,fixed bin,fixed bin,fixed bin,ptr); 81 dcl get_operator_names_ptr_ entry (char (*), ptr); 82 dcl ioa_ entry options(variable); 83 84 dcl (addr,addrel,divide,fixed,index,max,min,mod,null,string,substr) builtin; 85 86 brief = a_brief; 87 if ^brief then call get_operator_names_ptr_ ((oi (1).compiler), onp); 88 tlmax = max(tl(1),tl(2)); 89 90 91 /* Check for old style object segment and adjust relocation pointers accordingly */ 92 93 if oi.old_format(1) & rt(1) ^= null 94 then do; 95 rt(1) = addrel(rt(1),-1); 96 rt(2) = addrel(rt(2),-1); 97 end; 98 99 /* DO TEXT COMPARISON */ 100 101 102 /* Convert relocation info to unpacked form */ 103 104 rptr(1) = p(3); 105 rptr(2) = p(4); 106 if rt(1) ^= null 107 then do j = 1 to 2; /* for each segment */ 108 rscan = 1; 109 r = rptr(j); 110 limit = 2 * tl(j); 111 k = 1; 112 113 search_1: i = index(substr(rt(j)->relbits,rscan),"1"b); 114 if i ^= 0 115 then do; 116 rscan = rscan + (i - 1); 117 k = k + (i - 1); 118 if k > limit then go to jloop; 119 if substr(rt(j)->relbits,rscan,5)="11110"b 120 then do; 121 k = k + fixed(substr(rt(j)->relbits,rscan+5,10),17); 122 rscan = rscan + 15; 123 end; 124 else do; 125 rbits(k) = substr(rt(j)->relbits,rscan,5); 126 k = k + 1; 127 rscan = rscan + 5; 128 end; 129 go to search_1; 130 end; 131 132 jloop: end; 133 134 /* SECTION TO DO THE ACTUAL SCANNING */ 135 136 /* Initialize scanners */ 137 138 tlen(1) = tl(1); 139 tlen(2) = tl(2); 140 ilc(1), ilc(2) = 0; 141 142 /* Main loop, skip through blocks of matching lines */ 143 144 l1: 145 if tlen(1) <= 0 146 then if tlen(2) <= 0 147 then do; 148 stop: a_diff = differ; 149 return; 150 end; 151 else do; /* A finished, print B */ 152 differ = "1"b; 153 if ^brief 154 then do; 155 call print(1,2,tlen(2)); 156 call ioa_("^RAdded to end.^B"); 157 end; 158 go to stop; 159 end; 160 if tlen(2) <= 0 161 then do; 162 differ = "1"b; /* B finished, print A */ 163 if ^brief 164 then do; 165 call print(1,1,tlen(1)); 166 call ioa_("^RDeleted from end.^B"); 167 end; 168 go to stop; 169 end; 170 171 /* COMPARE */ 172 173 if tp(1) -> word(ilc(1)) = tp(2) -> word(ilc(2)) /* If lines equal, */ 174 then do; 175 check_reloc: 176 if rptr(1) -> word(ilc(1)) = rptr(2) -> word(ilc(2)) 177 then do; /* then move up the scanners */ 178 ilc(1) = ilc(1) + 1; 179 ilc(2) = ilc(2) + 1; 180 tlen(1) = tlen(1) -1; 181 tlen(2) = tlen(2) - 1; 182 go to l1; 183 end; 184 end; 185 else if check_ic(ilc(1),ilc(2)) 186 then go to check_reloc; 187 188 /* No match, start looking for matching group to sync on */ 189 190 af, bf = 1; 191 differ = "1"b; 192 if brief then go to stop; 193 194 l2: 195 if minwords > tlen(2) /* Make sure we don't run off the end */ 196 then go to nomatch; 197 198 if (af+minwords) > tlen(1) /* Ditto */ 199 then go to nomatch; 200 201 if equal(af,0) /* First, look for a match on the first line */ 202 then do; 203 bf = 0; 204 go to rematch; 205 end; 206 207 if (bf+minwords) > tlen(2) /* Again, watch out for end of segment */ 208 then go to nomatch; 209 210 bj = 0; 211 do i = 1 to bf while(bj = 0); /* Look for a matching group */ 212 if equal(af,i) 213 then bj = i; 214 end; 215 216 if minwords > tlen(1) /* Watch out for end of segment */ 217 then go to nomatch; 218 219 if equal(0,bf) /* Look for match the other way on the first line */ 220 then do; 221 af = 0; 222 go to rematch; 223 end; 224 225 if bj > 0 226 then do; 227 bf = bj; 228 go to rematch; 229 end; 230 231 aj = 0; /* Scan for a matching group */ 232 do i = 1 to af while (aj = 0); 233 if equal(i,bf) 234 then aj = i; 235 end; 236 237 if aj > 0 238 then do; 239 af = aj; 240 go to rematch; 241 end; 242 243 /* Look further in each segment for a matching group */ 244 245 af = af + 1; 246 bf = bf + 1; 247 go to l2; 248 249 /* No match, entire ends of files changed */ 250 251 nomatch: 252 af = tlen(1); 253 bf = tlen(2); 254 255 /* We have found a match to resync with if we get here by a goto */ 256 257 rematch: 258 if af <= 0 259 then do; 260 call print(1,2,bf); 261 call ioa_("^RInserted before:^B"); 262 call print(0,1,(minwords)); 263 end; 264 else if bf <= 0 265 then do; 266 call print(1,1,af); 267 call ioa_("^RDeleted before:^B"); 268 call print(0,2,(minwords)); 269 end; 270 else do; 271 call print(1,1,af); 272 call ioa_("^RChanged to:^B"); 273 call print(1,2,bf); 274 end; 275 276 call ioa_("^2/"); 277 tlen(1) = tlen(1) - af; 278 tlen(2) = tlen(2) - bf; 279 go to l1; 280 /* INTERNAL PROCEDURE FOR COMPARING BLOCKS OF CODE */ 281 282 equal: proc(astart,bstart) returns(bit(1) aligned); 283 dcl (a,astart,b,bstart,i) fixed bin; 284 285 a = astart + ilc(1); 286 b = bstart + ilc(2); 287 288 do i = 0 to minwords - 1; 289 if tp(1) -> word(i+a) ^= tp(2) -> word(i+b) 290 then if ^ check_ic(i+a, i+b) 291 then return("0"b); 292 if rptr(1) -> word(i+a) ^= rptr(2) -> word(i+b) 293 then return("0"b); 294 end; 295 296 return("1"b); 297 end; 298 299 300 301 302 /* INTERNAL PROCEDURE FOR DISPLAYING BAD TEXT */ 303 304 print: proc(bumpsw,which,plen); 305 dcl (i,bumpsw,which,len,plen) fixed bin; 306 307 i = which; 308 len = plen; 309 310 if first 311 then do; 312 call ioa_("^2/**Text discrepancies between the 2 segments have been found.^2/"); 313 first = "0"b; 314 end; 315 316 call ioa_("^a:",sname(i)); 317 call display_text_(tp(i),rptr(i),ilc(i),len,tl(i),onp); 318 319 if bumpsw ^= 0 320 then ilc(i) = ilc(i) + len; 321 end; 322 323 324 /* INTERNAL PROCEDURE TO SEE IF TWO DIFFERING INSTRUCTIONS ARE REALLY THE SAME, DIFFERING 325*ONLY IN THE OFFSET FOR IC MODIFICATION OR TEXT REFERENCING 326* 327* check_ic is heuristic not algorithmic */ 328 329 check_ic: proc(a,b) returns(bit(1) aligned); 330 331 dcl a fixed bin, /* location being compared in seg 1 */ 332 b fixed bin; /* location being compared in seg 2 */ 333 334 dcl a1 fixed bin, /* operand address in seg 1 */ 335 b1 fixed bin; /* operand address in seg 2 */ 336 337 differ = "1"b; 338 339 if string(tp(1) -> inst(a).right) = string(tp(2) -> inst(b).right) 340 & ^ tp(1) -> inst(a).ext_base 341 then if tp(1) -> inst(a).tag = "000100"b /* IC */ 342 | tp(1) -> inst(a).tag = "010100"b /* IC* */ 343 | tp(1) -> inst(a).tag = "000000"b /* (text) */ 344 then do; 345 a1 = tp(1) -> inst(a).address; 346 b1 = tp(2) -> inst(b).address; 347 348 if substr(tp(1) -> inst(a).tag,4,1) /* IC */ 349 then do; 350 a1 = a1 + a; 351 b1 = b1 + b; 352 end; 353 354 if b1 >= 0 & b1 < tl(2) & a1 >= 0 & a1 < tl(1) 355 then if tp(1) -> word(a1) = tp(2) -> word(b1) 356 then if tp(1) -> word(a1+1) = tp(2) -> word(b1+1) 357 then return("1"b); 358 end; 359 360 return("0"b); 361 362 end; 363 364 365 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/15/82 1501.0 compare_text_.pl1 >dumps>old>recomp>compare_text_.pl1 20 1 08/05/77 1022.5 object_info.incl.pl1 >ldd>include>object_info.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. a parameter fixed bin(17,0) dcl 331 in procedure "check_ic" ref 329 339 339 339 339 339 345 348 350 a 000162 automatic fixed bin(17,0) dcl 283 in procedure "equal" set ref 285* 289 289 292 a1 000204 automatic fixed bin(17,0) dcl 334 set ref 345* 350* 350 354 354 354 354 a_brief parameter bit(1) unaligned dcl 26 ref 11 86 a_diff parameter bit(1) unaligned dcl 24 set ref 11 148* addrel builtin function dcl 84 ref 95 96 address based fixed bin(17,0) array level 2 packed unaligned dcl 69 ref 345 346 af 000136 automatic fixed bin(17,0) dcl 62 set ref 190* 198 201* 212* 221* 232 239* 245* 245 251* 257 266* 271* 277 aj 000137 automatic fixed bin(17,0) dcl 62 set ref 231* 232 233* 237 239 array based structure array level 2 packed unaligned dcl 43 astart parameter fixed bin(17,0) dcl 283 ref 282 285 b parameter fixed bin(17,0) dcl 331 in procedure "check_ic" ref 329 339 346 351 b 000163 automatic fixed bin(17,0) dcl 283 in procedure "equal" set ref 286* 289 289 292 b1 000205 automatic fixed bin(17,0) dcl 334 set ref 346* 351* 351 354 354 354 354 bf 000140 automatic fixed bin(17,0) dcl 62 set ref 190* 203* 207 211 219* 227* 233* 246* 246 253* 260* 264 273* 278 bj 000141 automatic fixed bin(17,0) dcl 62 set ref 210* 211 212* 225 227 brief 000101 automatic bit(1) dcl 36 set ref 86* 87 153 163 192 bstart parameter fixed bin(17,0) dcl 283 ref 282 286 bumpsw parameter fixed bin(17,0) dcl 305 ref 304 319 compiler 30 based char(8) array level 2 dcl 22 ref 87 differ 000100 automatic bit(1) initial dcl 35 set ref 35* 148 152* 162* 191* 337* display_text_ 000010 constant entry external dcl 80 ref 317 ext_base 0(29) based bit(1) array level 3 packed unaligned dcl 69 ref 339 first 000102 automatic bit(1) initial dcl 37 set ref 37* 310 313* fixed builtin function dcl 84 ref 121 format 24 based structure array level 2 dcl 22 get_operator_names_ptr_ 000012 constant entry external dcl 81 ref 87 i 000174 automatic fixed bin(17,0) dcl 305 in procedure "print" set ref 307* 316 317 317 317 317 319 319 i 000103 automatic fixed bin(17,0) dcl 39 in procedure "compare_text_" set ref 113* 114 116 117 211* 212* 212* 232* 233* 233* i 000164 automatic fixed bin(17,0) dcl 283 in procedure "equal" set ref 288* 289 289 289 289 292 292* ilc 000144 automatic fixed bin(17,0) array dcl 65 set ref 140* 140* 173 173 175 175 178* 178 179* 179 185* 185* 285 286 317* 319* 319 index builtin function dcl 84 ref 113 inst based structure array level 1 dcl 69 ioa_ 000014 constant entry external dcl 82 ref 156 166 261 267 272 276 312 316 j 000104 automatic fixed bin(17,0) dcl 39 set ref 106* 109 110 113 119 121 125* k 000105 automatic fixed bin(17,0) dcl 39 set ref 111* 117* 117 118 121* 121 125 126* 126 len 000175 automatic fixed bin(17,0) dcl 305 set ref 308* 317* 319 limit 000106 automatic fixed bin(17,0) dcl 40 set ref 110* 118 max builtin function dcl 84 ref 88 minwords constant fixed bin(17,0) initial dcl 61 ref 194 198 207 216 262 268 288 n_bits 1 based fixed bin(17,0) level 2 dcl 54 ref 113 119 121 125 null builtin function dcl 84 ref 93 106 object_info based structure level 1 dcl 1-6 oi based structure array level 1 dcl 22 old_format 24 based bit(1) array level 3 packed unaligned dcl 22 ref 93 onp 000112 automatic pointer dcl 42 set ref 87* 317* optr parameter pointer dcl 17 ref 11 49 49 51 51 59 59 87 93 p based pointer array level 2 dcl 30 ref 104 105 plen parameter fixed bin(17,0) dcl 305 ref 304 308 r 000110 automatic pointer dcl 41 set ref 109* 125 rbits 0(13) based bit(5) array level 3 packed unaligned dcl 43 set ref 125* rel_tab based structure level 1 dcl 43 rel_text 50 based pointer array level 2 dcl 22 ref 59 59 relbits 2 based bit level 2 packed unaligned dcl 54 ref 113 119 121 125 relinfo based structure level 1 unaligned dcl 54 right 0(18) based structure array level 2 packed unaligned dcl 69 ref 339 339 rptr 000114 automatic pointer array dcl 47 set ref 104* 105* 109 175 175 292 292 317* rscan 000130 automatic fixed bin(17,0) dcl 53 set ref 108* 113 116* 116 119 121 122* 122 125 127* 127 rt 000132 automatic pointer initial array dcl 59 set ref 59* 59* 93 95* 95 96* 96 106 113 119 121 125 seg based structure level 1 unaligned dcl 30 segptr parameter pointer dcl 28 ref 11 104 105 316 sname 10 based char(200) array level 2 dcl 30 set ref 316* string builtin function dcl 84 ref 339 339 substr builtin function dcl 84 ref 113 119 121 125 348 tag 0(30) based bit(6) array level 3 packed unaligned dcl 69 ref 339 339 339 348 textp 2 based pointer array level 2 dcl 22 ref 51 51 tl 000120 automatic fixed bin(17,0) initial array dcl 49 set ref 49* 49* 88 88 110 138 139 317* 354 354 tlen 000142 automatic fixed bin(17,0) array dcl 64 set ref 138* 139* 144 144 155* 160 165* 180* 180 181* 181 194 198 207 216 251 253 277* 277 278* 278 tlmax 000122 automatic fixed bin(17,0) dcl 50 set ref 88* tlng 16 based fixed bin(17,0) array level 2 dcl 22 ref 49 49 tp 000124 automatic pointer initial array dcl 51 set ref 51* 51* 173 173 289 289 317* 339 339 339 339 339 339 345 346 348 354 354 354 354 which parameter fixed bin(17,0) dcl 305 ref 304 307 word based bit(36) array dcl 67 ref 173 173 175 175 289 289 292 292 354 354 354 354 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. addr builtin function dcl 84 divide builtin function dcl 84 min builtin function dcl 84 mod builtin function dcl 84 object_info_version_2 internal static fixed bin(17,0) initial dcl 1-60 NAMES DECLARED BY EXPLICIT CONTEXT. check_ic 001162 constant entry internal dcl 329 ref 185 289 check_reloc 000455 constant label dcl 175 ref 185 compare_text_ 000101 constant entry external dcl 11 equal 000772 constant entry internal dcl 282 ref 201 212 219 233 jloop 000344 constant label dcl 132 ref 118 l1 000354 constant label dcl 144 ref 182 279 l2 000506 constant label dcl 194 ref 247 nomatch 000624 constant label dcl 251 ref 194 198 207 216 print 001056 constant entry internal dcl 304 ref 155 165 260 262 266 268 271 273 rematch 000630 constant label dcl 257 ref 204 222 228 240 search_1 000261 constant label dcl 113 ref 129 stop 000360 constant label dcl 148 ref 158 168 192 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1510 1526 1436 1520 Length 1716 1436 16 153 52 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME compare_text_ 183 external procedure is an external procedure. equal internal procedure shares stack frame of external procedure compare_text_. print internal procedure shares stack frame of external procedure compare_text_. check_ic internal procedure shares stack frame of external procedure compare_text_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME compare_text_ 000100 differ compare_text_ 000101 brief compare_text_ 000102 first compare_text_ 000103 i compare_text_ 000104 j compare_text_ 000105 k compare_text_ 000106 limit compare_text_ 000110 r compare_text_ 000112 onp compare_text_ 000114 rptr compare_text_ 000120 tl compare_text_ 000122 tlmax compare_text_ 000124 tp compare_text_ 000130 rscan compare_text_ 000132 rt compare_text_ 000136 af compare_text_ 000137 aj compare_text_ 000140 bf compare_text_ 000141 bj compare_text_ 000142 tlen compare_text_ 000144 ilc compare_text_ 000162 a equal 000163 b equal 000164 i equal 000174 i print 000175 len print 000204 a1 check_ic 000205 b1 check_ic THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return ext_entry index_bs_1_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. display_text_ get_operator_names_ptr_ ioa_ NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000074 35 000106 37 000107 49 000111 51 000125 59 000140 86 000153 87 000160 88 000201 93 000206 95 000220 96 000223 104 000226 105 000232 106 000234 108 000245 109 000247 110 000253 111 000257 113 000261 114 000301 116 000303 117 000305 118 000306 119 000311 121 000320 122 000330 123 000332 125 000333 126 000340 127 000341 129 000343 132 000344 138 000346 139 000350 140 000352 144 000354 148 000360 149 000365 152 000366 153 000370 155 000372 156 000400 158 000417 160 000420 162 000422 163 000424 165 000426 166 000433 168 000447 173 000450 175 000455 178 000462 179 000463 180 000464 181 000466 182 000470 184 000471 185 000472 190 000477 191 000502 192 000504 194 000506 198 000511 201 000514 203 000522 204 000523 207 000524 210 000530 211 000531 212 000542 214 000551 216 000553 219 000556 221 000564 222 000565 225 000566 227 000570 228 000571 231 000572 232 000573 233 000604 235 000613 237 000615 239 000617 240 000620 245 000621 246 000622 247 000623 251 000624 253 000626 257 000630 260 000632 261 000640 262 000654 263 000663 264 000664 266 000666 267 000673 268 000712 269 000721 271 000722 272 000727 273 000744 276 000752 277 000765 278 000767 279 000771 282 000772 285 000774 286 000777 288 001002 289 001010 292 001035 294 001050 296 001052 304 001056 307 001060 308 001062 310 001064 312 001066 313 001102 316 001103 317 001127 319 001153 321 001161 329 001162 337 001164 339 001166 345 001213 346 001216 348 001221 350 001224 351 001226 354 001230 360 001254 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved