COMPILATION LISTING OF SEGMENT vfile_adjust Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/04/82 1737.9 mst Thu 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 /* This command is used to restore storage system files to a 12* consistent state after detecting an interrupted operation */ 13 vfa: 14 vfile_adjust: 15 proc (pathname_arg); 16 seg_ptr, fcb_ptr, iocb_ptr = null; 17 call cu_$arg_count (n_args); /* number of args with which command was invoked */ 18 if n_args <= 0 /* must specify at least the pathname */ 19 then code = error_table_$noarg; 20 else if n_args > 3 /* limit of permissible args */ 21 then code = error_table_$too_many_args; 22 else code = 0; 23 call check_code; /* aborts if error detected */ 24 call get_file_base; /* gets first seg ptr */ 25 if (seg_ptr -> header.file_code ^= seq_code) & (seg_ptr -> header.file_code ^= blk_code) 26 & (seg_ptr -> header.file_code ^= indx_code) 27 then call adj_uns_file; /* makes the adjustment */ 28 else call adj_struc_file; /* takes care of structured files */ 29 call check_code; 30 cleanup: 31 if fcb_ptr ^= null /* free the msf control block */ 32 then call msf_manager_$close (fcb_ptr); 33 else if seg_ptr ^= null /* was single segment file */ 34 then call hcs_$terminate_noname (seg_ptr, code); 35 if iocb_ptr ^= null /* file was opened for adjustment */ 36 then do; /* close file and free I/O switch */ 37 call iox_$close (iocb_ptr, code); 38 call iox_$detach_iocb (iocb_ptr, code); 39 end; 40 return; /* end of main file adjustment routine */ 41 42 check_code: 43 proc; /* aborts if error detected */ 44 if code = 0 45 then return; 46 call com_err_ (code, "vfile_adjust"); /* signal the error */ 47 go to cleanup; /* don't leave a mess */ 48 end check_code; 49 50 get_file_base: 51 proc; /* finds first file component and sets seg_ptr */ 52 call expand_path_ (addr (pathname_arg), length (pathname_arg), addr (d_name), addr (e_name), code); 53 /* separate directory and entry names */ 54 call check_code; 55 call hcs_$status_long (d_name, e_name, 1, addr (branch_info), null, code); 56 call check_code; 57 if branch_info.type = "10"b /* directory or msf */ 58 then if branch_info.bit_count = "0"b /* directory */ 59 then code = error_table_$dirseg; 60 else do; /* get ptr to base of msf */ 61 call msf_manager_$open ((d_name), (e_name), fcb_ptr, code); 62 /* creates control block */ 63 call check_code; /* abort on error */ 64 call msf_manager_$get_ptr (fcb_ptr, 0, "0"b, seg_ptr, bc, code); 65 /* pointer to base of file */ 66 if seg_ptr ^= null 67 then code = 0; /* reset spurious code */ 68 end; 69 else do; /* get ptr to base of segment */ 70 call hcs_$initiate (d_name, e_name, "", 0, 1, seg_ptr, code); 71 if seg_ptr ^= null 72 then code = 0; /* no error if pointer returned */ 73 end; 74 call check_code; 75 end get_file_base; 76 77 adj_struc_file: 78 proc; /* adjusts all structured files */ 79 if n_args > 1 /* no args permitted for structured files */ 80 then code = error_table_$too_many_args; 81 call check_code; 82 call check_file_lock; /* may unlock file */ 83 call attach_unique_sw; /* need I/O switch to open and close */ 84 call iox_$open (iocb_ptr, 7 /* sequential_update */, "0"b, code); 85 /* adjustment will automatically be made if necessary */ 86 end adj_struc_file; 87 88 adj_uns_file: 89 proc; /* handles adjustments to unstructured files */ 90 if n_args <= 1 /* a control option must be specified */ 91 then code = error_table_$noarg; 92 call cu_$arg_ptr (2, opt1_ptr, opt1_len, code); 93 call check_code; 94 if n_args > 2 95 then do; /* pick up second optional arg */ 96 call cu_$arg_ptr (3, opt2_ptr, opt2_len, code); 97 call check_code; 98 end; 99 if n_args = 2 100 then if opt1_arg = "-set_bc" /* indicates setting to last non-zero byte */ 101 then call adjust_bit_count_ (d_name, e_name, "1"b /* last byte */, bc, code); 102 /* does the work */ 103 else if opt1_arg = "-use_nl" /* indic trunc after last complete line */ 104 then call trunc_at_line; 105 else if opt1_arg = "-set_nl" /* indic newline to be appended if not there */ 106 then call append_line; 107 else call get_use_bc; /* option must be "-use_bc" */ 108 else call get_use_bc; /* use existing bit count to truncate */ 109 return; /* unstructured file has been adjusted */ 110 111 trunc_at_line: 112 proc; /* truncates file after last new-line char */ 113 call prep_uns_file; /* positions to last line */ 114 call iox_$put_chars (iocb_ptr, (null), 0, code); /* truncates the file */ 115 end trunc_at_line; 116 117 prep_uns_file: 118 proc; /* sets position to last line of file or eof */ 119 call adjust_bit_count_ (d_name, e_name, "1"b, bc, code); 120 /* first set bit count to last non-zero byte */ 121 call check_code; 122 call attach_unique_sw; /* attaches uniquely named I/O switch with "-extend" option */ 123 call iox_$open (iocb_ptr, 3 /* stream_input_output */, "0"b, code); 124 /* file must be opened */ 125 call check_code; 126 call iox_$position (iocb_ptr, 0, 0, code); /* positions just past last newline char */ 127 end prep_uns_file; 128 129 append_line: 130 proc; /* puts newline char at eof if none already there */ 131 call prep_uns_file; /* position past last newline */ 132 call iox_$get_chars (iocb_ptr, addr (dummy_buffer), 1, rec_len, code); 133 /* get next character */ 134 if code ^= error_table_$end_of_info 135 then do; /* must append a newline char */ 136 call iox_$position (iocb_ptr, 1, 0, code); 137 /* go to end of file */ 138 call iox_$put_chars (iocb_ptr, addr (newline), 1, code); 139 end; 140 else code = 0; /* already ends in newline */ 141 end append_line; 142 143 get_use_bc: 144 proc; /* checks option and truncates at existing bitcount */ 145 if opt1_arg ^= "-use_bc" /* no other option will do */ 146 then code = error_table_$bad_arg; 147 else if branch_info.type ^= "10"b /* single segment case */ 148 then do; 149 if n_args > 2 /* msf component number specified */ 150 then if opt2_arg ^= "0" 151 then code = error_table_$bad_arg; 152 else call hcs_$truncate_seg (seg_ptr, divide (fixed (bit_count) + 35, 36, 18, 0), code); 153 end; 154 else do; /* get tail num and truncate */ 155 if n_args = 2 /* n not given--default is last non-zero component */ 156 then call get_last_nz_comp; 157 else call get_comp_n; /* picks up specified component-num arg */ 158 call check_code; 159 call msf_manager_$adjust (fcb_ptr, n_tail, bc, "011"b, code); 160 /* does the truncation */ 161 end; 162 return; /* end main routine for handling "-use_bc" option */ 163 164 get_last_nz_comp: 165 proc; /* finds last non-empty msf component or comp 0 if none */ 166 167 do n_tail = 1 repeat n_tail + 1 while (code = 0); /* find last msf comp */ 168 call msf_manager_$get_ptr (fcb_ptr, n_tail, "0"b, seg_ptr, bc, code); 169 /* pointer to next component */ 170 end; 171 172 n_recs = 0; /* last comp+1 has no recs */ 173 174 do n_tail = n_tail - 2 to 0 by -1 while (n_recs = 0); 175 /* find last non-empty comp */ 176 call msf_manager_$get_ptr (fcb_ptr, n_tail, "0"b, seg_ptr, bc, code); 177 /* ptr to preceding comp */ 178 call hcs_$fs_get_path_name (seg_ptr, d_name, d_len, e_name, code); 179 /* need path for hcs_$status_ */ 180 call hcs_$status_ (d_name, e_name, 0, addr (branch_info), null /* no names */, code); 181 /* gets n_recs */ 182 end; 183 184 n_tail = n_tail + 1; /* loop decrements once too often */ 185 186 end get_last_nz_comp; 187 188 get_comp_n: 189 proc; /* sets n_tail to specified component number */ 190 n_tail = cv_dec_check_ (opt2_arg, code); /* validates conversion */ 191 call check_code; 192 call msf_manager_$get_ptr (fcb_ptr, n_tail, "0"b, seg_ptr, bc, code); 193 /* n'th comp info */ 194 end get_comp_n; 195 196 end get_use_bc; 197 198 end adj_uns_file; 199 200 attach_unique_sw: 201 proc; /* attaches I/O switch with "-extend" control option */ 202 call iox_$attach_ioname (unique_chars_ ("0"b), iocb_ptr, "vfile_ " || pathname_arg || " -extend", code); 203 call check_code; 204 end attach_unique_sw; 205 206 check_file_lock: 207 proc; /* may reset file lock */ 208 lock_word = seg_ptr -> header.lock_word; /* copy the file lock to examine it */ 209 call set_lock_$lock (lock_word, 0, code); 210 if code ^= 0 211 then if code = error_table_$locked_by_this_process 212 then do; /* warn user about danger of recursive use of vfile_ */ 213 call command_query_ (addr (query_info), answer, "vfile_adjust", 214 "Warning--file locked 215 by this process. Resuming a previous invocation 216 of vfile_ after adjustment may produce unpredictable 217 errors. Close the I/O switch or issue a new_proc to be safe. 218 Do you still wish to adjust the file?" 219 ); /* let user decide */ 220 if answer = "no" 221 then go to cleanup; /* forget the whole thing */ 222 seg_ptr -> header.lock_word = bit (-1); 223 /* lock becomes invalid */ 224 end; 225 end check_file_lock; 226 227 /* declarations for entire program */ 228 dcl hcs_$status_long entry (char (*) aligned, char (*) aligned, fixed (1), ptr, ptr, fixed (35)); 229 dcl hcs_$initiate entry (char (*) aligned, char (*) aligned, char (*) aligned, fixed (1), fixed (2), 230 ptr, fixed (35)); 231 dcl hcs_$terminate_noname entry (ptr, fixed (35)); 232 dcl lock_word bit (36) aligned; 233 dcl seq_code static internal fixed init (83711); 234 dcl blk_code static internal fixed init (22513); 235 dcl indx_code static internal fixed init (7129); 236 dcl hcs_$truncate_seg entry (ptr, fixed (18), fixed (35)); 237 dcl error_table_$end_of_info 238 external fixed (35); 239 dcl iox_$put_chars entry (ptr, ptr, fixed (21), fixed (35)); 240 dcl iox_$position entry (ptr, fixed, fixed, fixed (35)); 241 dcl iox_$get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed (35)); 242 dcl rec_len fixed (21); 243 dcl newline char (1) aligned static internal init (" 244 "); 245 dcl dummy_buffer char (1) aligned; 246 dcl pathname_arg char (*); 247 dcl opt1_arg char (opt1_len) based (opt1_ptr); 248 dcl opt2_arg char (opt2_len) based (opt2_ptr); 249 dcl (opt1_len, opt2_len) fixed; 250 dcl (opt1_ptr, opt2_ptr) ptr; 251 dcl cu_$arg_ptr entry (fixed, ptr, fixed, fixed (35)); 252 dcl (fcb_ptr, iocb_ptr) ptr; 253 dcl cu_$arg_count entry (fixed); 254 dcl n_args fixed; 255 dcl code fixed (35); 256 dcl (error_table_$noarg, error_table_$dirseg, error_table_$too_many_args, error_table_$bad_arg, 257 error_table_$locked_by_this_process) 258 external fixed (35); 259 dcl (null, fixed, bit, divide, addr) 260 builtin; 261 dcl msf_manager_$close entry (ptr); 262 dcl iox_$close entry (ptr, fixed (35)); 263 dcl iox_$open entry (ptr, fixed, bit (1) aligned, fixed (35)); 264 dcl iox_$detach_iocb entry (ptr, fixed (35)); 265 dcl com_err_ entry options (variable); 266 dcl expand_path_ entry (ptr, fixed, ptr, ptr, fixed (35)); 267 dcl msf_manager_$open entry (char (*) aligned, char (*) aligned, ptr, fixed (35)); 268 dcl msf_manager_$get_ptr entry (ptr, fixed, bit (1), ptr, fixed (24), fixed (35)); 269 dcl d_name char (168) aligned; 270 dcl e_name char (32) aligned; 271 dcl seg_ptr ptr; 272 dcl bc fixed (24); 273 dcl 1 header based (seg_ptr), 274 2 file_code fixed (35), 275 2 lock_word bit (36) aligned; 276 dcl adjust_bit_count_ entry (char (168) aligned, char (32) aligned, bit (1) aligned, fixed (24), 277 fixed (35)); 278 dcl n_tail fixed; 279 dcl msf_manager_$adjust entry (ptr, fixed, fixed (24), bit (3), fixed (35)); 280 dcl hcs_$fs_get_path_name entry (ptr, char (*) aligned, fixed, char (*) aligned, fixed (35)); 281 dcl hcs_$status_ entry (char (*) aligned, char (*) aligned, fixed (1), ptr, ptr, fixed (35)); 282 dcl d_len fixed; 283 dcl 1 branch_info aligned, 284 ( 2 type bit (2), 285 2 nnames fixed (15), 286 2 nrp bit (18), 287 2 dtm bit (36), 288 2 dtu bit (36), 289 2 mode bit (5), 290 2 pad bit (13), 291 2 n_recs fixed (17) 292 ) unaligned, 293 2 words1 (3) fixed, 294 2 pad1 bit (12) unal, 295 2 bit_count bit (24) unal, 296 2 words2 (2) fixed; 297 dcl cv_dec_check_ entry (char (*), fixed (35)) returns (fixed (35)); 298 dcl set_lock_$lock entry (bit (36) aligned, fixed, fixed (35)); 299 dcl command_query_ entry options (variable); 300 dcl 1 query_info aligned, 301 2 version fixed init (2), 302 2 yes_or_no_sw bit (1) unal init ("1"b), 303 2 suppress_name_sw bit (1) unal init ("0"b), 304 2 code fixed (35), 305 2 query_code fixed (35); 306 dcl answer char (12) var; 307 dcl iox_$attach_ioname entry (char (*), ptr, char (*), fixed (35)); 308 dcl unique_chars_ entry (bit (*)) returns (char (15)); 309 end vfile_adjust; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/82 1621.0 vfile_adjust.pl1 >dumps>old>recomp>vfile_adjust.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. addr builtin function dcl 259 ref 52 52 52 52 52 52 55 55 132 132 138 138 180 180 213 213 adjust_bit_count_ 000070 constant entry external dcl 276 ref 99 119 answer 000225 automatic varying char(12) dcl 306 set ref 213* 220 bc 000204 automatic fixed bin(24,0) dcl 272 set ref 64* 99* 119* 159* 168* 176* 192* bit builtin function dcl 259 ref 222 bit_count 7(12) 000207 automatic bit(24) level 2 packed unaligned dcl 283 set ref 57 152 152 blk_code constant fixed bin(17,0) initial dcl 234 ref 25 branch_info 000207 automatic structure level 1 dcl 283 set ref 55 55 180 180 code 000117 automatic fixed bin(35,0) dcl 255 set ref 18* 20* 22* 33* 37* 38* 44 46* 52* 55* 57* 61* 64* 66* 70* 71* 79* 84* 90* 92* 96* 99* 114* 119* 123* 126* 132* 134 136* 138* 140* 145* 149* 152* 159* 167 168* 176* 178* 180* 190* 192* 202* 209* 210 210 com_err_ 000060 constant entry external dcl 265 ref 46 command_query_ 000104 constant entry external dcl 299 ref 213 cu_$arg_count 000034 constant entry external dcl 253 ref 17 cu_$arg_ptr 000032 constant entry external dcl 251 ref 92 96 cv_dec_check_ 000100 constant entry external dcl 297 ref 190 d_len 000206 automatic fixed bin(17,0) dcl 282 set ref 178* d_name 000120 automatic char(168) dcl 269 set ref 52 52 55* 61 70* 99* 119* 178* 180* divide builtin function dcl 259 ref 152 152 dummy_buffer 000102 automatic char(1) dcl 245 set ref 132 132 e_name 000172 automatic char(32) dcl 270 set ref 52 52 55* 61 70* 99* 119* 178* 180* error_table_$bad_arg 000044 external static fixed bin(35,0) dcl 256 ref 145 149 error_table_$dirseg 000040 external static fixed bin(35,0) dcl 256 ref 57 error_table_$end_of_info 000022 external static fixed bin(35,0) dcl 237 ref 134 error_table_$locked_by_this_process 000046 external static fixed bin(35,0) dcl 256 ref 210 error_table_$noarg 000036 external static fixed bin(35,0) dcl 256 ref 18 90 error_table_$too_many_args 000042 external static fixed bin(35,0) dcl 256 ref 20 79 expand_path_ 000062 constant entry external dcl 266 ref 52 fcb_ptr 000112 automatic pointer dcl 252 set ref 16* 30 30* 61* 64* 159* 168* 176* 192* file_code based fixed bin(35,0) level 2 dcl 273 ref 25 25 25 fixed builtin function dcl 259 ref 152 152 hcs_$fs_get_path_name 000074 constant entry external dcl 280 ref 178 hcs_$initiate 000014 constant entry external dcl 229 ref 70 hcs_$status_ 000076 constant entry external dcl 281 ref 180 hcs_$status_long 000012 constant entry external dcl 228 ref 55 hcs_$terminate_noname 000016 constant entry external dcl 231 ref 33 hcs_$truncate_seg 000020 constant entry external dcl 236 ref 152 header based structure level 1 unaligned dcl 273 indx_code constant fixed bin(17,0) initial dcl 235 ref 25 iocb_ptr 000114 automatic pointer dcl 252 set ref 16* 35 37* 38* 84* 114* 123* 126* 132* 136* 138* 202* iox_$attach_ioname 000106 constant entry external dcl 307 ref 202 iox_$close 000052 constant entry external dcl 262 ref 37 iox_$detach_iocb 000056 constant entry external dcl 264 ref 38 iox_$get_chars 000030 constant entry external dcl 241 ref 132 iox_$open 000054 constant entry external dcl 263 ref 84 123 iox_$position 000026 constant entry external dcl 240 ref 126 136 iox_$put_chars 000024 constant entry external dcl 239 ref 114 138 lock_word 1 based bit(36) level 2 in structure "header" dcl 273 in procedure "vfile_adjust" set ref 208 222* lock_word 000100 automatic bit(36) dcl 232 in procedure "vfile_adjust" set ref 208* 209* msf_manager_$adjust 000072 constant entry external dcl 279 ref 159 msf_manager_$close 000050 constant entry external dcl 261 ref 30 msf_manager_$get_ptr 000066 constant entry external dcl 268 ref 64 168 176 192 msf_manager_$open 000064 constant entry external dcl 267 ref 61 n_args 000116 automatic fixed bin(17,0) dcl 254 set ref 17* 18 20 79 90 94 99 149 155 n_recs 3(18) 000207 automatic fixed bin(17,0) level 2 packed unaligned dcl 283 set ref 172* 174 n_tail 000205 automatic fixed bin(17,0) dcl 278 set ref 159* 167* 168* 170* 174* 174* 176* 184* 184 190* 192* newline 000010 internal static char(1) initial dcl 243 set ref 138 138 null builtin function dcl 259 ref 16 30 33 35 55 55 66 71 114 180 180 opt1_arg based char unaligned dcl 247 ref 99 103 105 145 opt1_len 000103 automatic fixed bin(17,0) dcl 249 set ref 92* 99 103 105 145 opt1_ptr 000106 automatic pointer dcl 250 set ref 92* 99 103 105 145 opt2_arg based char unaligned dcl 248 set ref 149 190* opt2_len 000104 automatic fixed bin(17,0) dcl 249 set ref 96* 149 190 190 opt2_ptr 000110 automatic pointer dcl 250 set ref 96* 149 190 pathname_arg parameter char unaligned dcl 246 set ref 13 13 52 52 52 52 202 query_info 000221 automatic structure level 1 dcl 300 set ref 213 213 rec_len 000101 automatic fixed bin(21,0) dcl 242 set ref 132* seg_ptr 000202 automatic pointer dcl 271 set ref 16* 25 25 25 33 33* 64* 66 70* 71 152* 168* 176* 178* 192* 208 222 seq_code constant fixed bin(17,0) initial dcl 233 ref 25 set_lock_$lock 000102 constant entry external dcl 298 ref 209 suppress_name_sw 1(01) 000221 automatic bit(1) initial level 2 packed unaligned dcl 300 set ref 300* type 000207 automatic bit(2) level 2 packed unaligned dcl 283 set ref 57 147 unique_chars_ 000110 constant entry external dcl 308 ref 202 202 version 000221 automatic fixed bin(17,0) initial level 2 dcl 300 set ref 300* yes_or_no_sw 1 000221 automatic bit(1) initial level 2 packed unaligned dcl 300 set ref 300* NAMES DECLARED BY EXPLICIT CONTEXT. adj_struc_file 000624 constant entry internal dcl 77 ref 28 adj_uns_file 000660 constant entry internal dcl 88 ref 25 append_line 001116 constant entry internal dcl 129 ref 105 attach_unique_sw 001563 constant entry internal dcl 200 ref 83 122 check_code 000325 constant entry internal dcl 42 ref 23 29 54 56 63 74 81 93 97 121 125 158 191 203 check_file_lock 001662 constant entry internal dcl 206 ref 82 cleanup 000245 constant label dcl 30 ref 47 220 get_comp_n 001510 constant entry internal dcl 188 ref 157 get_file_base 000353 constant entry internal dcl 50 ref 24 get_last_nz_comp 001322 constant entry internal dcl 164 ref 155 get_use_bc 001212 constant entry internal dcl 143 ref 107 108 prep_uns_file 001030 constant entry internal dcl 117 ref 113 131 trunc_at_line 001005 constant entry internal dcl 111 ref 103 vfa 000164 constant entry external dcl 13 vfile_adjust 000145 constant entry external dcl 13 NAME DECLARED BY CONTEXT OR IMPLICATION. length builtin function ref 52 52 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2334 2446 1762 2344 Length 2700 1762 112 215 351 2 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME vfile_adjust 654 external procedure is an external procedure. check_code internal procedure shares stack frame of external procedure vfile_adjust. get_file_base internal procedure shares stack frame of external procedure vfile_adjust. adj_struc_file internal procedure shares stack frame of external procedure vfile_adjust. adj_uns_file internal procedure shares stack frame of external procedure vfile_adjust. trunc_at_line internal procedure shares stack frame of external procedure vfile_adjust. prep_uns_file internal procedure shares stack frame of external procedure vfile_adjust. append_line internal procedure shares stack frame of external procedure vfile_adjust. get_use_bc internal procedure shares stack frame of external procedure vfile_adjust. get_last_nz_comp internal procedure shares stack frame of external procedure vfile_adjust. get_comp_n internal procedure shares stack frame of external procedure vfile_adjust. attach_unique_sw internal procedure shares stack frame of external procedure vfile_adjust. check_file_lock internal procedure shares stack frame of external procedure vfile_adjust. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 newline vfile_adjust STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME vfile_adjust 000100 lock_word vfile_adjust 000101 rec_len vfile_adjust 000102 dummy_buffer vfile_adjust 000103 opt1_len vfile_adjust 000104 opt2_len vfile_adjust 000106 opt1_ptr vfile_adjust 000110 opt2_ptr vfile_adjust 000112 fcb_ptr vfile_adjust 000114 iocb_ptr vfile_adjust 000116 n_args vfile_adjust 000117 code vfile_adjust 000120 d_name vfile_adjust 000172 e_name vfile_adjust 000202 seg_ptr vfile_adjust 000204 bc vfile_adjust 000205 n_tail vfile_adjust 000206 d_len vfile_adjust 000207 branch_info vfile_adjust 000221 query_info vfile_adjust 000225 answer vfile_adjust THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out return shorten_stack ext_entry_desc divide_fx3 THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. adjust_bit_count_ com_err_ command_query_ cu_$arg_count cu_$arg_ptr cv_dec_check_ expand_path_ hcs_$fs_get_path_name hcs_$initiate hcs_$status_ hcs_$status_long hcs_$terminate_noname hcs_$truncate_seg iox_$attach_ioname iox_$close iox_$detach_iocb iox_$get_chars iox_$open iox_$position iox_$put_chars msf_manager_$adjust msf_manager_$close msf_manager_$get_ptr msf_manager_$open set_lock_$lock unique_chars_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_arg error_table_$dirseg error_table_$end_of_info error_table_$locked_by_this_process error_table_$noarg error_table_$too_many_args LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 300 000132 13 000142 16 000200 17 000204 18 000213 20 000221 22 000227 23 000230 24 000231 25 000232 28 000243 29 000244 30 000245 33 000261 35 000276 37 000302 38 000313 40 000324 42 000325 44 000326 46 000331 47 000352 50 000353 52 000354 54 000404 55 000405 56 000447 57 000450 61 000463 63 000516 64 000517 66 000543 68 000550 70 000551 71 000615 74 000622 75 000623 77 000624 79 000625 81 000633 82 000634 83 000635 84 000636 86 000657 88 000660 90 000661 92 000667 93 000706 94 000707 96 000712 97 000731 99 000732 103 000765 105 000773 107 001001 108 001003 109 001004 111 001005 113 001006 114 001007 115 001027 117 001030 119 001031 121 001052 122 001053 123 001054 125 001075 126 001076 127 001115 129 001116 131 001117 132 001120 134 001143 136 001147 138 001166 139 001207 140 001210 141 001211 143 001212 145 001213 147 001225 149 001231 152 001246 153 001270 155 001271 157 001276 158 001277 159 001300 162 001321 164 001322 167 001323 168 001327 170 001352 172 001354 174 001356 176 001366 178 001411 180 001442 182 001503 184 001506 186 001507 188 001510 190 001511 191 001536 192 001537 194 001562 200 001563 202 001564 203 001657 204 001661 206 001662 208 001663 209 001666 210 001702 213 001707 220 001744 222 001751 225 001754 ----------------------------------------------------------- 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