COMPILATION LISTING OF SEGMENT hunt_dec Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/16/82 1435.6 mst Tue 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 hunt_dec: proc; 12 13 /* HUNT - find a segment in a given subtree. */ 14 /* Modified by Peter C. Krupp on 1/14/78 to find and classify PL/I object segments that use decimal data */ 15 /* Modified 780809 by PG to terminate archive segments when finished with them. */ 16 17 18 /* automatic */ 19 20 dcl path char (168), /* Root of tree to be scanned. */ 21 i fixed bin, 22 ap ptr, 23 segp ptr, 24 al fixed bin, 25 bchr char (al) unaligned based (ap), 26 ec fixed bin(35), 27 an fixed bin init (2), 28 code fixed bin (35); 29 30 /* entries */ 31 32 dcl absolute_pathname_ entry (char (*), char (*), fixed bin (35)), 33 cu_$arg_count entry returns (fixed bin), 34 hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, fixed bin (35)), 35 hcs_$initiate_count entry (char(*), char(*), char(*), fixed bin(24), fixed bin(2), ptr, fixed bin(35)), 36 hcs_$terminate_noname entry (ptr, fixed bin (35)), 37 com_err_ entry options (variable), 38 ioa_$rsnnl entry options (variable), 39 cu_$arg_ptr ext entry (fixed bin, ptr, fixed bin, fixed bin(35)), 40 sweep_disk_dec_ ext entry (char (168), entry), 41 get_wdir_ entry returns (char (168)), 42 ioa_ entry options (variable); 43 44 /* builtins */ 45 46 dcl (addr, bin, hbound, index, length, null, rtrim, substr) builtin; 47 48 /* files */ 49 50 dcl (no_decimal,aligned_decimal,unaligned_decimal) file record output environment(stringvalue); 51 52 dcl prog_list(3) file variable init(no_decimal,aligned_decimal,unaligned_decimal); 53 54 dcl attach_description(3) char(256) varying 55 init("discard_","record_stream_ -target vfile_ aligned_decimal.hd","record_stream_ -target vfile_ unaligned_decimal.hd"); 56 dcl header(3) char(132) var 57 init("/* PL/I object segments that do not reference decimal data */", 58 "/* PL/I object segments that reference aligned decimal data */", 59 "/* PL/I object segments that reference unaligned decimal data */"); 60 61 dcl total(3) fixed bin init((3)0); 62 dcl message char(256) var init(""); 63 64 65 dcl cleanup condition; 66 67 /* --------------------- */ 68 69 path = get_wdir_ (); 70 call cu_$arg_ptr (1, ap, al, ec); 71 if ec ^= 0 then do; 72 call com_err_ (0, "hunt_dec", "Usage: hunt_dec {root_of_tree} {-control_args}^/ Control arguments: -aligned_decimal -unaligned_decimal "); 73 return; 74 end; 75 76 call absolute_pathname_ (bchr, path, code); 77 if code ^= 0 then go to er; 78 79 call process_ctl_args(code,message); 80 if code^=0 | message^="" 81 then go to er; 82 83 do i=2 to 3; 84 open file(prog_list(i)) title(attach_description(i)); 85 end; 86 87 on cleanup 88 begin; 89 do i=2 to 3; 90 close file(prog_list(i)); 91 end; 92 end; 93 94 do i=2 to 3; 95 write file(prog_list(i)) from(header(i)); 96 end; 97 98 /* Now, go to work. Call disk sweeper program */ 99 100 call sweep_disk_dec_ (path, counter); 101 call ioa_ ("^/Total no decimal ^d^/Total aligned decimal ^d^/Total unaligned decimal ^d^/",total(1),total(2),total(3)); 102 103 do i=2 to 3; 104 close file(prog_list(i)); 105 end; 106 return; 107 108 er: 109 call com_err_ (code, "hunt_dec", message); 110 return; 111 112 counter: proc (sdn, sen, lvl, een, bptr, nptr); 113 114 dcl archive_util_$first_disected entry(ptr, ptr, char(32) aligned, fixed bin(24), fixed bin(35)); 115 dcl archive_util_$disected_element entry(ptr, ptr, char(32) aligned, fixed bin(24), fixed bin(35)); 116 117 dcl examine_object_ entry (ptr,fixed bin(24),char(*),char(*),(3) file,(3) fixed bin); /* examine segment to see if it is a PL/I object segment with unaligned decimal code */ 118 119 dcl message char(256); 120 dcl ml fixed bin; 121 122 dcl header_ptr ptr; /* ptr to current archive header...input/output to archive util_ */ 123 dcl comp_ptr ptr; /* pointer to component in archive segment */ 124 dcl comp_name char(32) aligned; /* name of component in archive segment */ 125 dcl bit_count fixed bin(24); /* bit count of component */ 126 127 dcl sdn char (168), /* superior dir name */ 128 sen char (32), /* dirname */ 129 lvl fixed bin, /* distance from root */ 130 een char (32), /* entry name */ 131 namec fixed bin, 132 (j, k) fixed bin, 133 names (100) char (32) aligned based (nptr), 134 ename char (32), 135 bptr ptr, /* ptr to info structure */ 136 nptr ptr; /* ptr to names structure */ 137 138 dcl xp char (168), 139 xi fixed bin; 140 141 dcl 1 branch based (bptr) aligned, /* thing returned by star_long */ 142 2 type bit (2) unal, 143 2 nname bit (16) unal, 144 2 nindex bit (18) unal, 145 2 dtm bit (36) unal, 146 2 dtu bit (36) unal, 147 2 mode bit (5) unal, 148 2 pad bit (13) unal, 149 2 records bit (18) unal; 150 151 dcl ecc fixed bin (35); 152 153 dcl any_other condition; 154 155 dcl continue_to_signal_ entry (fixed bin(35)); 156 dcl find_condition_info_ entry (ptr,ptr,fixed bin(35)); 157 158 dcl condition_name(5) char(32) aligned int static 159 init ("no_read_permission","not_in_read_bracket","seg_fault_error", 160 "program_interrupt","out_of_bounds"); 161 162 dcl 1 cond_info, 1 1 /* BEGIN INCLUDE FILE ... cond_info.incl.pl1 1 2* coded by M. Weaver 12 July 1973 */ 1 3 1 4 2 mcptr ptr, /* ptr to machine conditions at time of fault */ 1 5 2 version fixed bin, /* version of this structure (now=1) */ 1 6 2 condition_name char(32) var, /* name of condition */ 1 7 2 infoptr ptr, /* ptr to software info structure */ 1 8 2 wcptr ptr, /* ptr to wall crossing machine conditions */ 1 9 2 loc_ptr ptr, /* ptr to location where condition occurred */ 1 10 2 flags aligned, 1 11 3 crawlout bit(1) unal, /* = "1"b if condition occurred in inner ring */ 1 12 3 pad1 bit(35) unal, 1 13 2 pad_word bit(36) aligned, 1 14 2 user_loc_ptr ptr, /* ptr to last non-support loc before condition */ 1 15 2 pad (4) bit(36) aligned; 1 16 1 17 /* END INCLUDE FILE ... cond_info.incl.pl1 */ 163 ; 164 165 on any_other 166 begin; 167 168 dcl (i,code) fixed bin(35); 169 170 cond_info.version=1; 171 call find_condition_info_(null,addr(cond_info),code); 172 do i=1 to hbound(condition_name,1); 173 if condition_name(i)=cond_info.condition_name 174 then go to bypass_segment; 175 end; 176 call continue_to_signal_(code); 177 end; 178 179 if branch.type^="01"b 180 then return; /* do not process links or directories */ 181 if sdn^=">" 182 then call ioa_$rsnnl ("^a>^a", xp, xi, sdn, sen); 183 else call ioa_$rsnnl (">^a", xp, xi, sen); 184 xi = bin (branch.type, 2); 185 namec = bin (branch.nname, 16); 186 do j = 1 to namec; 187 ename = names (bin (branch.nindex, 18)+j-1); 188 ecc = index (ename, "."); 189 if ecc = 0 then do; 190 if xp = ">" 191 then call ioa_$rsnnl (">^a", message, ml, een); 192 else call ioa_$rsnnl ("^a>^a", message, ml, xp, een); 193 194 call hcs_$initiate_count(xp, ename, "", bit_count, 0b, segp, ecc); 195 if segp^=null 196 then 197 do; 198 call examine_object_(segp, bit_count, rtrim (message), "", prog_list, total); 199 call hcs_$terminate_noname(segp,ecc); 200 end; 201 202 return; 203 end; 204 k = length (rtrim (ename)); 205 if k > 8 & substr (ename, k-7, 8) = ".archive" then do; 206 call hcs_$initiate (xp, ename, "", 0b, 0b, segp, ecc); 207 if segp = null then return; 208 header_ptr = segp; 209 call archive_util_$first_disected(header_ptr, comp_ptr, comp_name, bit_count, ecc); 210 do while (ecc = 0); 211 ecc = index (header_ptr -> archive_header.name, "."); 212 if ecc = 0 then do; 213 if xp ^= ">" 214 then call ioa_$rsnnl ("^a>^a", message, ml, xp, ename); 215 else call ioa_$rsnnl (">^a", message, ml, ename); 216 call examine_object_ (comp_ptr, bit_count, rtrim(header_ptr -> archive_header.name), 217 rtrim (message), prog_list, total); 218 end; 219 loop: call archive_util_$disected_element(header_ptr, comp_ptr, comp_name, bit_count, ecc); 220 end; 221 call hcs_$terminate_noname (segp, ecc); 222 return; 223 end; 224 225 end; 226 return; 227 228 bypass_segment: 229 revert any_other; /* just in case a condition recurs while recovering */ 230 231 call hcs_$terminate_noname(segp,ecc); 232 return; 233 234 end counter; 235 236 /* process_ctl_args - process control arguments for hunt_dec */ 237 238 process_ctl_args: 239 procedure(code,message); 240 241 dcl code fixed bin(35); 242 dcl message char(*) varying; 243 244 dcl specified(3) bit(1) aligned initial((3)(1)"0"b); 245 dcl (arg_count,arg_index) fixed bin; 246 dcl ctl_index fixed bin; 247 dcl sc fixed bin(35); 248 249 dcl arg_string char(arg_length) based(arg_ptr); 250 dcl arg_length fixed bin; 251 dcl arg_ptr pointer; 252 253 dcl suffixed_path character(168) varying; 254 dcl dir char(168); 255 dcl entry char(32); 256 257 dcl error_table_$badopt fixed bin(35) ext static; 258 dcl expand_pathname_$add_suffix entry(char(*),char(*),char(*),char(*),fixed bin(35)); 259 260 dcl suffix char(2) init("hd") int static; 261 262 code=0; 263 message=""; 264 265 arg_count=cu_$arg_count(); 266 arg_index=2; 267 268 do while(arg_index<=arg_count); 269 call cu_$arg_ptr(arg_index,arg_ptr,arg_length,sc); 270 ctl_index=valid_ctl(arg_string); 271 if ctl_index=0 272 then do; 273 code=error_table_$badopt; 274 message=arg_string; 275 return; 276 end; 277 if specified(ctl_index) 278 then do; 279 message=arg_string || " ctl argument specified more than once"; 280 return; 281 end; 282 arg_index=arg_index+1; 283 if arg_index>arg_count 284 then do; 285 code=0; 286 message="pathname must follow ctl argument"; 287 return; 288 end; 289 call cu_$arg_ptr(arg_index,arg_ptr,arg_length,sc); 290 call expand_pathname_$add_suffix(arg_string,suffix,dir,entry,code); 291 suffixed_path=rtrim(arg_string) || "." || suffix; 292 if code ^=0 293 then do; 294 message=suffixed_path; 295 return; 296 end; 297 specified(ctl_index)="1"b; 298 attach_description(ctl_index)="record_stream_ -target vfile_ " || suffixed_path; 299 arg_index=arg_index+1; 300 end; 301 302 return; 303 304 305 /* valid_ctl - validate and encode control arguments */ 306 307 valid_ctl: 308 procedure(ctl_arg) returns(fixed bin); 309 310 dcl valid_arg(3,2) char(18) aligned int static init("-nd","-no_decimal","-ad","-aligned_decimal","-ud","-unaligned_decimal"); 311 312 dcl ctl_arg character(*); 313 dcl i fixed bin; 314 315 do i=2 to hbound(valid_arg,1); 316 if ctl_arg=valid_arg(i,1) | ctl_arg=valid_arg(i,2) 317 then return(i); 318 end; 319 320 return(0); 321 322 end valid_ctl; 323 324 end process_ctl_args; 325 326 /* */ 327 2 1 /* BEGIN INCLUDE FILE archive_header.incl.pl1 */ 2 2 2 3 2 4 dcl 1 archive_header aligned based, 2 5 2 header_begin char (8), 2 6 2 pad1 char (4), 2 7 2 name char (32), 2 8 2 timeup char (16), 2 9 2 mode char (4), 2 10 2 time char (16), 2 11 2 pad char (4), 2 12 2 bit_count char (8), 2 13 2 header_end char (8); 2 14 2 15 /* END INCLUDE archive_header.incl.pl1 */ 328 329 end hunt_dec; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/16/82 1435.6 hunt_dec.pl1 >dumps>old_dumps>recomp>hunt_dec.pl1 163 1 05/06/74 1741.0 cond_info.incl.pl1 >ldd>include>cond_info.incl.pl1 328 2 02/06/76 1405.1 archive_header.incl.pl1 >ldd>include>archive_header.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. absolute_pathname_ 000014 constant entry external dcl 32 ref 76 addr builtin function dcl 46 ref 171 171 al 000160 automatic fixed bin(17,0) dcl 20 set ref 70* 76 76 aligned_decimal 000044 constant file output record stringvalue environment dcl 50 set ref 52 an 000162 automatic fixed bin(17,0) initial dcl 20 set ref 20* any_other 000306 stack reference condition dcl 153 ref 165 228 ap 000154 automatic pointer dcl 20 set ref 70* 76 archive_header based structure level 1 dcl 2-4 archive_util_$disected_element 000060 constant entry external dcl 115 ref 219 archive_util_$first_disected 000056 constant entry external dcl 114 ref 209 arg_count 001151 automatic fixed bin(17,0) dcl 245 set ref 265* 268 283 arg_index 001152 automatic fixed bin(17,0) dcl 245 set ref 266* 268 269* 282* 282 283 289* 299* 299 arg_length 001155 automatic fixed bin(17,0) dcl 250 set ref 269* 270 270 274 279 289* 290 290 291 arg_ptr 001156 automatic pointer dcl 251 set ref 269* 270 274 279 289* 290 291 arg_string based char unaligned dcl 249 set ref 270* 274 279 290* 291 attach_description 000200 automatic varying char(256) initial array dcl 54 set ref 54* 54* 54* 84 298* bchr based char unaligned dcl 20 set ref 76* bin builtin function dcl 46 ref 184 185 187 bit_count 000216 automatic fixed bin(24,0) dcl 125 set ref 194* 198* 209* 216* 219* bptr parameter pointer dcl 127 ref 112 179 184 185 187 branch based structure level 1 dcl 141 cleanup 000756 stack reference condition dcl 65 ref 87 code 000101 automatic fixed bin(35,0) dcl 168 in on unit on line 165 set ref 171* 176* code 000163 automatic fixed bin(35,0) dcl 20 in procedure "hunt_dec" set ref 76* 77 79* 80 108* code parameter fixed bin(35,0) dcl 241 in procedure "process_ctl_args" set ref 238 262* 273* 285* 290* 292 com_err_ 000026 constant entry external dcl 32 ref 72 108 comp_name 000206 automatic char(32) dcl 124 set ref 209* 219* comp_ptr 000204 automatic pointer dcl 123 set ref 209* 216* 219* cond_info 000314 automatic structure level 1 unaligned dcl 162 set ref 171 171 condition_name 3 000314 automatic varying char(32) level 2 in structure "cond_info" dcl 162 in procedure "counter" set ref 173 condition_name 000036 constant char(32) initial array dcl 158 in procedure "counter" ref 172 173 continue_to_signal_ 000064 constant entry external dcl 155 ref 176 ctl_arg parameter char unaligned dcl 312 ref 307 316 316 ctl_index 001153 automatic fixed bin(17,0) dcl 246 set ref 270* 271 277 297 298 cu_$arg_count 000016 constant entry external dcl 32 ref 265 cu_$arg_ptr 000032 constant entry external dcl 32 ref 70 269 289 dir 001233 automatic char(168) unaligned dcl 254 set ref 290* ec 000161 automatic fixed bin(35,0) dcl 20 set ref 70* 71 ecc 000305 automatic fixed bin(35,0) dcl 151 set ref 188* 189 194* 199* 206* 209* 210 211* 212 219* 221* 231* een parameter char(32) unaligned dcl 127 set ref 112 190* 192* ename 000222 automatic char(32) unaligned dcl 127 set ref 187* 188 194* 204 205 206* 213* 215* entry 001305 automatic char(32) unaligned dcl 255 set ref 290* error_table_$badopt 000070 external static fixed bin(35,0) dcl 257 ref 273 examine_object_ 000062 constant entry external dcl 117 ref 198 216 expand_pathname_$add_suffix 000072 constant entry external dcl 258 ref 290 find_condition_info_ 000066 constant entry external dcl 156 ref 171 get_wdir_ 000036 constant entry external dcl 32 ref 69 hbound builtin function dcl 46 ref 172 315 hcs_$initiate 000020 constant entry external dcl 32 ref 206 hcs_$initiate_count 000022 constant entry external dcl 32 ref 194 hcs_$terminate_noname 000024 constant entry external dcl 32 ref 199 221 231 header 000503 automatic varying char(132) initial array dcl 56 set ref 56* 56* 56* 95 header_ptr 000202 automatic pointer dcl 122 set ref 208* 209* 211 216 216 219* i 000152 automatic fixed bin(17,0) dcl 20 in procedure "hunt_dec" set ref 83* 84 84* 89* 90* 94* 95 95* 103* 104* i 001324 automatic fixed bin(17,0) dcl 313 in procedure "valid_ctl" set ref 315* 316 316 316* i 000100 automatic fixed bin(35,0) dcl 168 in on unit on line 165 set ref 172* 173* index builtin function dcl 46 ref 188 211 ioa_ 000040 constant entry external dcl 32 ref 101 ioa_$rsnnl 000030 constant entry external dcl 32 ref 181 183 190 192 213 215 j 000220 automatic fixed bin(17,0) dcl 127 set ref 186* 187* k 000221 automatic fixed bin(17,0) dcl 127 set ref 204* 205 205 length builtin function dcl 46 ref 204 lvl parameter fixed bin(17,0) dcl 127 ref 112 message parameter varying char dcl 242 in procedure "process_ctl_args" set ref 238 263* 274* 279* 286* 294* message 000654 automatic varying char(256) initial dcl 62 in procedure "hunt_dec" set ref 62* 79* 80 108* message 000100 automatic char(256) unaligned dcl 119 in procedure "counter" set ref 190* 192* 198 198 213* 215* 216 216 ml 000200 automatic fixed bin(17,0) dcl 120 set ref 190* 192* 213* 215* name 3 based char(32) level 2 dcl 2-4 ref 211 216 216 namec 000217 automatic fixed bin(17,0) dcl 127 set ref 185* 186 names based char(32) array dcl 127 ref 187 nindex 0(18) based bit(18) level 2 packed unaligned dcl 141 ref 187 nname 0(02) based bit(16) level 2 packed unaligned dcl 141 ref 185 no_decimal 000042 constant file output record stringvalue environment dcl 50 set ref 52 nptr parameter pointer dcl 127 ref 112 187 null builtin function dcl 46 ref 171 171 195 207 path 000100 automatic char(168) unaligned dcl 20 set ref 69* 76* 100* prog_list 000164 automatic file variable initial array dcl 52 set ref 52* 52* 52* 84 90 95 104 198* 216* rtrim builtin function dcl 46 ref 198 198 204 216 216 216 216 291 sc 001154 automatic fixed bin(35,0) dcl 247 set ref 269* 289* sdn parameter char(168) unaligned dcl 127 set ref 112 181 181* segp 000156 automatic pointer dcl 20 set ref 194* 195 198* 199* 206* 207 208 221* 231* sen parameter char(32) unaligned dcl 127 set ref 112 181* 183* specified 001146 automatic bit(1) initial array dcl 244 set ref 244* 244* 244* 277 297* substr builtin function dcl 46 ref 205 suffix 000013 internal static char(2) initial unaligned dcl 260 set ref 290* 291 suffixed_path 001160 automatic varying char(168) dcl 253 set ref 291* 294 298 sweep_disk_dec_ 000034 constant entry external dcl 32 ref 100 total 000651 automatic fixed bin(17,0) initial array dcl 61 set ref 61* 61* 61* 101* 101* 101* 198* 216* type based bit(2) level 2 packed unaligned dcl 141 ref 179 184 unaligned_decimal 000046 constant file output record stringvalue environment dcl 50 set ref 52 valid_arg 000000 constant char(18) initial array dcl 310 ref 315 316 316 version 2 000314 automatic fixed bin(17,0) level 2 dcl 162 set ref 170* xi 000304 automatic fixed bin(17,0) dcl 138 set ref 181* 183* 184* xp 000232 automatic char(168) unaligned dcl 138 set ref 181* 183* 190 192* 194* 206* 213 213* NAMES DECLARED BY EXPLICIT CONTEXT. bypass_segment 002322 constant label dcl 228 ref 173 counter 001255 constant entry internal dcl 112 ref 100 100 er 001230 constant label dcl 108 ref 77 80 hunt_dec 000500 constant entry external dcl 11 loop 002264 constant label dcl 219 process_ctl_args 002336 constant entry internal dcl 238 ref 79 valid_ctl 002721 constant entry internal dcl 307 ref 270 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3344 3440 3002 3354 Length 3716 3002 74 242 341 4 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME hunt_dec 857 external procedure is an external procedure. on unit on line 87 113 on unit uses I/O statements. counter 292 internal procedure is assigned to an entry variable, and enables or reverts conditions. on unit on line 165 78 on unit process_ctl_args internal procedure shares stack frame of external procedure hunt_dec. valid_ctl internal procedure shares stack frame of external procedure hunt_dec. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000013 suffix process_ctl_args STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME counter 000100 message counter 000200 ml counter 000202 header_ptr counter 000204 comp_ptr counter 000206 comp_name counter 000216 bit_count counter 000217 namec counter 000220 j counter 000221 k counter 000222 ename counter 000232 xp counter 000304 xi counter 000305 ecc counter 000314 cond_info counter hunt_dec 000100 path hunt_dec 000152 i hunt_dec 000154 ap hunt_dec 000156 segp hunt_dec 000160 al hunt_dec 000161 ec hunt_dec 000162 an hunt_dec 000163 code hunt_dec 000164 prog_list hunt_dec 000200 attach_description hunt_dec 000503 header hunt_dec 000651 total hunt_dec 000654 message hunt_dec 001146 specified process_ctl_args 001151 arg_count process_ctl_args 001152 arg_index process_ctl_args 001153 ctl_index process_ctl_args 001154 sc process_ctl_args 001155 arg_length process_ctl_args 001156 arg_ptr process_ctl_args 001160 suffixed_path process_ctl_args 001233 dir process_ctl_args 001305 entry process_ctl_args 001324 i valid_ctl on unit on line 165 000100 i on unit on line 165 000101 code on unit on line 165 THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out return tra_ext enable shorten_stack ext_entry int_entry record_io open close THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. absolute_pathname_ archive_util_$disected_element archive_util_$first_disected com_err_ continue_to_signal_ cu_$arg_count cu_$arg_ptr examine_object_ expand_pathname_$add_suffix find_condition_info_ get_wdir_ hcs_$initiate hcs_$initiate_count hcs_$terminate_noname ioa_ ioa_$rsnnl sweep_disk_dec_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. aligned_decimal aligned_decimal.fsb error_table_$badopt no_decimal no_decimal.fsb unaligned_decimal unaligned_decimal.fsb LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000477 20 000510 50 000512 52 000550 54 000601 56 000637 61 000676 62 000710 69 000711 70 000717 71 000736 72 000740 73 000767 76 000770 77 001014 79 001016 80 001021 83 001030 84 001035 85 001063 87 001065 89 001110 90 001117 91 001123 92 001126 94 001127 95 001134 96 001147 100 001151 101 001165 103 001214 104 001221 105 001225 106 001227 108 001230 110 001253 112 001254 165 001262 170 001276 171 001301 172 001317 173 001324 175 001337 176 001344 177 001353 179 001354 181 001362 183 001422 184 001451 185 001456 186 001462 187 001470 188 001504 189 001515 190 001516 192 001552 194 001605 195 001650 198 001655 199 001732 202 001745 204 001746 205 001760 206 001766 207 002032 208 002037 209 002041 210 002060 211 002062 212 002074 213 002075 215 002135 216 002164 218 002263 219 002264 220 002303 221 002304 222 002316 225 002317 226 002321 228 002322 231 002323 232 002335 238 002336 244 002347 262 002361 263 002363 265 002365 266 002374 268 002376 269 002401 270 002416 271 002435 273 002437 274 002443 275 002455 277 002456 279 002460 280 002504 282 002506 283 002507 285 002512 286 002514 287 002525 289 002526 290 002543 291 002600 292 002646 294 002652 295 002663 297 002664 298 002667 299 002715 300 002717 302 002720 307 002721 315 002732 316 002737 318 002761 320 002763 ----------------------------------------------------------- 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