COMPILATION LISTING OF SEGMENT audit_file_position_ Compiled by: Multics PL/I Compiler, Release 30, of February 16, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 09/15/88 1341.2 mst Thu Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* *********************************************************** */ 8 9 10 11 /****^ HISTORY COMMENTS: 12* 1) change(88-08-02,TLNguyen), approve(88-08-02,MCR7939), 13* audit(88-09-14,Parisek), install(88-09-15,MR12.2-1110): 14* a. Return error_table_$bad_file when the audit file contains gargage 15* or nothing other than the header. 16* b. Remove the external entry named find_valid_entry because pcref 17* shows it has no caller and is virtually useless anyway. 18* END HISTORY COMMENTS */ 19 20 21 /* format: style2,ind3 */ 22 audit_file_position_: 23 proc; 24 return; /* Not a valid entry. */ 25 26 /* The entries in this procedure are all of the entries used for getting 27* around in the audit file. The position_info structure is used to specify 28* various things about the state of the audit file which some of theses 29* procedures need to know. The entries are: 30* 31*move_number - move a specified number of entries either relative to the 32* current position or from the beginning of the file. 33* 34*move_time - move to a specified time, relative to the current entry or an 35* absolute time. 36* 37*forward_search - search forward through the audit file for an entry which 38* contains a match for the specified regular expression (qedx style). 39* 40*backward_search - search backward through the audit file for and entry which 41* contains a match for the specified regular expression. 42* 43*next - move to the next entry. 44* 45*previous - move to the previous entry. 46* 47*first - move to the first entry in the file. 48* 49*last - move to the last entry in the file. 50* 51*count_last - count to the last entry in the file. Unlike "last", this entry 52* sets the entry_number in the position structure. 53* 54*set_count - set the count in the position structure to be the count up to 55* the current entry, given the class id of the current entry. The "any 56* entry" flag in the position info structure is ignored by this entry. 57* 58* 59*12/08/78 Written by Lindsey L. Spratt 60* 61*Modified: 62* 12/08/79 by Lindsey Spratt: Add the count_last and set_count entries. 63* 10/26/80 by Lindsey Spratt: Change spurious error code 64* incompatible_operations to be "inconsistent". Changed set_count 65* to set the class_identifier in the position structure to "" if 66* the "any entry" bit is on in the position_info structure. 67*06/02/82 by Lindsey Spratt: Change go_to_first and go_to_last internal 68* procedures to set the component_max_char_index correctly when the 69* audit file is circular. 70* Also, changed "move_number" from being a synonym label for 71* audit_file_position_ to being a separate entrypoint label. 72*06/03/82 by Lindsey Spratt: Fixed bug in setting of last entry position when 73* the file is circular. 74*06/04/82 by Lindsey Spratt: Fixed problem in go_to_previous_entry which was 75* generating a size or subscriptrange error. msf_manager_$get_ptr 76* returns the bit count of the component when the component was 77* first initiated for the "current" opening of the MSF, not the 78* current bit count as one might expect. The fix is to do an 79* explicit hcs_$status_mins to determine the bit count. 80*06/08/82 by Lindsey Spratt: Fixed go_to_last to behave correctly when the 81* position_info.audit_index = 0, meaning the "last" entry is at the 82* end of the "previous" component. This comes up when updating the 83* metering info is being done by audit_ (in insert_line) and the 84* entry being inserted is to large to fit in the current component, 85* hence the new entry is being placed at index 0 of the "next" 86* component (which is now the current component) and the last 87* entry is at the end of the previous component. 88*10/13/82 by Lindsey Spratt: Added limits to all loops. The limit is somewhat 89* arbitrarily set to by assuming that an audit file won't have more 90* than 1000 components, each of 255 pages, each page having no more 91* than 128 audit entries. These loop limits are to prevent any 92* infinite looping, no matter how damaged the audit file may be. 93* Added explicit subscriptrange condition enabling for setting the 94* position.aep pointer by indexing into file_char_array by 95* position.char_index. 96*03/16/83 by Lindsey Spratt: Updated the search_file_ entry declaration to fix 97* a size condition. 98**/ 99 100 dcl (p_position_ptr, p_position_info_ptr) 101 ptr; 102 dcl (time, p_time) fixed bin (71); 103 dcl 1 p_position based (p_position_ptr) like position_template; 104 dcl 1 position like position_template; 105 dcl 1 position_info based (p_position_info_ptr) like position_info_template; 106 dcl error_table_$bad_file fixed bin (35) ext static; 107 dcl error_table_$empty_file 108 fixed bin (35) ext; 109 dcl error_table_$end_of_info 110 fixed bin (35) ext; 111 dcl error_table_$nomatch fixed bin (35) ext; 112 dcl (p_abs, p_add, p_subtract) 113 bit (1); 114 dcl add bit (1); 115 dcl (p_number, number) fixed bin; 116 dcl entry_idx fixed bin (35); 117 dcl entry_number fixed bin; 118 dcl (code, p_code) fixed bin (35); 119 dcl type fixed bin (2); 120 dcl MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 121 init (3.264e7) /* 1000 components * 255 pages/component * 128 entries/page */ 122 fixed bin (35) internal static options (constant); 123 dcl error_table_$inconsistent 124 fixed bin (35) ext; 125 dcl search_file_ entry (ptr, fixed bin (21), fixed bin (21), ptr, fixed bin (21), fixed bin (21), 126 fixed bin (21), fixed bin (21), fixed bin (35)); 127 dcl hcs_$status_mins entry (ptr, fixed bin (2), fixed bin (24), fixed bin (35)); 128 dcl msf_manager_$get_ptr entry (ptr, fixed bin, bit (1), ptr, fixed bin (24), fixed bin (35)); 129 130 /* Builtin */ 131 132 dcl (abs, addr, addrel, bin, currentsize, divide, length, mod, size, substr) 133 builtin; 134 135 move_number: 136 entry (p_position_ptr, p_abs, p_add, p_subtract, p_number, p_position_info_ptr, p_code); 137 138 position = p_position; 139 p_code, code = 0; 140 141 142 /* An exclusive or is done over the input switches to check that one and 143* only one is "1"b and the other two are "0"b. */ 144 145 if (bin (p_abs) + bin (p_add) + bin (p_subtract)) ^= 1 146 then 147 do; 148 p_code = error_table_$inconsistent; 149 return; 150 end; 151 else if p_abs 152 then 153 do; 154 if (position.entry_number = 0 | position.search_tag ^= position_info.default_search_tag) 155 then 156 do; 157 call go_to_first_entry (position, code); 158 number = p_number - 1; 159 add = "1"b; 160 end; 161 else 162 do; 163 number = p_number - position.entry_number; 164 if number < 0 165 then 166 do; 167 add = "0"b; 168 number = abs (number); 169 end; 170 else add = "1"b; 171 end; 172 end; 173 else 174 do; 175 add = p_add; 176 number = p_number; 177 end; 178 179 180 if add 181 then 182 do entry_number = 1 to number while (code = 0); 183 call go_to_next_entry (position, code); 184 end; 185 else 186 do entry_number = 1 to number while (code = 0); 187 call go_to_previous_entry (position, code); 188 end; 189 if code ^= 0 190 then if code ^= error_table_$end_of_info 191 then 192 do; 193 p_code = code; 194 return; 195 end; 196 p_code = code; 197 p_position = position; 198 return; 199 200 201 202 move_time: 203 entry (p_position_ptr, p_abs, p_add, p_subtract, p_time, p_position_info_ptr, p_code); 204 position = p_position; 205 p_code, code = 0; 206 207 if (bin (p_abs) + bin (p_add) + bin (p_subtract)) ^= 1 208 then 209 do; 210 p_code = error_table_$inconsistent; 211 return; 212 end; 213 else if p_abs 214 then 215 do; 216 call go_to_first_entry (position, code); 217 time = p_time; 218 add = "1"b; 219 end; 220 else if p_add 221 then 222 do; 223 time = position.aep -> audit_entry.time + p_time; 224 add = "1"b; 225 end; 226 else 227 do; 228 time = position.aep -> audit_entry.time - p_time; 229 if time < 0 230 then time = 0; 231 add = "0"b; 232 end; 233 234 if add 235 then 236 do entry_idx = 1 to MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 237 while (position.aep -> audit_entry.time < time & code = 0); 238 call go_to_next_entry (position, code); 239 end; 240 else 241 do entry_idx = 1 to MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 242 while (position.aep -> audit_entry.time > time & code = 0); 243 call go_to_previous_entry (position, code); 244 end; 245 246 if entry_idx > MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 247 then code = error_table_$bad_file; 248 249 if code ^= 0 250 then if code ^= error_table_$end_of_info 251 then 252 do; 253 p_code = code; 254 return; 255 end; 256 p_code = code; 257 p_position = position; 258 259 return; 260 261 262 forward_search: 263 entry (p_position_ptr, p_match_str, p_position_info_ptr, p_code); 264 dcl (p_match_str, match_str) 265 char (256) varying; 266 dcl (forward, continue) bit (1) init ("1"b); 267 dcl (match_begin, match_end) 268 fixed bin(21); 269 dcl do_first_entry bit (1); 270 271 goto START; 272 273 backward_search: 274 entry (p_position_ptr, p_match_str, p_position_info_ptr, p_code); 275 276 forward = "0"b; 277 278 START: 279 p_code, code = 0; 280 position = p_position; 281 match_str = p_match_str; 282 283 do_first_entry = "1"b; 284 do entry_idx = 1 to MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 285 while ((continue & (position.aep ^= p_position.aep)) | do_first_entry); 286 do_first_entry = "0"b; 287 if forward 288 then call go_to_next_entry (position, code); 289 else call go_to_previous_entry (position, code); 290 if code ^= 0 291 then if code = error_table_$end_of_info 292 then 293 do; 294 code = 0; 295 if forward 296 then call go_to_first_entry (position, code); 297 else call go_to_last_entry (position, code); 298 if code ^= 0 299 then continue = "0"b; 300 end; 301 else 302 do; 303 p_code = code; 304 return; 305 end; 306 call 307 search_file_ (addrel (addr (match_str), 1), 1, length (match_str), addr (position.aep -> audit_entry.string), 308 1, (position.aep -> audit_entry.entry_length), match_begin, match_end, code); 309 if code ^= 1 310 then continue = "0"b; 311 else match_str = ""; 312 end; 313 if entry_idx > MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 314 then code = error_table_$bad_file; 315 316 if code = 0 317 then p_position = position; 318 else if code = 1 319 then code = error_table_$nomatch; 320 321 p_code = code; 322 return; 323 324 325 next: 326 entry (p_position_ptr, p_position_info_ptr, p_code); 327 p_code, code = 0; 328 call go_to_next_entry (p_position, p_code); 329 return; 330 331 previous: 332 entry (p_position_ptr, p_position_info_ptr, p_code); 333 p_code, code = 0; 334 call go_to_previous_entry (p_position, p_code); 335 return; 336 337 first: 338 entry (p_position_ptr, p_position_info_ptr, p_code); 339 p_code, code = 0; 340 call go_to_first_entry (p_position, p_code); 341 return; 342 343 last: 344 entry (p_position_ptr, p_position_info_ptr, p_code); 345 p_code, code = 0; 346 call go_to_last_entry (p_position, p_code); 347 return; 348 349 count_last: 350 entry (p_position_ptr, p_position_info_ptr, p_code); 351 p_code, code = 0; 352 call go_to_first_entry (p_position, p_code); 353 if p_code ^= 0 354 then return; 355 do entry_idx = 1 to MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE while (p_code = 0); 356 call go_to_next_entry (p_position, p_code); 357 end; 358 if entry_idx > MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 359 then p_code = error_table_$bad_file; 360 361 if p_code = error_table_$end_of_info 362 then p_code = 0; 363 return; 364 365 366 set_count: 367 entry (p_position_ptr, p_position_info_ptr, p_code); 368 p_code, code = 0; 369 position = p_position; 370 call go_to_first_entry (position, p_code); 371 if p_code ^= 0 372 then return; 373 do entry_idx = 1 to MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE while (position.aep ^= p_position.aep); 374 call go_to_next_entry (position, p_code); 375 end; 376 if entry_idx > MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 377 then 378 do; 379 p_code = error_table_$bad_file; 380 return; 381 end; 382 383 p_position = position; 384 if position_info.any_tag 385 then p_position.search_tag = ""; 386 return; 387 388 go_to_next_entry: 389 proc (p_position, p_code); 390 dcl entry_idx fixed bin (35); 391 dcl 1 p_position like position_template; 392 dcl 1 position like position_template; 393 dcl 1 last_position like position_template; 394 dcl (code, p_code) fixed bin (35); 395 dcl bit_count24 fixed bin (24); 396 dcl file_char_array (0:position.component_max_char_index) char (1) based (position.component_ptr); 397 dcl tag_match bit (1); 398 p_code, code = 0; 399 tag_match = "0"b; 400 position = p_position; 401 last_position = p_position; 402 call go_to_last_entry (last_position, code); 403 404 if (position.component_number = last_position.component_number) & (position.char_index = last_position.char_index) 405 then 406 do; 407 p_code = error_table_$end_of_info; 408 return; 409 end; 410 411 do entry_idx = 1 to MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 412 while 413 ((position.component_number ^= last_position.component_number | position.char_index ^= last_position.char_index) 414 & ^tag_match); 415 position.char_index = 416 position.char_index + (currentsize (position.aep -> audit_entry) * 4) + 7 417 - mod ((currentsize (position.aep -> audit_entry) * 4) + 7, 8); 418 419 if position.char_index >= position.component_max_char_index 420 then if position.component_number = position_info.max_component 421 then 422 do; 423 if position_info.max_component ^= 0 424 then 425 do; 426 position.component_number = 0; 427 position.component_ptr = position_info.audit_ptr; 428 if position_info.current_component = 0 429 then position.component_max_char_index = position_info.audit_index; 430 else 431 do; 432 call hcs_$status_mins (position.component_ptr, type, bit_count24, code); 433 if code ^= 0 434 then 435 do; 436 p_code = code; 437 return; 438 end; 439 call hcs_$status_mins (position.component_ptr, type, bit_count24, code); 440 if code ^= 0 441 then 442 do; 443 p_code = code; 444 return; 445 end; 446 position.component_max_char_index = divide (bit_count24, 9, 24, 0); 447 position.component_max_char_index = 448 position.component_max_char_index + 7 - mod (position.component_max_char_index + 7, 8); 449 end; 450 end; 451 else position.component_max_char_index = position_info.audit_index - 1; 452 position.char_index = 453 (size (audit_file_header) * 4) + 7 - mod ((size (audit_file_header) * 4) + 7, 8); 454 end; 455 else 456 do; 457 position.component_number = position.component_number + 1; 458 if position.component_number = position_info.current_component 459 then 460 do; 461 position.char_index = 0; 462 position.component_ptr = position_info.audit_ptr; 463 position.component_max_char_index = position_info.audit_index - 1; 464 end; 465 else if position.component_number = position_info.max_component 466 then 467 do; 468 position.char_index = 0; 469 call 470 msf_manager_$get_ptr (position_info.audit_fcb, position.component_number, "1"b, 471 position.component_ptr, bit_count24, code); 472 position.component_max_char_index = position_info.max_index; 473 end; 474 else 475 do; 476 position.char_index = 0; 477 call 478 msf_manager_$get_ptr (position_info.audit_fcb, position.component_number, "1"b, 479 position.component_ptr, bit_count24, code); 480 if code ^= 0 481 then 482 do; 483 p_code = code; 484 return; 485 end; 486 position.component_max_char_index = divide (bit_count24, 9, 24, 0); 487 position.component_max_char_index = 488 position.component_max_char_index + 7 - mod (position.component_max_char_index + 7, 8); 489 end; 490 end; 491 (subscriptrange): 492 position.aep = addr (file_char_array (position.char_index)); 493 call validate_entry (position, p_code); 494 if p_code ^= 0 495 then return; 496 if position_info.any_tag 497 then tag_match = "1"b; 498 else call set_tag_match (position.aep, position_info.default_search_tag, tag_match); 499 end; 500 if entry_idx > MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 501 then 502 do; 503 p_code = error_table_$bad_file; 504 return; 505 end; 506 507 if tag_match 508 then 509 do; 510 if (position.entry_number ^= 0 & position.search_tag = position_info.default_search_tag) 511 then position.entry_number = position.entry_number + 1; 512 else 513 do; 514 position.entry_number = 0; 515 position.search_tag = ""; 516 end; 517 p_position = position; 518 p_code = 0; 519 end; 520 else p_code = error_table_$end_of_info; 521 end go_to_next_entry; 522 523 go_to_previous_entry: 524 proc (p_position, p_code); 525 dcl tag_match bit (1); 526 dcl entry_idx fixed bin (35); 527 dcl 1 position like position_template; 528 dcl 1 p_position like position_template; 529 dcl (code, p_code) fixed bin (35); 530 dcl bit_count24 fixed bin (24); 531 dcl file_char_array (0:position.component_max_char_index) char (1) based (position.component_ptr); 532 p_code, code = 0; 533 tag_match = "0"b; 534 position = p_position; 535 536 if (position.component_number = position_info.begin_component) & (position.char_index = position_info.begin_index) 537 then 538 do; 539 p_code = error_table_$end_of_info; 540 return; 541 end; 542 543 do entry_idx = 1 to MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 544 while 545 ((position.component_number ^= position_info.begin_component | position.char_index ^= position_info.begin_index) 546 & ^tag_match); 547 548 position.char_index = 549 position.char_index 550 - (position.aep -> audit_entry.last_entry_length + 7 551 - mod (position.aep -> audit_entry.last_entry_length + 7, 8) + (size (audit_entry) * 4)); 552 553 /* Check if the char_index has crossed a component boundary. If so reset char_index 554* component_number, component_ptr, and component_max_char_index appropriately. 555**/ 556 557 if position.component_number = 0 558 & position.char_index < ((size (audit_file_header) * 4) + 7 - mod ((size (audit_file_header) * 4) + 7, 8)) 559 /* The beginning of the zero-th component is after the header. */ 560 then 561 do; 562 if position_info.file_limit 563 then 564 do; 565 if position_info.max_component ^= position.component_number 566 then 567 do; 568 position.component_number = position_info.max_component; 569 call 570 msf_manager_$get_ptr (position_info.audit_fcb, position.component_number, "1"b, 571 position.component_ptr, bit_count24, code); 572 if code ^= 0 573 then 574 do; 575 p_code = code; 576 return; 577 end; 578 end; 579 call hcs_$status_mins (position.component_ptr, type, bit_count24, code); 580 if code ^= 0 581 then 582 do; 583 p_code = code; 584 return; 585 end; 586 position.component_max_char_index = divide (bit_count24, 9, 24, 0); 587 position.component_max_char_index = 588 position.component_max_char_index + 7 - mod (position.component_max_char_index + 7, 8); 589 end; 590 591 else 592 do; 593 position.component_number = position_info.current_component; 594 position.component_max_char_index = position_info.audit_index - 1; 595 position.component_ptr = position_info.audit_ptr; 596 end; 597 position.char_index = 598 position.component_max_char_index 599 - (position.aep -> audit_entry.last_entry_length + 7 600 - mod (position.aep -> audit_entry.last_entry_length + 7, 8) + (size (audit_entry) * 4)); 601 end; 602 else if position.char_index < 0 603 then 604 do; 605 position.component_number = position.component_number - 1; 606 call 607 msf_manager_$get_ptr (position_info.audit_fcb, position.component_number, "1"b, position.component_ptr, 608 bit_count24, code); 609 if code ^= 0 610 then 611 do; 612 p_code = code; 613 return; 614 end; 615 call hcs_$status_mins (position.component_ptr, type, bit_count24, code); 616 if code ^= 0 617 then 618 do; 619 p_code = code; 620 return; 621 end; 622 position.component_max_char_index = divide (bit_count24, 9, 24, 0); 623 position.component_max_char_index = 624 position.component_max_char_index + 7 - mod (position.component_max_char_index + 7, 8); 625 position.char_index = 626 position.component_max_char_index 627 - (position.aep -> audit_entry.last_entry_length + 7 628 - mod (position.aep -> audit_entry.last_entry_length + 7, 8) + (size (audit_entry) * 4)); 629 end; 630 (subscriptrange): 631 position.aep = addr (file_char_array (position.char_index)); 632 call validate_entry (position, p_code); 633 if p_code ^= 0 634 then return; 635 if position_info.any_tag 636 then tag_match = "1"b; 637 else call set_tag_match (position.aep, position_info.default_search_tag, tag_match); 638 end; 639 if entry_idx > MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 640 then 641 do; 642 p_code = error_table_$bad_file; 643 return; 644 end; 645 646 if tag_match 647 then 648 do; 649 if (position.entry_number ^= 0 & position.search_tag = position_info.default_search_tag) 650 then position.entry_number = position.entry_number - 1; 651 else 652 do; 653 position.entry_number = 0; 654 position.search_tag = ""; 655 end; 656 657 p_position = position; 658 p_code = 0; 659 end; 660 661 else p_code = error_table_$end_of_info; 662 end go_to_previous_entry; 663 664 go_to_last_entry: 665 proc (p_position, p_code); 666 dcl 1 p_position like position_template; 667 dcl 1 position like position_template; 668 dcl file_char_array (0:position.component_max_char_index) char (1) based (position.component_ptr); 669 dcl bit_count24 fixed bin (24); 670 dcl tag_match bit (1); 671 dcl (p_code, code) fixed bin (35); 672 673 /* The last_entry_length is initialized by audit_attach (called by the command 674*attach_audit) to the value impossible_audit_entry_length. This value is 675*declared in the audit_entry.incl.pl1 include file. 676**/ 677 p_code, code = 0; 678 if position_info.last_entry_length = impossible_audit_entry_length 679 then 680 do; 681 p_code = error_table_$empty_file; 682 return; 683 end; 684 if position_info.audit_index = (size (audit_file_header) * 4) + 7 - mod (size (audit_file_header) * 4 + 7, 8) 685 & position_info.file_limit 686 then 687 do; 688 position.component_number = position_info.max_component; 689 call 690 msf_manager_$get_ptr (position_info.audit_fcb, position.component_number, "1"b, position.component_ptr, 691 bit_count24, code); 692 if code ^= 0 693 then 694 do; 695 p_code = code; 696 return; 697 end; 698 end; 699 else if position_info.audit_index = 0 700 then 701 do; 702 position.component_number = position_info.current_component - 1; 703 call 704 msf_manager_$get_ptr (position_info.audit_fcb, position.component_number, "1"b, position.component_ptr, 705 bit_count24, code); 706 if code ^= 0 707 then 708 do; 709 p_code = code; 710 return; 711 end; 712 end; 713 else 714 do; 715 position.component_number = position_info.current_component; 716 position.component_ptr = position_info.audit_ptr; 717 end; 718 719 if (position_info.audit_index = 0 720 | (position_info.file_limit 721 & (position_info.begin_component > position_info.current_component 722 | (position_info.begin_component = position_info.current_component 723 & position_info.begin_index > position_info.audit_index)))) 724 then 725 do; 726 call hcs_$status_mins (position.component_ptr, type, bit_count24, code); 727 if code ^= 0 728 then 729 do; 730 p_code = code; 731 return; 732 end; 733 position.component_max_char_index = divide (bit_count24, 9, 24, 0); 734 position.component_max_char_index = 735 position.component_max_char_index + 7 - mod (position.component_max_char_index + 7, 8); 736 end; 737 else position.component_max_char_index = position_info.audit_index; 738 739 if (position_info.audit_index = 0 740 | (position_info.file_limit 741 & position_info.audit_index = (size (audit_file_header) * 4) + 7 - mod (size (audit_file_header) * 4 + 7, 8))) 742 then position.char_index = 743 position.component_max_char_index 744 - (position_info.last_entry_length + 7 - mod (position_info.last_entry_length + 7, 8) 745 + audit_entry_header_length); 746 else position.char_index = 747 position_info.audit_index 748 - (position_info.last_entry_length + 7 - mod (position_info.last_entry_length + 7, 8) 749 + audit_entry_header_length); 750 751 (subscriptrange): 752 position.aep = addr (file_char_array (position.char_index)); 753 position.entry_number = 0; 754 position.search_tag = ""; 755 call validate_entry (position, p_code); 756 if p_code ^= 0 757 then return; 758 759 if position_info.any_tag 760 then tag_match = "1"b; 761 else call set_tag_match (position.aep, position_info.default_search_tag, tag_match); 762 if ^tag_match 763 then 764 do; 765 call go_to_previous_entry (position, code); 766 if code ^= 0 767 then 768 do; 769 p_code = code; 770 return; 771 end; 772 end; 773 p_code = 0; 774 p_position = position; 775 end go_to_last_entry; 776 777 go_to_first_entry: 778 proc (p_position, p_code); 779 dcl 1 p_position like position_template; 780 dcl 1 position like position_template; 781 dcl (p_code, code) fixed bin (35); 782 dcl tag_match bit (1); 783 dcl bit_count24 fixed bin (24); 784 dcl file_char_array (0:position.component_max_char_index) char (1) based (position.component_ptr); 785 p_code, code = 0; 786 position = p_position; 787 788 if position_info.last_entry_length < 0 789 then 790 do; 791 p_code = error_table_$empty_file; 792 return; 793 end; 794 795 if position.component_number ^= position_info.begin_component 796 then 797 do; 798 position.component_number = position_info.begin_component; 799 position.char_index = position_info.begin_index; 800 801 if position_info.current_component = position_info.begin_component 802 & position_info.begin_index < position_info.audit_index 803 then position.component_ptr = position_info.audit_ptr; 804 else 805 do; 806 call 807 msf_manager_$get_ptr (position_info.audit_fcb, position.component_number, "1"b, 808 position.component_ptr, bit_count24, code); 809 if code ^= 0 810 then 811 do; 812 p_code = code; 813 return; 814 end; 815 end; 816 end; 817 818 else position.char_index = position_info.begin_index; 819 820 if (position_info.file_limit 821 & (position_info.begin_component > position_info.current_component 822 | (position_info.begin_component = 0 & position_info.begin_index >= position_info.audit_index))) 823 | (^position_info.file_limit & position_info.current_component > 0) 824 then 825 do; 826 call hcs_$status_mins (position.component_ptr, type, bit_count24, code); 827 if code ^= 0 828 then 829 do; 830 p_code = code; 831 return; 832 end; 833 position.component_max_char_index = divide (bit_count24, 9, 24, 0); 834 position.component_max_char_index = 835 position.component_max_char_index + 7 - mod (position.component_max_char_index + 7, 8); 836 end; 837 else position.component_max_char_index = position_info.audit_index; 838 839 (subscriptrange): 840 position.aep = addr (file_char_array (position.char_index)); 841 call validate_entry (position, p_code); 842 if p_code ^= 0 843 then return; 844 if position_info.any_tag 845 then tag_match = "1"b; 846 else call set_tag_match (position.aep, position_info.default_search_tag, tag_match); 847 848 if ^tag_match 849 then 850 do; 851 call go_to_next_entry (position, p_code); 852 if p_code ^= 0 853 then return; 854 end; 855 856 position.entry_number = 1; 857 position.search_tag = position_info.default_search_tag; 858 p_position = position; 859 p_code = 0; 860 end go_to_first_entry; 861 862 set_tag_match: 863 proc (p_ptr, p_search_tag, p_tag_match); 864 dcl p_ptr ptr; 865 dcl p_search_tag char (32) varying; 866 dcl p_tag_match bit (1); 867 868 p_tag_match = (substr (p_ptr -> audit_entry.tag, 1, length (p_search_tag)) = p_search_tag); 869 end set_tag_match; 870 871 validate_entry: 872 proc (p_position, p_code); 873 /* parameters */ 874 dcl 1 p_position like position_template; /* input */ 875 dcl p_code fixed bin (35); /* input/output */ 876 877 /* begin coding */ 878 p_code = 0; 879 880 if p_position.aep -> audit_entry.tag = "" 881 then p_code = error_table_$bad_file; 882 883 return; 884 885 end validate_entry; 886 1 1 /* ****************************************************** 1 2* * * 1 3* * * 1 4* * Copyright (c) 1972 by Massachusetts Institute of * 1 5* * Technology and Honeywell Information Systems, Inc. * 1 6* * * 1 7* * * 1 8* ****************************************************** */ 1 9 1 10 /* BEGIN INCLUDE FILE audit_entry.incl.pl1 */ 1 11 1 12 /* 1 13* This structure is the format of an entry in the audit file. It is not intended to be 1 14* allocated, but overlayed (note the 0 refer for string). 1 15* 1 16* 12/08/78 Written by Lindsey L. Spratt 1 17* 1 18**/ 1 19 1 20 dcl impossible_audit_entry_length fixed bin (24) aligned static init (9999999) options (constant), 1 21 audit_entry_header_length fixed bin aligned static init (32) options (constant); 1 22 1 23 dcl aep ptr; 1 24 dcl 1 audit_entry aligned based (aep), 1 25 2 time fixed bin (71), /* Value is either time of day of entry, or -1. */ 1 26 2 virtual_time fixed bin (71), /* Virtual cpu time from this entry to the next. */ 1 27 2 paging fixed bin (24), /* Paging from this entry to the next. */ 1 28 2 last_entry_length fixed bin (24), /* Length of last entry's string. */ 1 29 2 entry_length fixed bin (24), /* Length of this entry's string. */ 1 30 2 tag char (2), /* Denotes class of entry (e.g., "IL"). */ 1 31 2 string char (0 refer (audit_entry.entry_length)); /* Text of this entry. */ 1 32 1 33 /* END INCLUDE FILE audit_entry.incl.pl1 */ 887 2 1 /* BEGIN INCLUDE FILE audit_position.incl.pl1 */ 2 2 2 3 2 4 2 5 /* 2 6* 12/08/78 Written by Lindsey L. Spratt 2 7**/ 2 8 2 9 /* format: style2 */ 2 10 dcl 1 position_template, 2 11 2 aep ptr, /* points to an entry. Base of audit_entry struc. */ 2 12 2 char_index fixed bin (24), /* Offset in bytes in audit_file of aep. */ 2 13 2 entry_number fixed bin (35), /* Count of entry from beginning of file. */ 2 14 2 search_tag char (32) varying, /* Search tag in effect when this entry found. */ 2 15 2 component_ptr ptr, /* Points to component of audit_file containing entry. */ 2 16 2 component_number fixed bin, /* NUmber of component containing entry. */ 2 17 2 component_max_char_index 2 18 fixed bin (24); /* Max allowed byte offset in current component. */ 2 19 2 20 2 21 dcl 1 position_info_template, 2 22 2 max_component fixed bin (17), /* Max allowed component number of audit_file. */ 2 23 2 max_index fixed bin (24), /* Max possible byte offset in max component. */ 2 24 2 current_component fixed bin (17), /* Component currently in use by audit_. */ 2 25 2 audit_fcb ptr, /* File control block pointer for audit_file. */ 2 26 2 audit_ptr ptr, /* Points to audit_file component currently in use by audit. */ 2 27 2 audit_index fixed bin (24), /* Byte offset in current component of next entry by audit_. */ 2 28 2 last_entry_length fixed bin (24), /* Length of last entry made by audit_. */ 2 29 2 begin_index fixed bin (24), /* Byte offset in begin component of begining of file. */ 2 30 2 begin_component fixed bin (17), /* Component containing beginning of file. */ 2 31 2 dirname char (168), /* Directory name of audit file. */ 2 32 2 ename char (32), /* Entry name of audit file. */ 2 33 2 file_limit bit (1), /* Indicates the audit_file is of limited size. */ 2 34 2 default_search_tag char (32) varying, /* Is the search_tag to use in looking at entries. */ 2 35 2 any_tag bit (1); /* Says to ignore the tags of the entries. */ 2 36 2 37 2 38 /* END INCLUDE FILE audit_position.incl.pl1 */ 888 3 1 /* ****************************************************** 3 2* * * 3 3* * * 3 4* * Copyright (c) 1972 by Massachusetts Institute of * 3 5* * Technology and Honeywell Information Systems, Inc. * 3 6* * * 3 7* * * 3 8* ****************************************************** */ 3 9 3 10 /* BEGIN INCLUDE FILE audit_file_header.incl.pl1 */ 3 11 3 12 /* 3 13* This structure is recorded in the audit_file starting at byte 0. It describes 3 14* the length of the file, the length of the last entry string and where the 3 15* beginning of the file is. 3 16* 3 17* Written 09/12/78 by Lindsey Spratt 3 18* Modified: 3 19* 01/15/79 by Lindsey L. Spratt to align structure, increase size 3 20* of byte offset variables to fixed bin(24), and add 3 21* pad1 and pad2. 3 22**/ 3 23 3 24 dcl audit_file_header_length fixed bin init (64) options (constant) int static; 3 25 dcl audit_file_header_version_1 fixed bin init (1) options (constant) int static; 3 26 dcl audit_file_header_ptr ptr; 3 27 dcl 1 audit_file_header based (audit_file_header_ptr) aligned, 3 28 2 version fixed bin (17), 3 29 2 audit_index fixed bin (24), /* The offset in bytes of where the next entry would start. */ 3 30 2 current_component fixed bin (17), /* The largest component number used. */ 3 31 2 begin_index fixed bin (24), /* The byte offset of the beginning of the file. */ 3 32 2 begin_component fixed bin (17), /* Component containing beginning of file. */ 3 33 2 max_index fixed bin (24), /* Byte offset of the largest possible position. */ 3 34 2 max_component fixed bin (17), /* Component containing largest possible position. */ 3 35 2 last_entry_length fixed bin (24), /* The length of the last entry string. */ 3 36 2 filled bit (1) unal, 3 37 2 unused1 bit (35) unal, 3 38 2 pad2 (7) fixed bin (35); 3 39 3 40 3 41 /* END INCLUDE FILE audit_file_header.incl.pl1 */ 889 890 end audit_file_position_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 09/15/88 1341.2 audit_file_position_.pl1 >spec>install>1110>audit_file_position_.pl1 887 1 05/03/79 1513.2 audit_entry.incl.pl1 >ldd>include>audit_entry.incl.pl1 888 2 05/18/81 1556.5 audit_position.incl.pl1 >ldd>include>audit_position.incl.pl1 889 3 05/03/79 1513.2 audit_file_header.incl.pl1 >ldd>include>audit_file_header.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. MAXIMUM_NUMBER_OF_ENTRIES_POSSIBLE 000001 constant fixed bin(35,0) initial dcl 120 ref 234 240 246 284 313 355 358 373 376 411 500 543 639 abs builtin function dcl 132 ref 168 add 000124 automatic bit(1) packed unaligned dcl 114 set ref 159* 167* 170* 175* 180 218* 224* 231* 234 addr builtin function dcl 132 ref 306 306 306 306 491 630 751 839 addrel builtin function dcl 132 ref 306 306 aep automatic pointer dcl 1-23 in procedure "audit_file_position_" ref 548 597 625 aep 000420 automatic pointer level 2 in structure "position" dcl 392 in procedure "go_to_next_entry" set ref 415 415 491* 498* aep 000102 automatic pointer level 2 in structure "position" dcl 104 in procedure "audit_file_position_" set ref 223 228 234 240 284 306 306 306 373 aep based pointer level 2 in structure "p_position" dcl 103 in procedure "audit_file_position_" set ref 284 373 aep 000570 automatic pointer level 2 in structure "position" dcl 780 in procedure "go_to_first_entry" set ref 839* 846* aep parameter pointer level 2 in structure "p_position" dcl 874 in procedure "validate_entry" ref 880 aep 000500 automatic pointer level 2 in structure "position" dcl 527 in procedure "go_to_previous_entry" set ref 548 548 597 597 625 625 630* 637* aep 000534 automatic pointer level 2 in structure "position" dcl 667 in procedure "go_to_last_entry" set ref 751* 761* any_tag 110 based bit(1) level 2 packed packed unaligned dcl 105 ref 384 496 635 759 844 audit_entry based structure level 1 dcl 1-24 set ref 415 415 548 597 625 audit_entry_header_length constant fixed bin(17,0) initial dcl 1-20 ref 739 746 audit_fcb 4 based pointer level 2 dcl 105 set ref 469* 477* 569* 606* 689* 703* 806* audit_file_header based structure level 1 dcl 3-27 ref 452 452 557 557 684 684 739 739 audit_file_header_ptr automatic pointer dcl 3-26 ref 452 452 557 557 684 684 739 739 audit_index 10 based fixed bin(24,0) level 2 dcl 105 ref 428 451 463 594 684 699 719 719 737 739 739 746 801 820 837 audit_ptr 6 based pointer level 2 dcl 105 ref 427 462 595 716 801 begin_component 13 based fixed bin(17,0) level 2 dcl 105 ref 536 543 719 719 795 798 801 820 820 begin_index 12 based fixed bin(24,0) level 2 dcl 105 ref 536 543 719 799 801 818 820 bin builtin function dcl 132 ref 145 145 145 207 207 207 bit_count24 000523 automatic fixed bin(24,0) dcl 530 in procedure "go_to_previous_entry" set ref 569* 579* 586 606* 615* 622 bit_count24 000465 automatic fixed bin(24,0) dcl 395 in procedure "go_to_next_entry" set ref 432* 439* 446 469* 477* 486 bit_count24 000614 automatic fixed bin(24,0) dcl 783 in procedure "go_to_first_entry" set ref 806* 826* 833 bit_count24 000556 automatic fixed bin(24,0) dcl 669 in procedure "go_to_last_entry" set ref 689* 703* 726* 733 char_index 2 000420 automatic fixed bin(24,0) level 2 in structure "position" dcl 392 in procedure "go_to_next_entry" set ref 404 411 415* 415 419 452* 461* 468* 476* 491 char_index 2 000534 automatic fixed bin(24,0) level 2 in structure "position" dcl 667 in procedure "go_to_last_entry" set ref 739* 746* 751 char_index 2 000500 automatic fixed bin(24,0) level 2 in structure "position" dcl 527 in procedure "go_to_previous_entry" set ref 536 543 548* 548 557 597* 602 625* 630 char_index 2 000570 automatic fixed bin(24,0) level 2 in structure "position" dcl 780 in procedure "go_to_first_entry" set ref 799* 818* 839 char_index 2 000442 automatic fixed bin(24,0) level 2 in structure "last_position" dcl 393 in procedure "go_to_next_entry" set ref 404 411 code 000522 automatic fixed bin(35,0) dcl 529 in procedure "go_to_previous_entry" set ref 532* 569* 572 575 579* 580 583 606* 609 612 615* 616 619 code 000130 automatic fixed bin(35,0) dcl 118 in procedure "audit_file_position_" set ref 139* 157* 180 183* 185 187* 189 189 193 196 205* 216* 234 238* 240 243* 246* 249 249 253 256 278* 287* 289* 290 290 294* 295* 297* 298 303 306* 309 313* 316 318 318* 321 327* 333* 339* 345* 351* 368* code 000560 automatic fixed bin(35,0) dcl 671 in procedure "go_to_last_entry" set ref 677* 689* 692 695 703* 706 709 726* 727 730 765* 766 769 code 000612 automatic fixed bin(35,0) dcl 781 in procedure "go_to_first_entry" set ref 785* 806* 809 812 826* 827 830 code 000464 automatic fixed bin(35,0) dcl 394 in procedure "go_to_next_entry" set ref 398* 402* 432* 433 436 439* 440 443 469* 477* 480 483 component_max_char_index 21 000534 automatic fixed bin(24,0) level 2 in structure "position" dcl 667 in procedure "go_to_last_entry" set ref 733* 734* 734 734 737* 739 751 component_max_char_index 21 000500 automatic fixed bin(24,0) level 2 in structure "position" dcl 527 in procedure "go_to_previous_entry" set ref 586* 587* 587 587 594* 597 622* 623* 623 623 625 630 component_max_char_index 21 000420 automatic fixed bin(24,0) level 2 in structure "position" dcl 392 in procedure "go_to_next_entry" set ref 419 428* 446* 447* 447 447 451* 463* 472* 486* 487* 487 487 491 component_max_char_index 21 000570 automatic fixed bin(24,0) level 2 in structure "position" dcl 780 in procedure "go_to_first_entry" set ref 833* 834* 834 834 837* 839 component_number 20 000420 automatic fixed bin(17,0) level 2 in structure "position" dcl 392 in procedure "go_to_next_entry" set ref 404 411 419 426* 457* 457 458 465 469* 477* component_number 20 000570 automatic fixed bin(17,0) level 2 in structure "position" dcl 780 in procedure "go_to_first_entry" set ref 795 798* 806* component_number 20 000534 automatic fixed bin(17,0) level 2 in structure "position" dcl 667 in procedure "go_to_last_entry" set ref 688* 689* 702* 703* 715* component_number 20 000500 automatic fixed bin(17,0) level 2 in structure "position" dcl 527 in procedure "go_to_previous_entry" set ref 536 543 557 565 568* 569* 593* 605* 605 606* component_number 20 000442 automatic fixed bin(17,0) level 2 in structure "last_position" dcl 393 in procedure "go_to_next_entry" set ref 404 411 component_ptr 16 000570 automatic pointer level 2 in structure "position" dcl 780 in procedure "go_to_first_entry" set ref 801* 806* 826* 839 component_ptr 16 000534 automatic pointer level 2 in structure "position" dcl 667 in procedure "go_to_last_entry" set ref 689* 703* 716* 726* 751 component_ptr 16 000500 automatic pointer level 2 in structure "position" dcl 527 in procedure "go_to_previous_entry" set ref 569* 579* 595* 606* 615* 630 component_ptr 16 000420 automatic pointer level 2 in structure "position" dcl 392 in procedure "go_to_next_entry" set ref 427* 432* 439* 462* 469* 477* 491 continue 000234 automatic bit(1) initial packed unaligned dcl 266 set ref 266* 284 298* 309* current_component 2 based fixed bin(17,0) level 2 dcl 105 ref 428 458 593 702 715 719 719 801 820 820 currentsize builtin function dcl 132 ref 415 415 default_search_tag 77 based varying char(32) level 2 dcl 105 set ref 154 498* 510 637* 649 761* 846* 857 divide builtin function dcl 132 ref 446 486 586 622 733 833 do_first_entry 000237 automatic bit(1) packed unaligned dcl 269 set ref 283* 284 286* entry_idx 000126 automatic fixed bin(35,0) dcl 116 in procedure "audit_file_position_" set ref 234* 240* 246 284* 313 355* 358 373* 376 entry_idx 000416 automatic fixed bin(35,0) dcl 390 in procedure "go_to_next_entry" set ref 411* 500 entry_idx 000477 automatic fixed bin(35,0) dcl 526 in procedure "go_to_previous_entry" set ref 543* 639 entry_length 6 based fixed bin(24,0) level 2 dcl 1-24 ref 306 306 306 415 415 entry_number 3 000420 automatic fixed bin(35,0) level 2 in structure "position" dcl 392 in procedure "go_to_next_entry" set ref 510 510* 510 514* entry_number 3 000534 automatic fixed bin(35,0) level 2 in structure "position" dcl 667 in procedure "go_to_last_entry" set ref 753* entry_number 3 000570 automatic fixed bin(35,0) level 2 in structure "position" dcl 780 in procedure "go_to_first_entry" set ref 856* entry_number 3 000102 automatic fixed bin(35,0) level 2 in structure "position" dcl 104 in procedure "audit_file_position_" set ref 154 163 entry_number 3 000500 automatic fixed bin(35,0) level 2 in structure "position" dcl 527 in procedure "go_to_previous_entry" set ref 649 649* 649 653* entry_number 000127 automatic fixed bin(17,0) dcl 117 in procedure "audit_file_position_" set ref 180* 185* error_table_$bad_file 000010 external static fixed bin(35,0) dcl 106 ref 246 313 358 379 503 642 880 error_table_$empty_file 000012 external static fixed bin(35,0) dcl 107 ref 681 791 error_table_$end_of_info 000014 external static fixed bin(35,0) dcl 109 ref 189 249 290 361 407 520 539 661 error_table_$inconsistent 000020 external static fixed bin(35,0) dcl 123 ref 148 210 error_table_$nomatch 000016 external static fixed bin(35,0) dcl 111 ref 318 file_char_array based char(1) array packed unaligned dcl 668 in procedure "go_to_last_entry" set ref 751 file_char_array based char(1) array packed unaligned dcl 396 in procedure "go_to_next_entry" set ref 491 file_char_array based char(1) array packed unaligned dcl 784 in procedure "go_to_first_entry" set ref 839 file_char_array based char(1) array packed unaligned dcl 531 in procedure "go_to_previous_entry" set ref 630 file_limit 76 based bit(1) level 2 packed packed unaligned dcl 105 ref 562 684 719 739 820 820 forward 000233 automatic bit(1) initial packed unaligned dcl 266 set ref 266* 276* 287 295 hcs_$status_mins 000024 constant entry external dcl 127 ref 432 439 579 615 726 826 impossible_audit_entry_length 000000 constant fixed bin(24,0) initial dcl 1-20 ref 678 last_entry_length 11 based fixed bin(24,0) level 2 in structure "position_info" dcl 105 in procedure "audit_file_position_" ref 678 739 739 746 746 788 last_entry_length 5 based fixed bin(24,0) level 2 in structure "audit_entry" dcl 1-24 in procedure "audit_file_position_" ref 548 548 597 597 625 625 last_position 000442 automatic structure level 1 unaligned dcl 393 set ref 401* 402* length builtin function dcl 132 ref 306 306 868 match_begin 000235 automatic fixed bin(21,0) dcl 267 set ref 306* match_end 000236 automatic fixed bin(21,0) dcl 267 set ref 306* match_str 000132 automatic varying char(256) dcl 264 set ref 281* 306 306 306 306 311* max_component based fixed bin(17,0) level 2 dcl 105 ref 419 423 465 565 568 688 max_index 1 based fixed bin(24,0) level 2 dcl 105 ref 472 mod builtin function dcl 132 ref 415 447 452 487 548 557 587 597 623 625 684 734 739 739 746 834 msf_manager_$get_ptr 000026 constant entry external dcl 128 ref 469 477 569 606 689 703 806 number 000125 automatic fixed bin(17,0) dcl 115 set ref 158* 163* 164 168* 168 176* 180 185 p_abs parameter bit(1) packed unaligned dcl 112 ref 135 145 151 202 207 213 p_add parameter bit(1) packed unaligned dcl 112 ref 135 145 175 202 207 220 p_code parameter fixed bin(35,0) dcl 875 in procedure "validate_entry" set ref 871 878* 880* p_code parameter fixed bin(35,0) dcl 118 in procedure "audit_file_position_" set ref 135 139* 148* 193* 196* 202 205* 210* 253* 256* 262 273 278* 303* 321* 325 327* 328* 331 333* 334* 337 339* 340* 343 345* 346* 349 351* 352* 353 355 356* 358* 361 361* 366 368* 370* 371 374* 379* p_code parameter fixed bin(35,0) dcl 671 in procedure "go_to_last_entry" set ref 664 677* 681* 695* 709* 730* 755* 756 769* 773* p_code parameter fixed bin(35,0) dcl 529 in procedure "go_to_previous_entry" set ref 523 532* 539* 575* 583* 612* 619* 632* 633 642* 658* 661* p_code parameter fixed bin(35,0) dcl 394 in procedure "go_to_next_entry" set ref 388 398* 407* 436* 443* 483* 493* 494 503* 518* 520* p_code parameter fixed bin(35,0) dcl 781 in procedure "go_to_first_entry" set ref 777 785* 791* 812* 830* 841* 842 851* 852 859* p_match_str parameter varying char(256) dcl 264 ref 262 273 281 p_number parameter fixed bin(17,0) dcl 115 ref 135 158 163 176 p_position parameter structure level 1 unaligned dcl 666 in procedure "go_to_last_entry" set ref 664 774* p_position parameter structure level 1 unaligned dcl 391 in procedure "go_to_next_entry" set ref 388 400 401 517* p_position parameter structure level 1 unaligned dcl 528 in procedure "go_to_previous_entry" set ref 523 534 657* p_position parameter structure level 1 unaligned dcl 779 in procedure "go_to_first_entry" set ref 777 786 858* p_position parameter structure level 1 unaligned dcl 874 in procedure "validate_entry" ref 871 p_position based structure level 1 unaligned dcl 103 in procedure "audit_file_position_" set ref 138 197* 204 257* 280 316* 328* 334* 340* 346* 352* 356* 369 383* p_position_info_ptr parameter pointer dcl 100 ref 135 154 202 262 273 325 331 337 343 349 366 384 419 423 427 428 428 451 458 462 463 465 469 472 477 496 498 510 536 536 543 543 562 565 568 569 593 594 595 606 635 637 649 678 684 684 688 689 699 702 703 715 716 719 719 719 719 719 719 719 719 737 739 739 739 739 739 746 746 746 759 761 788 795 798 799 801 801 801 801 801 806 818 820 820 820 820 820 820 820 820 837 844 846 857 p_position_ptr parameter pointer dcl 100 ref 135 138 197 202 204 257 262 273 280 284 316 325 328 331 334 337 340 343 346 349 352 356 366 369 373 383 384 p_ptr parameter pointer dcl 864 ref 862 868 p_search_tag parameter varying char(32) dcl 865 ref 862 868 868 p_subtract parameter bit(1) packed unaligned dcl 112 ref 135 145 202 207 p_tag_match parameter bit(1) packed unaligned dcl 866 set ref 862 868* p_time parameter fixed bin(71,0) dcl 102 ref 202 217 223 228 position 000500 automatic structure level 1 unaligned dcl 527 in procedure "go_to_previous_entry" set ref 534* 632* 657 position 000102 automatic structure level 1 unaligned dcl 104 in procedure "audit_file_position_" set ref 138* 157* 183* 187* 197 204* 216* 238* 243* 257 280* 287* 289* 295* 297* 316 369* 370* 374* 383 position 000420 automatic structure level 1 unaligned dcl 392 in procedure "go_to_next_entry" set ref 400* 493* 517 position 000570 automatic structure level 1 unaligned dcl 780 in procedure "go_to_first_entry" set ref 786* 841* 851* 858 position 000534 automatic structure level 1 unaligned dcl 667 in procedure "go_to_last_entry" set ref 755* 765* 774 position_info based structure level 1 unaligned dcl 105 position_info_template 000262 automatic structure level 1 unaligned dcl 2-21 position_template 000240 automatic structure level 1 unaligned dcl 2-10 search_file_ 000022 constant entry external dcl 125 ref 306 search_tag 4 000570 automatic varying char(32) level 2 in structure "position" dcl 780 in procedure "go_to_first_entry" set ref 857* search_tag 4 000534 automatic varying char(32) level 2 in structure "position" dcl 667 in procedure "go_to_last_entry" set ref 754* search_tag 4 based varying char(32) level 2 in structure "p_position" dcl 103 in procedure "audit_file_position_" set ref 384* search_tag 4 000420 automatic varying char(32) level 2 in structure "position" dcl 392 in procedure "go_to_next_entry" set ref 510 515* search_tag 4 000500 automatic varying char(32) level 2 in structure "position" dcl 527 in procedure "go_to_previous_entry" set ref 649 654* search_tag 4 000102 automatic varying char(32) level 2 in structure "position" dcl 104 in procedure "audit_file_position_" set ref 154 size builtin function dcl 132 ref 452 452 548 557 557 597 625 684 684 739 739 string 10 based char level 2 dcl 1-24 set ref 306 306 substr builtin function dcl 132 ref 868 tag 7 based char(2) level 2 dcl 1-24 ref 868 880 tag_match 000466 automatic bit(1) packed unaligned dcl 397 in procedure "go_to_next_entry" set ref 399* 411 496* 498* 507 tag_match 000613 automatic bit(1) packed unaligned dcl 782 in procedure "go_to_first_entry" set ref 844* 846* 848 tag_match 000476 automatic bit(1) packed unaligned dcl 525 in procedure "go_to_previous_entry" set ref 533* 543 635* 637* 646 tag_match 000557 automatic bit(1) packed unaligned dcl 670 in procedure "go_to_last_entry" set ref 759* 761* 762 time 000100 automatic fixed bin(71,0) dcl 102 in procedure "audit_file_position_" set ref 217* 223* 228* 229 229* 234 240 time based fixed bin(71,0) level 2 in structure "audit_entry" dcl 1-24 in procedure "audit_file_position_" ref 223 228 234 240 type 000131 automatic fixed bin(2,0) dcl 119 set ref 432* 439* 579* 615* 726* 826* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. audit_file_header_length internal static fixed bin(17,0) initial dcl 3-24 audit_file_header_version_1 internal static fixed bin(17,0) initial dcl 3-25 NAMES DECLARED BY EXPLICIT CONTEXT. START 000537 constant label dcl 278 ref 271 audit_file_position_ 000033 constant entry external dcl 22 backward_search 000523 constant entry external dcl 273 count_last 001121 constant entry external dcl 349 first 001035 constant entry external dcl 337 forward_search 000505 constant entry external dcl 262 go_to_first_entry 003027 constant entry internal dcl 777 ref 157 216 295 340 352 370 go_to_last_entry 002466 constant entry internal dcl 664 ref 297 346 402 go_to_next_entry 001334 constant entry internal dcl 388 ref 183 238 287 328 356 374 851 go_to_previous_entry 002003 constant entry internal dcl 523 ref 187 243 289 334 765 last 001067 constant entry external dcl 343 move_number 000050 constant entry external dcl 135 move_time 000266 constant entry external dcl 202 next 000751 constant entry external dcl 325 previous 001003 constant entry external dcl 331 set_count 001220 constant entry external dcl 366 set_tag_match 003312 constant entry internal dcl 862 ref 498 637 761 846 validate_entry 003333 constant entry internal dcl 871 ref 493 632 755 841 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3610 3640 3373 3620 Length 4132 3373 30 255 214 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME audit_file_position_ 519 external procedure is an external procedure. go_to_next_entry internal procedure shares stack frame of external procedure audit_file_position_. go_to_previous_entry internal procedure shares stack frame of external procedure audit_file_position_. go_to_last_entry internal procedure shares stack frame of external procedure audit_file_position_. go_to_first_entry internal procedure shares stack frame of external procedure audit_file_position_. set_tag_match internal procedure shares stack frame of external procedure audit_file_position_. validate_entry internal procedure shares stack frame of external procedure audit_file_position_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME audit_file_position_ 000100 time audit_file_position_ 000102 position audit_file_position_ 000124 add audit_file_position_ 000125 number audit_file_position_ 000126 entry_idx audit_file_position_ 000127 entry_number audit_file_position_ 000130 code audit_file_position_ 000131 type audit_file_position_ 000132 match_str audit_file_position_ 000233 forward audit_file_position_ 000234 continue audit_file_position_ 000235 match_begin audit_file_position_ 000236 match_end audit_file_position_ 000237 do_first_entry audit_file_position_ 000240 position_template audit_file_position_ 000262 position_info_template audit_file_position_ 000416 entry_idx go_to_next_entry 000420 position go_to_next_entry 000442 last_position go_to_next_entry 000464 code go_to_next_entry 000465 bit_count24 go_to_next_entry 000466 tag_match go_to_next_entry 000476 tag_match go_to_previous_entry 000477 entry_idx go_to_previous_entry 000500 position go_to_previous_entry 000522 code go_to_previous_entry 000523 bit_count24 go_to_previous_entry 000534 position go_to_last_entry 000556 bit_count24 go_to_last_entry 000557 tag_match go_to_last_entry 000560 code go_to_last_entry 000570 position go_to_first_entry 000612 code go_to_first_entry 000613 tag_match go_to_first_entry 000614 bit_count24 go_to_first_entry THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_out return_mac bound_ck_signal mdfx1 ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. hcs_$status_mins msf_manager_$get_ptr search_file_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_file error_table_$empty_file error_table_$end_of_info error_table_$inconsistent error_table_$nomatch LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 266 000025 22 000032 24 000041 135 000042 138 000063 139 000071 145 000073 148 000126 149 000131 151 000132 154 000134 157 000146 158 000150 159 000154 160 000156 163 000157 164 000165 167 000166 168 000167 169 000173 170 000174 172 000176 175 000177 176 000201 180 000203 183 000217 184 000221 185 000224 187 000235 188 000237 189 000241 193 000246 194 000247 196 000250 197 000251 198 000257 202 000260 204 000301 205 000307 207 000311 210 000344 211 000347 213 000350 216 000352 217 000354 218 000357 219 000361 220 000362 223 000364 224 000367 225 000371 228 000372 229 000375 231 000400 234 000401 238 000420 239 000422 240 000430 243 000444 244 000446 246 000453 249 000461 253 000466 254 000467 256 000470 257 000471 259 000477 262 000500 271 000520 273 000521 276 000536 278 000537 280 000541 281 000547 283 000555 284 000557 286 000601 287 000602 289 000607 290 000611 294 000616 295 000617 297 000624 298 000626 300 000631 303 000632 304 000633 306 000634 309 000704 311 000711 312 000712 313 000717 316 000725 318 000736 321 000743 322 000744 325 000745 327 000764 328 000766 329 001000 331 001001 333 001016 334 001020 335 001032 337 001033 339 001050 340 001052 341 001064 343 001065 345 001102 346 001104 347 001116 349 001117 351 001134 352 001136 353 001150 355 001152 356 001163 357 001175 358 001202 361 001210 363 001215 366 001216 368 001233 369 001235 370 001243 371 001253 373 001255 374 001273 375 001303 376 001310 379 001313 380 001316 383 001317 384 001325 386 001333 388 001334 398 001336 399 001340 400 001341 401 001345 402 001350 404 001352 407 001360 408 001364 411 001365 415 001406 419 001426 423 001434 426 001436 427 001437 428 001442 432 001447 433 001464 436 001466 437 001470 439 001471 440 001506 443 001510 444 001512 446 001513 447 001516 450 001526 451 001527 452 001533 454 001542 457 001543 458 001544 461 001550 462 001551 463 001553 464 001556 465 001557 468 001561 469 001562 472 001605 473 001611 476 001612 477 001613 480 001636 483 001640 484 001642 486 001643 487 001646 491 001656 493 001667 494 001700 496 001704 498 001714 499 001726 500 001733 503 001736 504 001742 507 001743 510 001746 514 001765 515 001766 517 001767 518 001774 519 001775 520 001776 521 002002 523 002003 532 002005 533 002007 534 002010 536 002014 539 002024 540 002027 543 002030 548 002052 557 002075 562 002110 565 002112 568 002115 569 002116 572 002141 575 002143 576 002145 579 002146 580 002163 583 002165 584 002167 586 002170 587 002173 589 002203 593 002204 594 002206 595 002211 597 002213 601 002230 602 002231 605 002233 606 002235 609 002260 612 002262 613 002264 615 002265 616 002302 619 002304 620 002306 622 002307 623 002312 625 002322 630 002337 632 002350 633 002361 635 002365 637 002375 638 002407 639 002414 642 002417 643 002423 646 002424 649 002427 653 002450 654 002451 657 002452 658 002457 659 002460 661 002461 662 002465 664 002466 677 002470 678 002472 681 002477 682 002502 684 002503 688 002517 689 002521 692 002544 695 002546 696 002550 698 002551 699 002552 702 002554 703 002557 706 002602 709 002604 710 002606 712 002607 715 002610 716 002612 719 002614 726 002631 727 002646 730 002650 731 002652 733 002653 734 002656 736 002666 737 002667 739 002671 746 002717 751 002734 753 002745 754 002746 755 002747 756 002760 759 002764 761 002774 762 003006 765 003011 766 003013 769 003015 770 003017 773 003020 774 003022 775 003026 777 003027 785 003031 786 003033 788 003037 791 003043 792 003046 795 003047 798 003052 799 003054 801 003056 806 003067 809 003112 812 003114 813 003116 816 003117 818 003120 820 003122 826 003142 827 003157 830 003161 831 003163 833 003164 834 003167 836 003177 837 003200 839 003202 841 003213 842 003224 844 003230 846 003240 848 003252 851 003255 852 003266 856 003272 857 003274 858 003303 859 003310 860 003311 862 003312 868 003314 869 003332 871 003333 878 003335 880 003336 883 003346 ----------------------------------------------------------- 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