COMPILATION LISTING OF SEGMENT abs_io_put_chars Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 08/11/87 0925.5 mst Tue Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 4* * * 5* *********************************************************** */ 6 7 8 /* format: style3,idind30,ll122,ifthenstmt */ 9 10 abs_io_put_chars: 11 procedure (P_iocb_ptr, P_buffer_ptr, P_buffer_len, P_status); 12 13 /* Initial coding: 25 June 1979 by J. Spencer Love as specified in MCR 3958 */ 14 /* Changed to always set absout bc unless "ear -no_set_bit_count" 07/29/81 S. Herbst */ 15 /* Fixed bug setting bit count one line early 03/19/82 S. Herbst */ 16 /* Recompiled for changed abs_data structure 04/12/83 S. Herbst */ 17 /* Changed to turn on absout safety switch while running 05/16/83 S. Herbst */ 18 /* Changed to create absouts through links 11/14/84 Steve Herbst */ 19 20 21 /* Parameters */ 22 23 declare P_iocb_ptr ptr parameter, 24 P_buffer_ptr ptr parameter, 25 P_buffer_len fixed bin (21) parameter, 26 P_attach_data_ptr ptr parameter, 27 P_dir_name char (*) parameter, 28 P_entry_name char (*) parameter, 29 P_truncate bit (1) aligned parameter, 30 P_MSF bit (1) aligned parameter, 31 P_status fixed bin (35) parameter; 32 33 /* Builtins */ 34 35 declare (addr, binary, divide, length, max, min, mod, null, rtrim, substr) 36 builtin; 37 38 declare any_other condition; 39 40 /* Automatic */ 41 42 declare buffer_len fixed bin (21), 43 buffer_ptr ptr, 44 create_dir_name char (168), 45 create_entry_name char (32), 46 iocb_ptr ptr, 47 mask bit (36), 48 pad_len fixed bin (21), 49 rest_of_buffer_len fixed bin (21), 50 safety_switch bit (1) aligned, 51 seg_max_len fixed bin (19), 52 status fixed bin (35); 53 54 declare 1 branch aligned like status_branch; 55 56 /* Based */ 57 58 declare buffer char (buffer_len) based (buffer_ptr), 59 output_seg char (output_file.max_len) based (output_file.seg_ptr); 60 61 /* Static */ 62 63 declare max_buffer_size fixed bin (21) static; 64 65 declare 1 file_is_full aligned static, 66 2 version fixed bin initial (0), 67 2 status_code fixed bin (35); 68 69 declare 1 unable_to_do_io aligned static like file_is_full; 70 71 /* Constants */ 72 73 declare NULL char (1) aligned static options (constant) initial (""); 74 75 /* External Constants */ 76 77 declare error_table_$buffer_big fixed bin (35) external, 78 error_table_$dirseg fixed bin (35) external, 79 error_table_$file_is_full fixed bin (35) external, 80 error_table_$moderr fixed bin (35) external, 81 error_table_$no_s_permission fixed bin (35) external, 82 error_table_$unable_to_do_io fixed bin (35) external, 83 sys_info$max_seg_size fixed bin (35) external; 84 85 /* Entries */ 86 87 declare continue_to_signal_ entry (fixed bin (35)), 88 hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), fixed bin (35)), 89 hcs_$get_link_target entry (char (*), char (*), char (*), char (*), fixed bin (35)), 90 hcs_$get_max_length_seg entry (ptr, fixed bin (19), fixed bin (35)), 91 hcs_$get_safety_sw_seg entry (ptr, bit (1) aligned, fixed bin (35)), 92 hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)), 93 hcs_$reset_ips_mask entry (bit (36), bit (36)), 94 hcs_$set_bc_seg entry (ptr, fixed bin (24), fixed bin (35)), 95 hcs_$set_ips_mask entry (bit (36), bit (36)), 96 hcs_$set_safety_sw_seg entry (ptr, bit (1) aligned, fixed bin (35)), 97 hcs_$status_long entry (char (*), char (*), fixed bin (1), ptr, ptr, fixed bin (35)), 98 hcs_$terminate_noname entry (ptr, fixed bin (35)), 99 hcs_$truncate_seg entry (ptr, fixed bin, fixed bin (35)), 100 msf_manager_$open entry (char (*), char (*), ptr, fixed bin (35)), 101 msf_manager_$get_ptr entry (pointer, fixed bin, bit (1) aligned, pointer, fixed bin (24), 102 fixed bin (35)), 103 msf_manager_$adjust entry (ptr, fixed bin, fixed bin (24), bit (3), fixed bin (35)), 104 msf_manager_$close entry (pointer), 105 terminate_process_ entry (char (*), ptr); 106 107 /* abs_io_put_chars: procedure (P_iocb_ptr, P_buffer_ptr, P_buffer_len, P_status); */ 108 109 iocb_ptr = P_iocb_ptr -> iocb.actual_iocb_ptr; /* get our IOCB, so we can get attach data block. */ 110 abs_data_ptr = iocb_ptr -> iocb.attach_data_ptr; 111 112 buffer_ptr = P_buffer_ptr; /* copy parameters so we can play with them */ 113 buffer_len = P_buffer_len; 114 115 if buffer_len < 0 | buffer_len > max_buffer_size 116 then do; /* Punt if given invalid buffer size. */ 117 P_status = error_table_$buffer_big; 118 return; 119 end; 120 121 mask = ""b; /* zero mask if we need to switch output segments */ 122 123 /* The following block ensures that no more data will ever get written into a component than will fit. The block will 124* not be executed if the output segment is exactly filled, or if P_buffer_len is zero. It will only be executed if 125* another output component is required. Note that the max_length of the output segment(s) is picked up at open time; 126* if it is decreased we will take a fault before this code will be executed, and if it is increased, we will never 127* take advantage of the additional space. */ 128 129 do while (buffer_len + output_file.current_len > output_file.max_len); 130 pad_len = output_file.max_len - output_file.current_len; 131 rest_of_buffer_len = buffer_len - pad_len; /* PL/I compiler doesn't notice common subexpression */ 132 buffer_len = pad_len; 133 call write (); /* write as much as will fit in current component */ 134 buffer_ptr = addr (substr (buffer, buffer_len + 1)); 135 buffer_len = rest_of_buffer_len; 136 call get_next_MSF_component (); /* get next MSF component if possible */ 137 end; 138 139 call write (); 140 141 P_status = 0; 142 143 return; 144 145 /* This entrypoint is called by abs_io_open if the opening mode is stream_input_output. It opens the specified output 146* file. It is called with the IPS mask set to zero to prevent interruption. An any_other handler in abs_io_open will 147* terminate the process if anything goes wrong. If the file is already an MSF, it is opened using msf_manager_, 148* otherwise it is opened with a call to hcs_$make_seg, which creates it if it does not exist. The first call is to 149* hcs_$status_long because the current length and effective mode are needed, otherwise it would have to make an 150* additional call. In the MSF case, this call is not necessary and will have to be repeated on an MSF component, but 151* it isn't known that hcs_$status_minf would suffice until too late. */ 152 153 open: 154 entry (P_attach_data_ptr, P_dir_name, P_entry_name, P_truncate, P_MSF, P_status); 155 156 abs_data_ptr = P_attach_data_ptr; 157 158 output_file.seg_ptr, output_file.fcb_ptr = null (); 159 output_file.may_be_MSF = P_MSF; 160 161 call hcs_$status_long (P_dir_name, P_entry_name, 1, addr (branch), null (), status); 162 163 if branch.type = Link & (status = 0 | status = error_table_$no_s_permission) then do; 164 /* chase link with nonexistent target */ 165 call hcs_$get_link_target (P_dir_name, P_entry_name, create_dir_name, create_entry_name, status); 166 if create_dir_name = "" then do; 167 P_status = status; 168 return; 169 end; 170 end; 171 else do; 172 create_dir_name = P_dir_name; 173 create_entry_name = P_entry_name; 174 end; 175 176 if (status ^= 0 & status ^= error_table_$no_s_permission) | (branch.type ^= Segment & branch.type ^= Directory) 177 then do; /* File does not exist. We will try to create it. */ 178 branch.type = Segment; 179 branch.mode = "01010"b; /* rw access for check later */ 180 branch.bit_count, branch.current_length = 0; 181 end; 182 else if branch.type = Directory & branch.bit_count = 0 183 then do; /* File is a directory. Punt. */ 184 P_status = error_table_$dirseg; 185 return; 186 end; 187 188 if branch.type = Segment 189 then call open_segment (); 190 else call open_MSF (); 191 192 file_is_full.status_code = error_table_$file_is_full; 193 unable_to_do_io.status_code = error_table_$unable_to_do_io; 194 195 P_status = 0; 196 197 return; 198 199 PUNT: /* Target for non-local goto's */ 200 P_status = status; /* Error occured during open or close. */ 201 return; 202 203 /* The following entrypoint is called by abs_io_close when output_file.seg_ptr ^= null (). It is called with the IPS 204* mask set to zero; an any_other handler in abs_io_close will terminate the process if anything goes wrong. */ 205 206 close: 207 entry (P_attach_data_ptr, P_status); 208 209 abs_data_ptr = P_attach_data_ptr; 210 211 if output_file.turn_off_ssw then call hcs_$set_safety_sw_seg (output_file.seg_ptr, "0"b, (0)); 212 213 pad_len = mod (-output_file.current_len, 4096); 214 if pad_len ^= 0 215 then do; 216 call hcs_$set_bc_seg (output_file.seg_ptr, 9 * output_file.current_len, status); 217 if status ^= 0 then go to PUNT; /* Something very badly wrong. Punt immediately. */ 218 end; 219 220 if output_file.fcb_ptr = null () 221 then do; /* File was SSF. */ 222 call hcs_$terminate_noname (output_file.seg_ptr, (0)); 223 output_file.seg_ptr = null (); /* TEMP: can go away when terminate_noname is fixed */ 224 end; 225 else do; /* File was opened as MSF. */ 226 output_file.seg_ptr = null (); /* msf_manager_ will terminate this. */ 227 call msf_manager_$close (output_file.fcb_ptr); 228 end; 229 230 P_status = 0; 231 return; 232 233 /* The following procedure is used by abs_io_put_chars to actually transfer data into the current output segment. If a 234* new page is touched, the bit count of the segment is set to the end of the page. Thus, data is never present beyond 235* the end of file indicated by the bit count. The call to set the bit count MUST precede the code which does the 236* actual transfer of output, so that data will never be lost. It is the reponsibility of the caller to determine that 237* the data in buffer will fit in the output segment. */ 238 239 write: 240 procedure (); 241 242 substr (output_seg, output_file.current_len + 1, buffer_len) = buffer; 243 output_file.current_len = output_file.current_len + buffer_len; 244 245 if ^abs_data.open_data.no_set_bc then do; 246 call hcs_$set_bc_seg (output_file.seg_ptr, 9 * output_file.current_len, status); 247 if status ^= 0 then go to PUNT; 248 end; 249 250 return; 251 end write; 252 253 /* The following procedure is called when the segment which abs_io_put_chars is currently using is filled. If the file 254* was opened as a single segment file, it is terminated and reopened as a multi-segment file. If -single_segment_file 255* (-ssf) was specified at attach time, the process is terminated instead with error_table_$file_is_full as the reason. 256* If anything goes wrong while we are switching output segments, there is nowhere for output to go from error 257* handlers, so we terminate the process with the reason error_table_$unable_to_do_io. The output file may have been 258* opened as an MSF and then truncated. In this case, it is still open as an MSF and msf_manager_ will automatically 259* convert it back to an MSF. This is done because we can't depend on the MSF becoming an SSF when truncated since it 260* might be upgraded. The whole operation is done with an IPS mask of zero so nothing can interrupt us. */ 261 262 get_next_MSF_component: 263 procedure (); 264 265 declare dir_name char (168), 266 entry_name char (32); 267 268 on any_other 269 begin; 270 if substr (mask, 36, 1) 271 then call terminate_process_ ("fatal_error", addr (unable_to_do_io)); 272 else call continue_to_signal_ ((0)); 273 end; 274 275 call hcs_$set_ips_mask (mask, mask); 276 277 if output_file.fcb_ptr = null () 278 then do; /* Convert from SSF to MSF */ 279 if ^output_file.may_be_MSF then call terminate_process_ ("fatal_error", addr (file_is_full)); 280 call hcs_$fs_get_path_name (output_file.seg_ptr, dir_name, (0), entry_name, status); 281 if status ^= 0 then go to PUNT_MASKED; 282 283 if output_file.turn_off_ssw then do; 284 call hcs_$set_safety_sw_seg (output_file.seg_ptr, "0"b, (0)); 285 output_file.turn_off_ssw = "0"b; 286 end; 287 288 call hcs_$terminate_noname (output_file.seg_ptr, (0)); 289 call msf_manager_$open (dir_name, entry_name, output_file.fcb_ptr, status); 290 if status ^= 0 then go to PUNT_MASKED; 291 output_file.MSF_seg_idx = 1; 292 end; 293 else output_file.MSF_seg_idx = output_file.MSF_seg_idx + 1; 294 295 call msf_manager_$get_ptr (output_file.fcb_ptr, output_file.MSF_seg_idx, "1"b, output_file.seg_ptr, (0), status) 296 ; 297 if status ^= 0 then go to PUNT_MASKED; 298 299 output_file.current_len = 0; /* start over at base of new component */ 300 301 call hcs_$reset_ips_mask (mask, mask); 302 return; 303 304 PUNT_MASKED: 305 call terminate_process_ ("fatal_error", addr (unable_to_do_io)); 306 307 end get_next_MSF_component; 308 309 /* This entrypoint is called by abs_io_put_chars$open to open an output file which is a segment, which includes the 310* case where the output file does not exist. It checks that rw access is available, makes it known, gets the max 311* length and adjusts the length as specified. The other entrypoint, open_MSF, is described below. The two 312* entrypoints are merged to reduce the number of non-quick internal procedure calls, and are declared options 313* (non-quick) to keep the stack frame small for calls to abs_io_put_chars */ 314 315 open_segment: 316 procedure () options (non_quick); 317 318 if (branch.mode & "01010"b) ^= "01010"b 319 then do; /* We must have rw access on the file */ 320 status = error_table_$moderr; 321 go to PUNT; 322 end; 323 324 call hcs_$make_seg (create_dir_name, create_entry_name, "", 1010b, output_file.seg_ptr, status); 325 if output_file.seg_ptr = null () then go to PUNT; /* We couldn't create the file. Punt. */ 326 327 call get_max_len (); /* Needed by abs_io_put_chars and adjust_length */ 328 329 if P_truncate 330 then do; 331 if branch.current_length ^= 0 332 then do; 333 call hcs_$truncate_seg (output_file.seg_ptr, 0, status); 334 if status ^= 0 then go to PUNT; 335 end; 336 if branch.bit_count ^= 0 337 then do; 338 call hcs_$set_bc_seg (output_file.seg_ptr, 0, status); 339 if status ^= 0 then go to PUNT; 340 end; 341 end; 342 else call adjust_length (); 343 344 call hcs_$get_safety_sw_seg (output_file.seg_ptr, safety_switch, status); 345 if status = 0 & ^safety_switch then do; 346 output_file.turn_off_ssw = "1"b; 347 call hcs_$set_safety_sw_seg (output_file.seg_ptr, "1"b, status); 348 end; 349 350 return; 351 352 /* The following entrypoint is called by abs_io_put_chars$open to open an MSF for output. There are two separate 353* tracks which are followed depending on whether truncation is required. In the non-truncation case, the length of 354* the last component is adjusted by the same procedure used for SSF's. This necessitates another call to 355* hcs_$status_long to acertain the effective mode and the current length of the component. The index of the last 356* component is one less than the bit count of the MSF directory. In the truncation case, the length of the file is 357* adjusted by a call to msf_manager_$adjust; it is assumed that rw access is present on the MSF if this call succeeds. 358* The current length and last component index are known to be zero. */ 359 360 open_MSF: 361 entry (); 362 363 declare dir_name char (168), 364 entry_name char (32); 365 366 call msf_manager_$open (P_dir_name, P_entry_name, output_file.fcb_ptr, status); 367 if status ^= 0 then go to PUNT; 368 369 if P_truncate 370 then do; 371 call msf_manager_$adjust (output_file.fcb_ptr, 0, 0, "110"b, status); 372 if status ^= 0 then go to PUNT; 373 call msf_manager_$get_ptr (output_file.fcb_ptr, 0, "1"b, output_file.seg_ptr, (0), status); 374 if status ^= 0 then go to PUNT; 375 call get_max_len (); 376 output_file.MSF_seg_idx, output_file.current_len = 0; 377 end; 378 else do; 379 output_file.MSF_seg_idx = branch.bit_count - 1; 380 call msf_manager_$get_ptr (output_file.fcb_ptr, output_file.MSF_seg_idx, "1"b, output_file.seg_ptr, 381 (0), status); 382 if status ^= 0 then go to PUNT; 383 call hcs_$fs_get_path_name (output_file.seg_ptr, dir_name, (0), entry_name, (0)); 384 call hcs_$status_long (dir_name, entry_name, 1, addr (branch), null (), (0)); 385 if (branch.mode & "01010"b) ^= "01010"b 386 then do; 387 status = error_table_$moderr; 388 go to PUNT; 389 end; 390 call get_max_len (); 391 call adjust_length (); 392 end; 393 394 return; 395 end open_segment; 396 397 /* This procedure is called by open_segment and open_MSF to initialize output_file.max_len, which is needed by 398* abs_io_put_chars and adjust_len, and max_buffer_size, which is needed by abs_io_put_chars. If the maximum length of 399* the output component is zero, the file cannot be opened. */ 400 401 get_max_len: 402 procedure (); 403 404 call hcs_$get_max_length_seg (output_file.seg_ptr, seg_max_len, status); 405 if status ^= 0 then go to PUNT; 406 if seg_max_len <= 0 407 then do; 408 status = error_table_$file_is_full; 409 go to PUNT; 410 end; 411 output_file.max_len = 4 * seg_max_len; 412 max_buffer_size = 4 * sys_info$max_seg_size; 413 414 return; 415 416 end get_max_len; 417 418 /* The following procedure is called by abs_io_put_chars$open to position the logical length of the file just beyond 419* the end of valid data. All entrypoints in this external block cooperate to ensure that data can never be lost. 420* get_max_len must be called before this procedure is called. */ 421 422 adjust_length: 423 procedure (); 424 425 declare bc fixed bin (24); 426 427 output_file.current_len = length (rtrim (substr (output_seg, 1, 4096 * binary (branch.current_length)), NULL)); 428 pad_len = min (output_file.max_len, divide (max (0, branch.bit_count), 9, 21, 0)); 429 430 if mod (output_file.current_len, 4096) = 0 431 then output_file.current_len = max (output_file.current_len, pad_len); 432 else output_file.current_len = max (output_file.current_len, pad_len - 4095); 433 434 bc = 9 * (output_file.current_len + pad_len); 435 if bc ^= branch.bit_count 436 then do; 437 call hcs_$set_bc_seg (output_file.seg_ptr, bc, status); 438 if status ^= 0 then go to PUNT; 439 end; 440 441 return; 442 443 end adjust_length; 444 1 1 /* START OF: abs_io_data.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 1 2 1 3 1 4 /****^ HISTORY COMMENTS: 1 5* 1) change(87-02-20,Parisek), approve(87-07-23,MCR7716), 1 6* audit(87-07-30,Fawcett), install(87-08-11,MR12.1-1080): 1 7* Added the noabort flag for determining whether or not to abort after 1 8* exec_com error occurs. 1 9* END HISTORY COMMENTS */ 1 10 1 11 1 12 /* Initial coding: 25 June 79 by J. Spencer Love */ 1 13 /* login_channel option flag BIM 11/81 */ 1 14 /* Added this_action and next_action 04/20/82 S. Herbst */ 1 15 /* Added on_info, goto_statement_(pos len) 01/06/83 S. Herbst */ 1 16 /* Added output_file.turn_off_ssw 05/16/83 S. Herbst */ 1 17 /* Added attach.trim_whitespace_sw 06/02/83 S. Herbst */ 1 18 /* Added listener_pl1_label and get_line_pl1_label 11/17/83 S. Herbst */ 1 19 /* Added (command comment control input)_line.by_control_arg 03/20/84 S. Herbst */ 1 20 1 21 declare abs_data_ptr ptr; 1 22 1 23 declare 1 abs_data aligned based (abs_data_ptr), 1 24 2 version fixed bin, /* Version = 1 */ 1 25 2 io_module_name char (32) varying, /* either "abs_io_" or "ec_input_" */ 1 26 2 open_description char (24) varying, /* either "stream_input" or "stream_input_output" */ 1 27 2 unique_name char (15) varying, /* &! -- either blank or 15 char unique string */ 1 28 /* */ 1 29 2 ec_data_ptr ptr, /* -> communication area for exec_com */ 1 30 2 expand_data_ptr ptr, /* -> structure for abs_io_expand_ */ 1 31 /* */ 1 32 2 instance_chain, /* two way linked chain of abs_data blocks for debugging */ 1 33 3 prev_ptr ptr, /* -> next older abs_data instance */ 1 34 3 next_ptr ptr, /* -> next newer abs_data instance */ 1 35 3 level fixed bin, /* level of ec invocation in chain for debugging */ 1 36 3 pad bit (36), /* */ 1 37 /* */ 1 38 2 arg_info, /* */ 1 39 3 ec_path_ptr ptr, /* Ptr to allocated &ec_path string */ 1 40 3 ec_path_len fixed bin (21), /* Length of allocated &ec_path (&0) string */ 1 41 3 ec_path_quotes fixed bin (21), /* Number of quote chars in &ec_path, -1 if not yet counted */ 1 42 3 ec_name_ptr ptr, /* Ptr to allocated &ec_name string */ 1 43 3 ec_name_len fixed bin (21), /* Length of allocated &ec_name string */ 1 44 3 ec_name_quotes fixed bin (21), /* Number of quote chars in &ec_name, -1 if not yet counted */ 1 45 3 arg_ptr ptr, /* pointer to allocated structure containing args */ 1 46 3 arg_count fixed bin, /* number of arguments passed */ 1 47 3 args_copied bit (1), /* 1 indicates arguments were copied into work_area */ 1 48 3 default_arg_ptr ptr, /* pointer to allocated &default args */ 1 49 3 default_arg_count fixed bin, /* number of &default args */ 1 50 3 pad bit (36), /* */ 1 51 /* */ 1 52 2 input_string, /* data about input segment or archive component */ 1 53 3 ptr ptr, /* pointer to input file */ 1 54 3 len fixed bin (21), /* number of characters in input file */ 1 55 3 start fixed bin (21), /* initial value for input_pos, set beyond &version, if any */ 1 56 3 position fixed bin (21), /* current index into input file */ 1 57 3 limit fixed bin (21), /* farthest point yet reached...begin &label search here */ 1 58 /* */ 1 59 2 open_data, /* data saved at attach time for open time */ 1 60 3 output_dir char (168) unal, /* directory pathname of output file (if specified) */ 1 61 3 output_entry char (32) unal, /* entryname of output file (if specified) */ 1 62 3 parser_version fixed bin, /* indicates version of parser (get_line) for open */ 1 63 3 si bit (1) unal, /* 1 indicates opening for stream_input permitted */ 1 64 3 sio bit (1) unal, /* 1 indicates opening for stream_input_output permitted */ 1 65 3 ssf bit (1) unal, /* 1 indicates output file cannot be MSF */ 1 66 3 truncate bit (1) unal, /* 1 indicates output file truncated at open */ 1 67 3 no_set_bc bit (1) unal, /* 1 to set absout bitcount only at close */ 1 68 3 login_channel bit (1) unal, /* 1 to fish arguments from PIT */ 1 69 3 pad bit (30) unal, /* */ 1 70 /* */ 1 71 2 output_file, /* data for abs_io_put_chars */ 1 72 3 fcb_ptr ptr, /* -> File Control Block for msf_manager_, null if SSF */ 1 73 3 seg_ptr ptr, /* -> base of current component of output file */ 1 74 3 current_len fixed bin (21), /* number of characters in current component */ 1 75 3 max_len fixed bin (21), /* max number of characters in a component */ 1 76 3 MSF_seg_idx fixed bin, /* index of current MSF component. Used to get new ones */ 1 77 3 switches aligned, 1 78 4 may_be_MSF bit (1) unaligned, /* 1 indicates absout can become an MSF */ 1 79 4 turn_off_ssw bit (1) unaligned, /* 1 means safety switch of absout was off originally */ 1 80 4 mbz bit (34) unaligned, 1 81 /* */ 1 82 2 command_line, /* substructure dealing with tracing command lines */ 1 83 3 by_control_arg bit (1) unaligned, /* 1 if trace modes specified by ec control arg */ 1 84 3 on bit (1) unaligned, /* 1 to print tracing information */ 1 85 3 expand fixed bin (3) unal, /* 1 to print unexpanded, 2 expanded, 3 all, 4 both */ 1 86 3 pad1 bit (66) unaligned, /* pad to double word */ 1 87 3 iocb ptr, /* I/O switch to put trace out on */ 1 88 3 prefix char (32) varying, /* prefix for &trace tracing, eg. "COMMAND: " */ 1 89 3 pad2 bit (36), /* */ 1 90 2 (comment_line, /* for tracing comments..always unexpanded */ 1 91 control_line, /* for tracing control lines */ 1 92 input_line) /* for tracing input lines in &attach mode */ 1 93 like abs_data.command_line, 1 94 /* */ 1 95 2 attach, /* */ 1 96 3 victim_ptr ptr, /* -> IOCB affected by &attach (usually iox_$user_input */ 1 97 3 target_ptr ptr, /* -> IOCB &attached to (created by exec_com command) */ 1 98 3 save_ptr ptr, /* -> IOCB used to save previous victim_ptr -> IOCB */ 1 99 3 switches, 1 100 4 trim_whitespace_sw bit (1) unaligned, /* OFF for &attach &trim off, ON by default */ 1 101 4 noabort bit (1) unaligned, /* ON if continue after severity 1 error */ 1 102 4 pad bit (34) unaligned, 1 103 /* */ 1 104 2 allocated_chars_ptr ptr, /* -> allocated buffer for freeing */ 1 105 2 chars_ptr ptr, /* -> characters in buffer waiting to be returned */ 1 106 2 else_clause_ptr ptr, /* -> characters in deferred else clause */ 1 107 2 allocated_chars_len fixed bin (21), /* total length of allocated buffer */ 1 108 2 chars_len fixed bin (21), /* characters left in buffer to be returned */ 1 109 2 else_clause_len fixed bin (21), /* length of deferred else clause */ 1 110 /* */ 1 111 2 absentee bit (1), /* 1 indicates logout on &quit */ 1 112 2 quit bit (1), /* 1 indicates orderly exit, quit or return */ 1 113 /* */ 1 114 2 active bit (1), /* 1 indicates get_line is busy, for recursion check */ 1 115 2 eof bit (1), /* 1 indicates &quit found or no more input */ 1 116 2 last_input_line_sw bit (1), /* previous line returned was an input line */ 1 117 2 label_search_sw bit (1), /* ON when searching for target of &goto */ 1 118 2 nest_level fixed bin, /* V1: depth of &if-&then-&else nesting */ 1 119 2 expected_nest_level fixed bin, /* V1: depth that must be reached to resume execution */ 1 120 /* */ 1 121 2 goto_statement_pos fixed bin (21), /* position of last &goto stmt, for error msgs */ 1 122 2 goto_statement_len fixed bin (21), /* length of the &goto stmt */ 1 123 1 124 2 if_info aligned, /* &if-&then-&else nesting info */ 1 125 3 if_sw bit (1), /* ON if inside an &if-&then-&else construct */ 1 126 3 true_sw bit (1), /* ON after "&if true" */ 1 127 3 got_then_sw bit (1), /* ON after the &then has been seen */ 1 128 3 got_else_sw bit (1), /* ON after the &else has been seen */ 1 129 3 clause_type fixed bin, /* previous &then or &else */ 1 130 3 skip_sw bit (1), /* ON if skipping a &then or &else clause */ 1 131 3 skip_block_level fixed bin, /* how many levels of &do we are inside while skipping */ 1 132 3 prev_if_ptr ptr, /* ptr to if_info (saved) of &if we are nested inside */ 1 133 3 this_action fixed bin, /* copy of expand_data.this_statement.action */ 1 134 3 next_action fixed bin, /* copy of expand_data.next_statement.action */ 1 135 1 136 2 on_info aligned, /* info pertaining to &on units in the ec */ 1 137 3 cleanup_handler_ptr ptr, /* -> node for cleanup handler if any */ 1 138 3 first_handler_ptr ptr, /* -> top of chain of nodes for other handlers */ 1 139 3 switches aligned, 1 140 4 was_attached_sw bit (1) unal, /* 1 indicates parent ec was &attach'ed */ 1 141 4 in_handler_sw bit (1) unal, /* 1 indicates we are now executing some handler text */ 1 142 4 exit_sw bit (1) unal, /* 1 indicates ready to exit the handler via &exit or &goto */ 1 143 4 goto_sw bit (1) unal, /* 1 means this exit is accomplished by a nonlocal &goto */ 1 144 4 continue_to_signal_sw bit (1) unal, /* 1 means &continue_to_signal was executed */ 1 145 4 pad bit (31) unal, 1 146 3 handler_node_ptr ptr, /* -> parent's handler_node for this condition */ 1 147 3 parent_abs_data_ptr ptr, /* -> abs_data structure of parent ec */ 1 148 3 condition_info aligned, /* selected condition info if in_handler_sw is ON */ 1 149 4 condition_name char (32), /* name of condition signalled */ 1 150 4 mc_ptr ptr, /* machine conditions ptr for signal_ */ 1 151 4 info_ptr ptr, /* ptr to specific condition info, for signal_ */ 1 152 4 wc_ptr ptr, /* machine conditions for lower ring fault, for signal_ */ 1 153 3 goto_label_ptr ptr, /* -> &goto label if goto_sw is on */ 1 154 3 goto_label_len fixed bin (21), /* length of the &goto label */ 1 155 3 listener_pl1_label label variable, /* for nonlocal goto to parent ec's listener's stack frame */ 1 156 3 get_line_pl1_label label variable, /* for nonlocal goto to parent ec's get_line's stack frame */ 1 157 /* */ 1 158 2 saved_state_ptr ptr, /* -> top of parser stack */ 1 159 2 current_lex_block_ptr ptr, /* -> lex_block for current block position */ 1 160 2 current_proc_block_ptr ptr, /* -> proc block for current procedure */ 1 161 2 last_block_ptr ptr, /* -> last lex or proc block that has been allocated */ 1 162 2 current_loop_ptr ptr, /* -> loop_block for current active loop */ 1 163 2 last_loop_ptr ptr, /* -> last loop block that has been allocated */ 1 164 /* */ 1 165 2 labels_ptr ptr, /* hash table ptr for label hash table */ 1 166 2 first_xlabel_ptr ptr, /* first expandable label */ 1 167 2 last_xlabel_ptr ptr, /* last expandable label */ 1 168 2 variables_ptr ptr, /* hash table ptr for variable hash table */ 1 169 /* */ 1 170 2 timed_input bit (1), /* 1 indicates input requests may be delayed */ 1 171 2 low_sleep_time fixed bin (35), /* low sleep time for timed input */ 1 172 2 sleep_time_range fixed bin (35), /* high sleep time for timed input */ 1 173 2 seed fixed bin (35), /* seed for timed input random numbers */ 1 174 /* */ 1 175 2 work_area area (800); /* extensible area for args, etc. */ 1 176 1 177 declare abs_data_version_1 fixed bin static options (constant) initial (1), 1 178 Work_area_size fixed bin static options (constant) initial (800); 1 179 1 180 dcl (UNEXPANDED init (1), EXPANDED init (2), ALL init (3), BOTH init (4)) 1 181 fixed bin int static options (constant); 1 182 1 183 /* END OF: abs_io_data.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 445 446 2 1 /* BEGIN INCLUDE FILE ..... iocb.incl.pl1 ..... 13 Feb 1975, M. Asherman */ 2 2 /* Modified 11/29/82 by S. Krupp to add new entries and to change 2 3* version number to IOX2. */ 2 4 /* format: style2 */ 2 5 2 6 dcl 1 iocb aligned based, /* I/O control block. */ 2 7 2 version character (4) aligned, /* IOX2 */ 2 8 2 name char (32), /* I/O name of this block. */ 2 9 2 actual_iocb_ptr ptr, /* IOCB ultimately SYNed to. */ 2 10 2 attach_descrip_ptr ptr, /* Ptr to printable attach description. */ 2 11 2 attach_data_ptr ptr, /* Ptr to attach data structure. */ 2 12 2 open_descrip_ptr ptr, /* Ptr to printable open description. */ 2 13 2 open_data_ptr ptr, /* Ptr to open data structure (old SDB). */ 2 14 2 reserved bit (72), /* Reserved for future use. */ 2 15 2 detach_iocb entry (ptr, fixed (35)),/* detach_iocb(p,s) */ 2 16 2 open entry (ptr, fixed, bit (1) aligned, fixed (35)), 2 17 /* open(p,mode,not_used,s) */ 2 18 2 close entry (ptr, fixed (35)),/* close(p,s) */ 2 19 2 get_line entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 2 20 /* get_line(p,bufptr,buflen,actlen,s) */ 2 21 2 get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 2 22 /* get_chars(p,bufptr,buflen,actlen,s) */ 2 23 2 put_chars entry (ptr, ptr, fixed (21), fixed (35)), 2 24 /* put_chars(p,bufptr,buflen,s) */ 2 25 2 modes entry (ptr, char (*), char (*), fixed (35)), 2 26 /* modes(p,newmode,oldmode,s) */ 2 27 2 position entry (ptr, fixed, fixed (21), fixed (35)), 2 28 /* position(p,u1,u2,s) */ 2 29 2 control entry (ptr, char (*), ptr, fixed (35)), 2 30 /* control(p,order,infptr,s) */ 2 31 2 read_record entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 2 32 /* read_record(p,bufptr,buflen,actlen,s) */ 2 33 2 write_record entry (ptr, ptr, fixed (21), fixed (35)), 2 34 /* write_record(p,bufptr,buflen,s) */ 2 35 2 rewrite_record entry (ptr, ptr, fixed (21), fixed (35)), 2 36 /* rewrite_record(p,bufptr,buflen,s) */ 2 37 2 delete_record entry (ptr, fixed (35)),/* delete_record(p,s) */ 2 38 2 seek_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 2 39 /* seek_key(p,key,len,s) */ 2 40 2 read_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 2 41 /* read_key(p,key,len,s) */ 2 42 2 read_length entry (ptr, fixed (21), fixed (35)), 2 43 /* read_length(p,len,s) */ 2 44 2 open_file entry (ptr, fixed bin, char (*), bit (1) aligned, fixed bin (35)), 2 45 /* open_file(p,mode,desc,not_used,s) */ 2 46 2 close_file entry (ptr, char (*), fixed bin (35)), 2 47 /* close_file(p,desc,s) */ 2 48 2 detach entry (ptr, char (*), fixed bin (35)); 2 49 /* detach(p,desc,s) */ 2 50 2 51 declare iox_$iocb_version_sentinel 2 52 character (4) aligned external static; 2 53 2 54 /* END INCLUDE FILE ..... iocb.incl.pl1 ..... */ 447 448 3 1 /* --------------- BEGIN include file status_structures.incl.pl1 --------------- */ 3 2 3 3 /* Revised from existing include files 09/26/78 by C. D. Tavares */ 3 4 3 5 /* This include file contains branch and link structures returned by 3 6* hcs_$status_ and hcs_$status_long. */ 3 7 3 8 dcl 1 status_branch aligned based (status_ptr), 3 9 2 short aligned, 3 10 3 type fixed bin (2) unaligned unsigned, /* seg, dir, or link */ 3 11 3 nnames fixed bin (16) unaligned unsigned, /* number of names */ 3 12 3 names_relp bit (18) unaligned, /* see entry_names dcl */ 3 13 3 dtcm bit (36) unaligned, /* date/time contents last modified */ 3 14 3 dtu bit (36) unaligned, /* date/time last used */ 3 15 3 mode bit (5) unaligned, /* caller's effective access */ 3 16 3 raw_mode bit (5) unaligned, /* caller's raw "rew" modes */ 3 17 3 pad1 bit (8) unaligned, 3 18 3 records_used fixed bin (18) unaligned unsigned, /* number of NONZERO pages used */ 3 19 3 20 /* Limit of information returned by hcs_$status_ */ 3 21 3 22 2 long aligned, 3 23 3 dtd bit (36) unaligned, /* date/time last dumped */ 3 24 3 dtem bit (36) unaligned, /* date/time branch last modified */ 3 25 3 lvid bit (36) unaligned, /* logical volume ID */ 3 26 3 current_length fixed bin (12) unaligned unsigned, /* number of last page used */ 3 27 3 bit_count fixed bin (24) unaligned unsigned, /* reported length in bits */ 3 28 3 pad2 bit (8) unaligned, 3 29 3 copy_switch bit (1) unaligned, /* copy switch */ 3 30 3 tpd_switch bit (1) unaligned, /* transparent to paging device switch */ 3 31 3 mdir_switch bit (1) unaligned, /* is a master dir */ 3 32 3 damaged_switch bit (1) unaligned, /* salvager warned of possible damage */ 3 33 3 synchronized_switch bit (1) unaligned, /* DM synchronized file */ 3 34 3 pad3 bit (5) unaligned, 3 35 3 ring_brackets (0:2) fixed bin (6) unaligned unsigned, 3 36 3 uid bit (36) unaligned; /* unique ID */ 3 37 3 38 dcl 1 status_link aligned based (status_ptr), 3 39 2 type fixed bin (2) unaligned unsigned, /* as above */ 3 40 2 nnames fixed bin (16) unaligned unsigned, 3 41 2 names_relp bit (18) unaligned, 3 42 2 dtem bit (36) unaligned, 3 43 2 dtd bit (36) unaligned, 3 44 2 pathname_length fixed bin (17) unaligned, /* see pathname */ 3 45 2 pathname_relp bit (18) unaligned; /* see pathname */ 3 46 3 47 dcl status_entry_names (status_branch.nnames) character (32) aligned 3 48 based (pointer (status_area_ptr, status_branch.names_relp)), 3 49 /* array of names returned */ 3 50 status_pathname character (status_link.pathname_length) aligned 3 51 based (pointer (status_area_ptr, status_link.pathname_relp)), 3 52 /* link target path */ 3 53 status_area_ptr pointer, 3 54 status_ptr pointer; 3 55 3 56 dcl (Link initial (0), 3 57 Segment initial (1), 3 58 Directory initial (2)) fixed bin internal static options (constant); 3 59 /* values for type fields declared above */ 3 60 3 61 /* ---------------- END include file status_structures.incl.pl1 ---------------- */ 449 450 451 452 453 end abs_io_put_chars; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 08/11/87 0925.5 abs_io_put_chars.pl1 >spec>install>MR12.1-1080>abs_io_put_chars.pl1 445 1 08/11/87 0925.5 abs_io_data.incl.pl1 >spec>install>MR12.1-1080>abs_io_data.incl.pl1 447 2 05/20/83 1846.4 iocb.incl.pl1 >ldd>include>iocb.incl.pl1 449 3 11/22/82 0955.7 status_structures.incl.pl1 >ldd>include>status_structures.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. Directory constant fixed bin(17,0) initial dcl 3-56 ref 176 182 Link constant fixed bin(17,0) initial dcl 3-56 ref 163 MSF_seg_idx 160 based fixed bin(17,0) level 3 dcl 1-23 set ref 291* 293* 293 295* 376* 379* 380* NULL constant char(1) initial dcl 73 ref 427 P_MSF parameter bit(1) dcl 23 ref 153 159 P_attach_data_ptr parameter pointer dcl 23 ref 153 156 206 209 P_buffer_len parameter fixed bin(21,0) dcl 23 ref 10 113 P_buffer_ptr parameter pointer dcl 23 ref 10 112 P_dir_name parameter char unaligned dcl 23 set ref 153 161* 165* 172 366* P_entry_name parameter char unaligned dcl 23 set ref 153 161* 165* 173 366* P_iocb_ptr parameter pointer dcl 23 ref 10 109 P_status parameter fixed bin(35,0) dcl 23 set ref 10 117* 141* 153 167* 184* 195* 199* 206 230* P_truncate parameter bit(1) dcl 23 ref 153 329 369 Segment constant fixed bin(17,0) initial dcl 3-56 ref 176 178 188 abs_data based structure level 1 dcl 1-23 abs_data_ptr 000210 automatic pointer dcl 1-21 set ref 110* 129 129 130 130 156* 158 158 159 209* 211 211 213 216 216 220 222 223 226 227 242 242 242 243 243 245 246 246 277 279 280 283 284 285 288 289 291 293 293 295 295 295 299 324 325 333 338 344 346 347 366 371 373 373 376 376 379 380 380 380 383 404 411 427 427 427 428 430 430 430 432 432 434 437 actual_iocb_ptr 12 based pointer level 2 dcl 2-6 ref 109 addr builtin function dcl 35 ref 134 161 161 270 270 279 279 304 304 384 384 any_other 000000 stack reference condition dcl 38 ref 268 attach_data_ptr 16 based pointer level 2 dcl 2-6 ref 110 bc 000176 automatic fixed bin(24,0) dcl 425 set ref 434* 435 437* binary builtin function dcl 35 ref 427 bit_count 7(12) 000176 automatic fixed bin(24,0) level 3 packed unsigned unaligned dcl 54 set ref 180* 182 336 379 428 435 branch 000176 automatic structure level 1 dcl 54 set ref 161 161 384 384 buffer based char unaligned dcl 58 set ref 134 242 buffer_len 000100 automatic fixed bin(21,0) dcl 42 set ref 113* 115 115 129 131 132* 134 134 135* 242 242 243 buffer_ptr 000102 automatic pointer dcl 42 set ref 112* 134* 134 242 command_line 162 based structure level 2 dcl 1-23 continue_to_signal_ 000034 constant entry external dcl 87 ref 272 create_dir_name 000104 automatic char(168) unaligned dcl 42 set ref 165* 166 172* 324* create_entry_name 000156 automatic char(32) unaligned dcl 42 set ref 165* 173* 324* current_len 156 based fixed bin(21,0) level 3 dcl 1-23 set ref 129 130 213 216 242 243* 243 246 299* 376* 427* 430 430* 430 432* 432 434 current_length 7 000176 automatic fixed bin(12,0) level 3 packed unsigned unaligned dcl 54 set ref 180* 331 427 dir_name 000100 automatic char(168) unaligned dcl 363 in procedure "open_segment" set ref 383* 384* dir_name 000100 automatic char(168) unaligned dcl 265 in procedure "get_next_MSF_component" set ref 280* 289* divide builtin function dcl 35 ref 428 entry_name 000152 automatic char(32) unaligned dcl 363 in procedure "open_segment" set ref 383* 384* entry_name 000152 automatic char(32) unaligned dcl 265 in procedure "get_next_MSF_component" set ref 280* 289* error_table_$buffer_big 000016 external static fixed bin(35,0) dcl 77 ref 117 error_table_$dirseg 000020 external static fixed bin(35,0) dcl 77 ref 184 error_table_$file_is_full 000022 external static fixed bin(35,0) dcl 77 ref 192 408 error_table_$moderr 000024 external static fixed bin(35,0) dcl 77 ref 320 387 error_table_$no_s_permission 000026 external static fixed bin(35,0) dcl 77 ref 163 176 error_table_$unable_to_do_io 000030 external static fixed bin(35,0) dcl 77 ref 193 fcb_ptr 152 based pointer level 3 dcl 1-23 set ref 158* 220 227* 277 289* 295* 366* 371* 373* 380* file_is_full 000012 internal static structure level 1 dcl 65 set ref 279 279 hcs_$fs_get_path_name 000036 constant entry external dcl 87 ref 280 383 hcs_$get_link_target 000040 constant entry external dcl 87 ref 165 hcs_$get_max_length_seg 000042 constant entry external dcl 87 ref 404 hcs_$get_safety_sw_seg 000044 constant entry external dcl 87 ref 344 hcs_$make_seg 000046 constant entry external dcl 87 ref 324 hcs_$reset_ips_mask 000050 constant entry external dcl 87 ref 301 hcs_$set_bc_seg 000052 constant entry external dcl 87 ref 216 246 338 437 hcs_$set_ips_mask 000054 constant entry external dcl 87 ref 275 hcs_$set_safety_sw_seg 000056 constant entry external dcl 87 ref 211 284 347 hcs_$status_long 000060 constant entry external dcl 87 ref 161 384 hcs_$terminate_noname 000062 constant entry external dcl 87 ref 222 288 hcs_$truncate_seg 000064 constant entry external dcl 87 ref 333 iocb based structure level 1 dcl 2-6 iocb_ptr 000166 automatic pointer dcl 42 set ref 109* 110 length builtin function dcl 35 ref 427 long 4 000176 automatic structure level 2 dcl 54 mask 000170 automatic bit(36) unaligned dcl 42 set ref 121* 270 275* 275* 301* 301* max builtin function dcl 35 ref 428 430 432 max_buffer_size 000010 internal static fixed bin(21,0) dcl 63 set ref 115 412* max_len 157 based fixed bin(21,0) level 3 dcl 1-23 set ref 129 130 242 411* 427 428 may_be_MSF 161 based bit(1) level 4 packed unaligned dcl 1-23 set ref 159* 279 min builtin function dcl 35 ref 428 mod builtin function dcl 35 ref 213 430 mode 3 000176 automatic bit(5) level 3 packed unaligned dcl 54 set ref 179* 318 385 msf_manager_$adjust 000072 constant entry external dcl 87 ref 371 msf_manager_$close 000074 constant entry external dcl 87 ref 227 msf_manager_$get_ptr 000070 constant entry external dcl 87 ref 295 373 380 msf_manager_$open 000066 constant entry external dcl 87 ref 289 366 no_set_bc 151(04) based bit(1) level 3 packed unaligned dcl 1-23 ref 245 null builtin function dcl 35 ref 158 161 161 220 223 226 277 325 384 384 open_data 66 based structure level 2 dcl 1-23 output_file 152 based structure level 2 dcl 1-23 output_seg based char unaligned dcl 58 set ref 242* 427 pad_len 000171 automatic fixed bin(21,0) dcl 42 set ref 130* 131 132 213* 214 428* 430 432 434 rest_of_buffer_len 000172 automatic fixed bin(21,0) dcl 42 set ref 131* 135 rtrim builtin function dcl 35 ref 427 safety_switch 000173 automatic bit(1) dcl 42 set ref 344* 345 seg_max_len 000174 automatic fixed bin(19,0) dcl 42 set ref 404* 406 411 seg_ptr 154 based pointer level 3 dcl 1-23 set ref 158* 211* 216* 222* 223* 226* 242 246* 280* 284* 288* 295* 324* 325 333* 338* 344* 347* 373* 380* 383* 404* 427 437* short 000176 automatic structure level 2 dcl 54 status 000175 automatic fixed bin(35,0) dcl 42 set ref 161* 163 163 165* 167 176 176 199 216* 217 246* 247 280* 281 289* 290 295* 297 320* 324* 333* 334 338* 339 344* 345 347* 366* 367 371* 372 373* 374 380* 382 387* 404* 405 408* 437* 438 status_branch based structure level 1 dcl 3-8 status_code 1 000012 internal static fixed bin(35,0) level 2 in structure "file_is_full" dcl 65 in procedure "abs_io_put_chars" set ref 192* status_code 1 000014 internal static fixed bin(35,0) level 2 in structure "unable_to_do_io" dcl 69 in procedure "abs_io_put_chars" set ref 193* substr builtin function dcl 35 set ref 134 242* 270 427 switches 161 based structure level 3 dcl 1-23 sys_info$max_seg_size 000032 external static fixed bin(35,0) dcl 77 ref 412 terminate_process_ 000076 constant entry external dcl 87 ref 270 279 304 turn_off_ssw 161(01) based bit(1) level 4 packed unaligned dcl 1-23 set ref 211 283 285* 346* type 000176 automatic fixed bin(2,0) level 3 packed unsigned unaligned dcl 54 set ref 163 176 176 178* 182 188 unable_to_do_io 000014 internal static structure level 1 dcl 69 set ref 270 270 304 304 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ALL internal static fixed bin(17,0) initial dcl 1-180 BOTH internal static fixed bin(17,0) initial dcl 1-180 EXPANDED internal static fixed bin(17,0) initial dcl 1-180 UNEXPANDED internal static fixed bin(17,0) initial dcl 1-180 Work_area_size internal static fixed bin(17,0) initial dcl 1-177 abs_data_version_1 internal static fixed bin(17,0) initial dcl 1-177 iox_$iocb_version_sentinel external static char(4) dcl 2-51 status_area_ptr automatic pointer dcl 3-47 status_entry_names based char(32) array dcl 3-47 status_link based structure level 1 dcl 3-38 status_pathname based char dcl 3-47 status_ptr automatic pointer dcl 3-47 NAMES DECLARED BY EXPLICIT CONTEXT. PUNT 000404 constant label dcl 199 ref 217 247 321 325 334 339 367 372 374 382 388 405 409 438 PUNT_MASKED 001121 constant label dcl 304 ref 281 290 297 abs_io_put_chars 000031 constant entry external dcl 10 adjust_length 001762 constant entry internal dcl 422 ref 342 391 close 000413 constant entry external dcl 206 get_max_len 001715 constant entry internal dcl 401 ref 327 375 390 get_next_MSF_component 000573 constant entry internal dcl 262 ref 136 open 000126 constant entry external dcl 153 open_MSF 001370 constant entry internal dcl 360 ref 190 open_segment 001146 constant entry internal dcl 315 ref 188 write 000534 constant entry internal dcl 239 ref 133 139 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2444 2544 2071 2454 Length 3056 2071 100 275 353 6 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME abs_io_put_chars 190 external procedure is an external procedure. write internal procedure shares stack frame of external procedure abs_io_put_chars. get_next_MSF_component 162 internal procedure enables or reverts conditions. on unit on line 268 80 on unit open_segment 178 internal procedure is declared options(non_quick). get_max_len internal procedure shares stack frame of internal procedure open_segment. adjust_length internal procedure shares stack frame of internal procedure open_segment. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 max_buffer_size abs_io_put_chars 000012 file_is_full abs_io_put_chars 000014 unable_to_do_io abs_io_put_chars STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME abs_io_put_chars 000100 buffer_len abs_io_put_chars 000102 buffer_ptr abs_io_put_chars 000104 create_dir_name abs_io_put_chars 000156 create_entry_name abs_io_put_chars 000166 iocb_ptr abs_io_put_chars 000170 mask abs_io_put_chars 000171 pad_len abs_io_put_chars 000172 rest_of_buffer_len abs_io_put_chars 000173 safety_switch abs_io_put_chars 000174 seg_max_len abs_io_put_chars 000175 status abs_io_put_chars 000176 branch abs_io_put_chars 000210 abs_data_ptr abs_io_put_chars get_next_MSF_component 000100 dir_name get_next_MSF_component 000152 entry_name get_next_MSF_component open_segment 000100 dir_name open_segment 000152 entry_name open_segment 000176 bc adjust_length THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out call_int_this return_mac tra_ext_1 mdfx1 enable_op ext_entry ext_entry_desc int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. continue_to_signal_ hcs_$fs_get_path_name hcs_$get_link_target hcs_$get_max_length_seg hcs_$get_safety_sw_seg hcs_$make_seg hcs_$reset_ips_mask hcs_$set_bc_seg hcs_$set_ips_mask hcs_$set_safety_sw_seg hcs_$status_long hcs_$terminate_noname hcs_$truncate_seg msf_manager_$adjust msf_manager_$close msf_manager_$get_ptr msf_manager_$open terminate_process_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$buffer_big error_table_$dirseg error_table_$file_is_full error_table_$moderr error_table_$no_s_permission error_table_$unable_to_do_io sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 10 000024 109 000041 110 000045 112 000047 113 000052 115 000054 117 000057 118 000061 121 000062 129 000063 130 000071 131 000074 132 000077 133 000101 134 000102 135 000106 136 000110 137 000114 139 000115 141 000116 143 000117 153 000120 156 000151 158 000155 159 000160 161 000164 163 000227 165 000237 166 000272 167 000276 168 000300 170 000301 172 000302 173 000310 176 000315 178 000332 179 000336 180 000342 181 000346 182 000347 184 000354 185 000357 188 000360 190 000371 192 000375 193 000400 195 000402 197 000403 199 000404 201 000406 206 000407 209 000423 211 000427 213 000450 214 000455 216 000456 217 000474 220 000476 222 000503 223 000515 224 000520 226 000521 227 000523 230 000532 231 000533 239 000534 242 000535 243 000545 245 000546 246 000551 247 000567 250 000571 262 000572 268 000600 270 000614 272 000644 273 000653 275 000654 277 000665 279 000673 280 000721 281 000755 283 000760 284 000764 285 001002 288 001006 289 001020 290 001047 291 001052 292 001055 293 001056 295 001057 297 001103 299 001106 301 001110 302 001120 304 001121 307 001144 315 001145 318 001153 320 001161 321 001163 324 001166 325 001225 327 001236 329 001237 331 001244 333 001247 334 001264 336 001272 338 001276 339 001313 341 001321 342 001322 344 001323 345 001340 346 001346 347 001351 350 001366 360 001367 366 001375 367 001426 369 001434 371 001441 372 001465 373 001473 374 001522 375 001530 376 001531 377 001535 379 001536 380 001543 382 001567 383 001575 384 001632 385 001676 387 001704 388 001707 390 001712 391 001713 394 001714 401 001715 404 001716 405 001733 406 001741 408 001744 409 001747 411 001752 412 001755 414 001761 422 001762 427 001763 428 002004 430 002017 432 002031 434 002037 435 002043 437 002045 438 002060 441 002066 ----------------------------------------------------------- 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