COMPILATION LISTING OF SEGMENT syn_ Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 0958.1 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 /* format: style4,delnl,insnl,tree,ifthenstmt,indnoniterend */ 14 15 /* Modified 05/15/84 by Jim Lippard to free attach data on detach */ 16 syn_$syn_attach: 17 proc (p1, args, loud_sw_param, Code); 18 19 /* Parameters. */ 20 21 dcl args (*) char (*) varying parameter; 22 dcl p1 ptr parameter; 23 dcl loud_sw_param bit (1) aligned parameter; 24 dcl Code fixed bin (35) parameter; 25 26 /* Automatic. */ 27 28 dcl blkptr ptr; 29 dcl code fixed (35); 30 dcl i fixed; 31 dcl inhibit_sw bit (1); 32 dcl inhibits bit (36); 33 dcl loud_sw bit (1); 34 dcl mask fixed (35); 35 dcl (p2, p3) ptr; 36 37 /* Procedures. */ 38 39 dcl com_err_ ext entry options (variable); 40 dcl get_system_free_area_ entry () returns (ptr); 41 dcl hcs_$set_ips_mask ext entry (fixed bin (35), fixed bin (35)); 42 dcl hcs_$reset_ips_mask ext entry (fixed bin (35), fixed bin (35)); 43 dcl iox_$find_iocb entry (char (*), ptr, fixed bin (35)); 44 dcl iox_$propagate entry (ptr); 45 46 /* Based. */ 47 48 dcl based_area area based; 49 50 dcl 1 blk aligned based (blkptr), 51 2 attach char (189) varying; 1 1 /* BEGIN INCLUDE FILE iocbx.incl.pl1 */ 1 2 /* written 27 Dec 1973, M. G. Smith */ 1 3 /* returns attributes removed, hashing support BIM Spring 1981 */ 1 4 /* version made character string June 1981 BIM */ 1 5 /* Modified 11/29/82 by S. Krupp to add new entries and to change 1 6* version number to IOX2. */ 1 7 /* format: style2 */ 1 8 1 9 dcl 1 iocb aligned based, /* I/O control block. */ 1 10 2 version character (4) aligned, /* IOX2 */ 1 11 2 name char (32), /* I/O name of this block. */ 1 12 2 actual_iocb_ptr ptr, /* IOCB ultimately SYNed to. */ 1 13 2 attach_descrip_ptr ptr, /* Ptr to printable attach description. */ 1 14 2 attach_data_ptr ptr, /* Ptr to attach data structure. */ 1 15 2 open_descrip_ptr ptr, /* Ptr to printable open description. */ 1 16 2 open_data_ptr ptr, /* Ptr to open data structure (old SDB). */ 1 17 2 event_channel bit (72), /* Event channel for asynchronous I/O. */ 1 18 2 detach_iocb entry (ptr, fixed bin (35)), 1 19 /* detach_iocb(p) */ 1 20 2 open entry (ptr, fixed, bit (1) aligned, fixed bin (35)), 1 21 /* open(p,mode,not_used) */ 1 22 2 close entry (ptr, fixed bin (35)), 1 23 /* close(p) */ 1 24 2 get_line entry (ptr, ptr, fixed (21), fixed (21), fixed bin (35)), 1 25 /* get_line(p,bufptr,buflen,actlen) */ 1 26 2 get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed bin (35)), 1 27 /* get_chars(p,bufptr,buflen,actlen) */ 1 28 2 put_chars entry (ptr, ptr, fixed (21), fixed bin (35)), 1 29 /* put_chars(p,bufptr,buflen) */ 1 30 2 modes entry (ptr, char (*), char (*), fixed bin (35)), 1 31 /* modes(p,newmode,oldmode) */ 1 32 2 position entry (ptr, fixed, fixed (21), fixed bin (35)), 1 33 /* position(p,u1,u2) */ 1 34 2 control entry (ptr, char (*), ptr, fixed bin (35)), 1 35 /* control(p,order,infptr) */ 1 36 2 read_record entry (ptr, ptr, fixed (21), fixed (21), fixed bin (35)), 1 37 /* read_record(p,bufptr,buflen,actlen) */ 1 38 2 write_record entry (ptr, ptr, fixed (21), fixed bin (35)), 1 39 /* write_record(p,bufptr,buflen) */ 1 40 2 rewrite_record entry (ptr, ptr, fixed (21), fixed bin (35)), 1 41 /* rewrite_record(p,bufptr,buflen) */ 1 42 2 delete_record entry (ptr, fixed bin (35)), 1 43 /* delete_record(p) */ 1 44 2 seek_key entry (ptr, char (256) varying, fixed (21), fixed bin (35)), 1 45 /* seek_key(p,key,len) */ 1 46 2 read_key entry (ptr, char (256) varying, fixed (21), fixed bin (35)), 1 47 /* read_key(p,key,len) */ 1 48 2 read_length entry (ptr, fixed (21), fixed bin (35)), 1 49 /* read_length(p,len) */ 1 50 2 open_file entry (ptr, fixed bin, char (*), bit (1) aligned, fixed bin (35)), 1 51 /* open_file(p,mode,desc,not_used,s) */ 1 52 2 close_file entry (ptr, char (*), fixed bin (35)), 1 53 /* close_file(p,desc,s) */ 1 54 2 detach entry (ptr, char (*), fixed bin (35)), 1 55 /* detach(p,desc,s) */ 1 56 /* Hidden information, to support SYN attachments. */ 1 57 2 ios_compatibility ptr, /* Ptr to old DIM's IOS transfer vector. */ 1 58 2 syn_inhibits bit (36), /* Operations inhibited by SYN. */ 1 59 2 syn_father ptr, /* IOCB immediately SYNed to. */ 1 60 2 syn_brother ptr, /* Next IOCB SYNed as this one is. */ 1 61 2 syn_son ptr, /* First IOCB SYNed to this one. */ 1 62 2 hash_chain_ptr ptr; /* Next IOCB in hash bucket */ 1 63 1 64 declare iox_$iocb_version_sentinel 1 65 character (4) aligned external static; 1 66 1 67 /* END INCLUDE FILE iocbx.incl.pl1 */ 52 53 54 /* Constants. */ 55 56 dcl error_table_$cyclic_syn fixed (35) ext; 57 dcl error_table_$not_detached fixed (35) ext; 58 dcl error_table_$noarg fixed (35) ext; 59 dcl error_table_$badopt fixed (35) ext; 60 dcl iox_$err_no_operation ext entry options (variable); 61 dcl iox_$err_not_attached ext entry options (variable); 62 dcl iox_$err_not_open ext entry options (variable); 63 dcl open_bit bit (36) int static init ("100000000000000"b); 64 dcl close_bit bit (36) int static init ("010000000000000"b); 65 dcl get_line_bit bit (36) int static init ("001000000000000"b); 66 dcl get_chars_bit bit (36) int static init ("000100000000000"b); 67 dcl put_chars_bit bit (36) int static init ("000010000000000"b); 68 dcl modes_bit bit (36) int static init ("000001000000000"b); 69 dcl position_bit bit (36) int static init ("000000100000000"b); 70 dcl control_bit bit (36) int static init ("000000010000000"b); 71 dcl read_record_bit bit (36) int static init ("000000001000000"b); 72 dcl write_record_bit bit (36) int static init ("000000000100000"b); 73 dcl rewrite_record_bit bit (36) int static init ("000000000010000"b); 74 dcl delete_record_bit bit (36) int static init ("000000000001000"b); 75 dcl seek_key_bit bit (36) int static init ("000000000000100"b); 76 dcl read_key_bit bit (36) int static init ("000000000000010"b); 77 dcl read_length_bit bit (36) int static init ("000000000000001"b); 78 79 /* Built-ins. */ 80 81 dcl (addr, hbound, index, null) builtin; 82 83 dcl cleanup condition; 84 85 /* End of declarations. */ 86 87 /* Beginning of entry point ..... syn_$syn_attach(p1,args,loud_sw_param,Code) ..... */ 88 89 loud_sw = loud_sw_param; 90 mask = 0; /* used by cleaner which is called by error */ 91 92 if hbound (args, 1) < 1 then call error (error_table_$noarg); 93 94 call iox_$find_iocb ((args (1)), p2, code); 95 if code ^= 0 then call error (code); 96 97 inhibits, inhibit_sw = "0"b; 98 do i = 2 to hbound (args, 1); 99 if /* case */ (args (i) = "-inh") | (args (i) = "-inhibit") then inhibit_sw = "1"b; 100 else if ^inhibit_sw then go to badopt; 101 else if args (i) = "open" then inhibits = inhibits | open_bit; 102 else if args (i) = "close" then inhibits = inhibits | close_bit; 103 else if args (i) = "get_line" then inhibits = inhibits | get_line_bit; 104 else if args (i) = "get_chars" then inhibits = inhibits | get_chars_bit; 105 else if args (i) = "put_chars" then inhibits = inhibits | put_chars_bit; 106 else if args (i) = "modes" then inhibits = inhibits | modes_bit; 107 else if args (i) = "position" then inhibits = inhibits | position_bit; 108 else if args (i) = "control" then inhibits = inhibits | control_bit; 109 else if args (i) = "read_record" then inhibits = inhibits | read_record_bit; 110 else if args (i) = "write_record" then inhibits = inhibits | write_record_bit; 111 else if args (i) = "rewrite_record" then inhibits = inhibits | rewrite_record_bit; 112 else if args (i) = "delete_record" then inhibits = inhibits | delete_record_bit; 113 else if args (i) = "seek_key" then inhibits = inhibits | seek_key_bit; 114 else if args (i) = "read_key" then inhibits = inhibits | read_key_bit; 115 else if args (i) = "read_length" then inhibits = inhibits | read_length_bit; 116 else 117 badopt: 118 call error (error_table_$badopt); 119 end; 120 121 if p1 -> iocb.attach_descrip_ptr ^= null () then call error (error_table_$not_detached); 122 if p2 -> iocb.actual_iocb_ptr = p1 then call error (error_table_$cyclic_syn); 123 124 allocate blk in (get_system_free_area_ () -> based_area) set (blkptr); 125 blk.attach = "syn_ " || rtrim (p2 -> iocb.name); 126 if inhibits ^= ""b then do; 127 blk.attach = blk.attach || " -inh"; 128 if inhibits & open_bit then blk.attach = blk.attach || " open"; 129 if inhibits & close_bit then blk.attach = blk.attach || " close"; 130 if inhibits & get_line_bit then blk.attach = blk.attach || " get_line"; 131 if inhibits & get_chars_bit then blk.attach = blk.attach || " get_chars"; 132 if inhibits & put_chars_bit then blk.attach = blk.attach || " put_chars"; 133 if inhibits & modes_bit then blk.attach = blk.attach || " modes"; 134 if inhibits & position_bit then blk.attach = blk.attach || " position"; 135 if inhibits & control_bit then blk.attach = blk.attach || " control"; 136 if inhibits & read_record_bit then blk.attach = blk.attach || " read_record"; 137 if inhibits & write_record_bit then blk.attach = blk.attach || " write_record"; 138 if inhibits & rewrite_record_bit then blk.attach = blk.attach || " rewrite_record"; 139 if inhibits & delete_record_bit then blk.attach = blk.attach || " delete_record"; 140 if inhibits & seek_key_bit then blk.attach = blk.attach || " seek_key"; 141 if inhibits & read_key_bit then blk.attach = blk.attach || " read_key"; 142 if inhibits & read_length_bit then blk.attach = blk.attach || " read_length"; 143 end; 144 145 mask = 0; 146 on cleanup call cleaner; 147 call hcs_$set_ips_mask (0, mask); 148 149 p1 -> iocb.actual_iocb_ptr = p2 -> iocb.actual_iocb_ptr; 150 p1 -> iocb.attach_descrip_ptr = addr (blk.attach); 151 p1 -> iocb.attach_data_ptr = blkptr; 152 p1 -> iocb.open_descrip_ptr = p2 -> iocb.open_descrip_ptr; 153 p1 -> iocb.open_data_ptr = p2 -> iocb.open_data_ptr; 154 p1 -> iocb.detach_iocb = syn_detach; 155 if inhibits & open_bit 156 then p1 -> iocb.open = iox_$err_no_operation; 157 else p1 -> iocb.open = p2 -> iocb.open; 158 if inhibits & close_bit 159 then p1 -> iocb.close = iox_$err_no_operation; 160 else p1 -> iocb.close = p2 -> iocb.close; 161 if inhibits & get_line_bit 162 then p1 -> iocb.get_line = iox_$err_no_operation; 163 else p1 -> iocb.get_line = p2 -> iocb.get_line; 164 if inhibits & get_chars_bit 165 then p1 -> iocb.get_chars = iox_$err_no_operation; 166 else p1 -> iocb.get_chars = p2 -> iocb.get_chars; 167 if inhibits & put_chars_bit 168 then p1 -> iocb.put_chars = iox_$err_no_operation; 169 else p1 -> iocb.put_chars = p2 -> iocb.put_chars; 170 if inhibits & modes_bit 171 then p1 -> iocb.modes = iox_$err_no_operation; 172 else p1 -> iocb.modes = p2 -> iocb.modes; 173 if inhibits & position_bit 174 then p1 -> iocb.position = iox_$err_no_operation; 175 else p1 -> iocb.position = p2 -> iocb.position; 176 if inhibits & control_bit 177 then p1 -> iocb.control = iox_$err_no_operation; 178 else p1 -> iocb.control = p2 -> iocb.control; 179 if inhibits & read_record_bit 180 then p1 -> iocb.read_record = iox_$err_no_operation; 181 else p1 -> iocb.read_record = p2 -> iocb.read_record; 182 if inhibits & write_record_bit 183 then p1 -> iocb.write_record = iox_$err_no_operation; 184 else p1 -> iocb.write_record = p2 -> iocb.write_record; 185 if inhibits & rewrite_record_bit 186 then p1 -> iocb.rewrite_record = iox_$err_no_operation; 187 else p1 -> iocb.rewrite_record = p2 -> iocb.rewrite_record; 188 if inhibits & delete_record_bit 189 then p1 -> iocb.delete_record = iox_$err_no_operation; 190 else p1 -> iocb.delete_record = p2 -> iocb.delete_record; 191 if inhibits & seek_key_bit 192 then p1 -> iocb.seek_key = iox_$err_no_operation; 193 else p1 -> iocb.seek_key = p2 -> iocb.seek_key; 194 if inhibits & read_key_bit 195 then p1 -> iocb.read_key = iox_$err_no_operation; 196 else p1 -> iocb.read_key = p2 -> iocb.read_key; 197 if inhibits & read_length_bit 198 then p1 -> iocb.read_length = iox_$err_no_operation; 199 else p1 -> iocb.read_length = p2 -> iocb.read_length; 200 p1 -> iocb.ios_compatibility = p2 -> iocb.ios_compatibility; 201 p1 -> iocb.syn_inhibits = inhibits; 202 p1 -> iocb.syn_father = p2; 203 p1 -> iocb.syn_brother = p2 -> iocb.syn_son; 204 p2 -> iocb.syn_son = p1; 205 call iox_$propagate (p1); 206 call cleaner; 207 Code = 0; 208 return; 209 210 /* Handler for the 'detach_iocb' I/O operation. */ 211 212 syn_detach: 213 entry (p1, Code); 214 215 mask = 0; 216 on cleanup call cleaner; 217 call hcs_$set_ips_mask (0, mask); 218 219 blkptr = p1 -> iocb.attach_data_ptr; 220 p1 -> iocb.actual_iocb_ptr = p1; 221 p1 -> iocb.attach_descrip_ptr = null (); 222 p1 -> iocb.attach_data_ptr = null (); 223 p1 -> iocb.open_descrip_ptr = null (); 224 p1 -> iocb.open_data_ptr = null (); 225 p1 -> iocb.detach_iocb = iox_$err_not_attached; 226 p1 -> iocb.open = iox_$err_not_attached; 227 p1 -> iocb.close = iox_$err_not_open; 228 p1 -> iocb.get_line = iox_$err_not_open; 229 p1 -> iocb.get_chars = iox_$err_not_open; 230 p1 -> iocb.put_chars = iox_$err_not_open; 231 p1 -> iocb.modes = iox_$err_not_open; 232 p1 -> iocb.position = iox_$err_not_open; 233 p1 -> iocb.control = iox_$err_not_open; 234 p1 -> iocb.read_record = iox_$err_not_open; 235 p1 -> iocb.write_record = iox_$err_not_open; 236 p1 -> iocb.rewrite_record = iox_$err_not_open; 237 p1 -> iocb.delete_record = iox_$err_not_open; 238 p1 -> iocb.seek_key = iox_$err_not_open; 239 p1 -> iocb.read_key = iox_$err_not_open; 240 p1 -> iocb.read_length = iox_$err_not_open; 241 p1 -> iocb.ios_compatibility = null (); 242 p1 -> iocb.syn_inhibits = "0"b; 243 p3 = p1 -> iocb.syn_father; 244 if p3 -> iocb.syn_son = p1 245 then p3 -> iocb.syn_son = p1 -> iocb.syn_brother; 246 else do; 247 do p3 = p3 -> iocb.syn_son repeat p3 -> iocb.syn_brother while (p3 -> iocb.syn_brother ^= p1); 248 end; 249 p3 -> iocb.syn_brother = p1 -> iocb.syn_brother; 250 end; 251 p1 -> iocb.syn_father, p1 -> iocb.syn_brother = null (); 252 call iox_$propagate (p1); 253 call cleaner; 254 Code = 0; 255 free blkptr -> blk; 256 return; 257 258 error: 259 procedure (c); 260 dcl c fixed bin (35) parameter; 261 262 call cleaner; 263 if loud_sw then call com_err_ (c, "syn_"); 264 code = c; 265 go to return; 266 end error; 267 268 return: 269 Code = code; 270 return; 271 272 273 cleaner: 274 procedure; 275 if mask ^= 0 then call hcs_$reset_ips_mask (mask, mask); 276 return; 277 end cleaner; 278 279 end syn_$syn_attach; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0803.9 syn_.pl1 >spec>install>1111>syn_.pl1 52 1 06/03/83 1008.5 iocbx.incl.pl1 >ldd>include>iocbx.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. Code parameter fixed bin(35,0) dcl 24 set ref 16 207* 212 254* 268* actual_iocb_ptr 12 based pointer level 2 dcl 1-9 set ref 122 149* 149 220* addr builtin function dcl 81 ref 150 args parameter varying char array dcl 21 ref 16 92 94 98 99 99 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 attach based varying char(189) level 2 dcl 50 set ref 125* 127* 127 128* 128 129* 129 130* 130 131* 131 132* 132 133* 133 134* 134 135* 135 136* 136 137* 137 138* 138 139* 139 140* 140 141* 141 142* 142 150 attach_data_ptr 16 based pointer level 2 dcl 1-9 set ref 151* 219 222* attach_descrip_ptr 14 based pointer level 2 dcl 1-9 set ref 121 150* 221* based_area based area(1024) dcl 48 ref 124 blk based structure level 1 dcl 50 set ref 124 255 blkptr 000100 automatic pointer dcl 28 set ref 124* 125 127 127 128 128 129 129 130 130 131 131 132 132 133 133 134 134 135 135 136 136 137 137 138 138 139 139 140 140 141 141 142 142 150 151 219* 255 c parameter fixed bin(35,0) dcl 260 set ref 258 263* 264 cleanup 000114 stack reference condition dcl 83 ref 146 216 close 36 based entry variable level 2 dcl 1-9 set ref 158* 160* 160 227* close_bit constant bit(36) initial packed unaligned dcl 64 ref 102 129 158 code 000102 automatic fixed bin(35,0) dcl 29 set ref 94* 95 95* 264* 268 com_err_ 000010 constant entry external dcl 39 ref 263 control 66 based entry variable level 2 dcl 1-9 set ref 176* 178* 178 233* control_bit constant bit(36) initial packed unaligned dcl 70 ref 108 135 176 delete_record 106 based entry variable level 2 dcl 1-9 set ref 188* 190* 190 237* delete_record_bit constant bit(36) initial packed unaligned dcl 74 ref 112 139 188 detach_iocb 26 based entry variable level 2 dcl 1-9 set ref 154* 225* error_table_$badopt 000032 external static fixed bin(35,0) dcl 59 set ref 116* error_table_$cyclic_syn 000024 external static fixed bin(35,0) dcl 56 set ref 122* error_table_$noarg 000030 external static fixed bin(35,0) dcl 58 set ref 92* error_table_$not_detached 000026 external static fixed bin(35,0) dcl 57 set ref 121* get_chars 46 based entry variable level 2 dcl 1-9 set ref 164* 166* 166 229* get_chars_bit constant bit(36) initial packed unaligned dcl 66 ref 104 131 164 get_line 42 based entry variable level 2 dcl 1-9 set ref 161* 163* 163 228* get_line_bit constant bit(36) initial packed unaligned dcl 65 ref 103 130 161 get_system_free_area_ 000012 constant entry external dcl 40 ref 124 hbound builtin function dcl 81 ref 92 98 hcs_$reset_ips_mask 000016 constant entry external dcl 42 ref 275 hcs_$set_ips_mask 000014 constant entry external dcl 41 ref 147 217 i 000103 automatic fixed bin(17,0) dcl 30 set ref 98* 99 99 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115* inhibit_sw 000104 automatic bit(1) packed unaligned dcl 31 set ref 97* 99* 100 inhibits 000105 automatic bit(36) packed unaligned dcl 32 set ref 97* 101* 101 102* 102 103* 103 104* 104 105* 105 106* 106 107* 107 108* 108 109* 109 110* 110 111* 111 112* 112 113* 113 114* 114 115* 115 126 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 155 158 161 164 167 170 173 176 179 182 185 188 191 194 197 201 iocb based structure level 1 dcl 1-9 ios_compatibility 142 based pointer level 2 dcl 1-9 set ref 200* 200 241* iox_$err_no_operation 000034 constant entry external dcl 60 ref 155 158 161 164 167 170 173 176 179 182 185 188 191 194 197 iox_$err_not_attached 000036 constant entry external dcl 61 ref 225 226 iox_$err_not_open 000040 constant entry external dcl 62 ref 227 228 229 230 231 232 233 234 235 236 237 238 239 240 iox_$find_iocb 000020 constant entry external dcl 43 ref 94 iox_$propagate 000022 constant entry external dcl 44 ref 205 252 loud_sw 000106 automatic bit(1) packed unaligned dcl 33 set ref 89* 263 loud_sw_param parameter bit(1) dcl 23 ref 16 89 mask 000107 automatic fixed bin(35,0) dcl 34 set ref 90* 145* 147* 215* 217* 275 275* 275* modes 56 based entry variable level 2 dcl 1-9 set ref 170* 172* 172 231* modes_bit constant bit(36) initial packed unaligned dcl 68 ref 106 133 170 name 1 based char(32) level 2 dcl 1-9 ref 125 null builtin function dcl 81 ref 121 221 222 223 224 241 251 open 32 based entry variable level 2 dcl 1-9 set ref 155* 157* 157 226* open_bit constant bit(36) initial packed unaligned dcl 63 ref 101 128 155 open_data_ptr 22 based pointer level 2 dcl 1-9 set ref 153* 153 224* open_descrip_ptr 20 based pointer level 2 dcl 1-9 set ref 152* 152 223* p1 parameter pointer dcl 22 set ref 16 121 122 149 150 151 152 153 154 155 157 158 160 161 163 164 166 167 169 170 172 173 175 176 178 179 181 182 184 185 187 188 190 191 193 194 196 197 199 200 201 202 203 204 205* 212 219 220 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 244 247 249 251 251 252* p2 000110 automatic pointer dcl 35 set ref 94* 122 125 149 152 153 157 160 163 166 169 172 175 178 181 184 187 190 193 196 199 200 202 203 204 p3 000112 automatic pointer dcl 35 set ref 243* 244 244 247* 247 247* 248 249 position 62 based entry variable level 2 dcl 1-9 set ref 173* 175* 175 232* position_bit constant bit(36) initial packed unaligned dcl 69 ref 107 134 173 put_chars 52 based entry variable level 2 dcl 1-9 set ref 167* 169* 169 230* put_chars_bit constant bit(36) initial packed unaligned dcl 67 ref 105 132 167 read_key 116 based entry variable level 2 dcl 1-9 set ref 194* 196* 196 239* read_key_bit constant bit(36) initial packed unaligned dcl 76 ref 114 141 194 read_length 122 based entry variable level 2 dcl 1-9 set ref 197* 199* 199 240* read_length_bit constant bit(36) initial packed unaligned dcl 77 ref 115 142 197 read_record 72 based entry variable level 2 dcl 1-9 set ref 179* 181* 181 234* read_record_bit constant bit(36) initial packed unaligned dcl 71 ref 109 136 179 rewrite_record 102 based entry variable level 2 dcl 1-9 set ref 185* 187* 187 236* rewrite_record_bit constant bit(36) initial packed unaligned dcl 73 ref 111 138 185 seek_key 112 based entry variable level 2 dcl 1-9 set ref 191* 193* 193 238* seek_key_bit constant bit(36) initial packed unaligned dcl 75 ref 113 140 191 syn_brother 150 based pointer level 2 dcl 1-9 set ref 203* 244 247 248 249* 249 251* syn_father 146 based pointer level 2 dcl 1-9 set ref 202* 243 251* syn_inhibits 144 based bit(36) level 2 dcl 1-9 set ref 201* 242* syn_son 152 based pointer level 2 dcl 1-9 set ref 203 204* 244 244* 247 write_record 76 based entry variable level 2 dcl 1-9 set ref 182* 184* 184 235* write_record_bit constant bit(36) initial packed unaligned dcl 72 ref 110 137 182 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. index builtin function dcl 81 iox_$iocb_version_sentinel external static char(4) dcl 1-64 NAMES DECLARED BY EXPLICIT CONTEXT. badopt 000517 constant label dcl 116 ref 100 cleaner 002052 constant entry internal dcl 273 ref 146 206 216 253 262 error 002015 constant entry internal dcl 258 ref 92 95 116 121 122 return 002012 constant label dcl 268 ref 265 syn_$syn_attach 000154 constant entry external dcl 16 syn_detach 001570 constant entry external dcl 212 ref 154 NAME DECLARED BY CONTEXT OR IMPLICATION. rtrim builtin function ref 125 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2324 2366 2100 2334 Length 2602 2100 42 177 223 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME syn_$syn_attach 130 external procedure is an external procedure. on unit on line 146 64 on unit on unit on line 216 64 on unit error internal procedure shares stack frame of external procedure syn_$syn_attach. cleaner 70 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME syn_$syn_attach 000100 blkptr syn_$syn_attach 000102 code syn_$syn_attach 000103 i syn_$syn_attach 000104 inhibit_sw syn_$syn_attach 000105 inhibits syn_$syn_attach 000106 loud_sw syn_$syn_attach 000107 mask syn_$syn_attach 000110 p2 syn_$syn_attach 000112 p3 syn_$syn_attach THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp call_ext_out_desc call_ext_out call_int_this call_int_other return_mac enable_op shorten_stack ext_entry ext_entry_desc int_entry op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ get_system_free_area_ hcs_$reset_ips_mask hcs_$set_ips_mask iox_$err_no_operation iox_$err_not_attached iox_$err_not_open iox_$find_iocb iox_$propagate THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$badopt error_table_$cyclic_syn error_table_$noarg error_table_$not_detached LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 16 000147 89 000172 90 000175 92 000176 94 000210 95 000254 97 000261 98 000263 99 000275 100 000325 101 000327 102 000337 103 000347 104 000357 105 000367 106 000377 107 000407 108 000417 109 000427 110 000437 111 000447 112 000457 113 000467 114 000477 115 000507 116 000517 119 000526 121 000530 122 000546 124 000563 125 000577 126 000633 127 000636 128 000650 129 000664 130 000700 131 000714 132 000730 133 000744 134 000760 135 000774 136 001010 137 001024 138 001040 139 001054 140 001070 141 001104 142 001120 145 001134 146 001135 147 001157 149 001171 150 001177 151 001203 152 001207 153 001214 154 001220 155 001226 157 001237 158 001243 160 001254 161 001260 163 001271 164 001275 166 001306 167 001312 169 001323 170 001327 172 001340 173 001344 175 001355 176 001361 178 001372 179 001376 181 001407 182 001413 184 001424 185 001430 187 001441 188 001445 190 001456 191 001462 193 001473 194 001477 196 001510 197 001514 199 001525 200 001531 201 001533 202 001537 203 001540 204 001544 205 001547 206 001556 207 001562 208 001563 212 001564 215 001600 216 001601 217 001623 219 001635 220 001642 221 001643 222 001647 223 001652 224 001655 225 001660 226 001667 227 001671 228 001674 229 001676 230 001700 231 001702 232 001704 233 001706 234 001710 235 001712 236 001714 237 001716 238 001720 239 001722 240 001724 241 001726 242 001730 243 001733 244 001735 247 001744 248 001754 249 001757 251 001763 252 001773 253 002002 254 002006 255 002007 256 002011 268 002012 270 002014 258 002015 262 002017 263 002023 264 002045 265 002050 273 002051 275 002057 276 002071 ----------------------------------------------------------- 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