COMPILATION LISTING OF SEGMENT menu_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 04/09/85 1209.7 mst Tue Options: optimize map 1 /* ****************************************************** 2* * * 3* * * 4* * Copyright (c) 1972 by Massachusetts Institute of * 5* * Technology and Honeywell Information Systems, Inc. * 6* * * 7* * * 8* ****************************************************** */ 9 10 menu_: 11 procedure; 12 return; 13 14 /* Subroutines for Menu Presentation. MTB - 493 15* 16* James R. Davis January - February 1981 17* 18* entries here: 19* 20* create 21* display 22* get_choice 23* describe 24* destroy 25* list 26* store 27* retrieve 28* 29**/ 30 31 /* 32* Maintained by Suzanne L. Krupp 33* 34* Modified 06/05/81 by Suzanne Krupp to include store_menu and retrieve_menu 35* entry points. 36* 37* Modified 06/29/81 to make store_menu and retrieve_menu entry points use 38* value segments (so that we can now store more than one menu 39* per segment. 40* 41* Modified 06/29/81 to fix bug in menu_$get_choice where it can't handle a 42* function_key_data_ptr. 43* 44* Modified by BIM July 1981 for to remove the _menu from the names, 45* fix up the value stuff, and add the delete and list entrypoints. 46* 47* Auditing changes BIM October 1981. 48* 49* Modified January 1981 by Chris Jones to make menus case-insensitive when possible. 50* 51* 84-03-15 Davids: Modified call to hcs_$initiate in the LIST procedure 52* to use the valiables dname and ename which are input to the LIST proc 53* instead of using P_dname and P_ename which are input to the list entry 54* which calls the LIST proc. A procedure should use its own parameters. 55* This answers TR15713. 56* 57* 84-09-18 Davids: Added calls to window_$sync after all calls to 58* window_$overwrite_text. These occur in the display_menu entry and in the 59* get_choice entry. This should prevent the pause that can occur when a menu 60* is being displayed and the long delay that can occur between the time the 61* user makes a selection and the time the selection is flaged with an asterix. 62* Also deleted declared but unreferenced variables. 63**/ 64 65 /* ***** INTERNAL REPRESENTATION OF A MENU ***** */ 66 67 declare 1 menu aligned based (menu_ptr), 68 2 version char (8) init (MENU_VERSION), 69 2 window_requirements, /* size of menu */ 70 3 height fixed bin, /* number of lines */ 71 3 width fixed bin, 72 2 n_options fixed bin, 73 2 flags unaligned, 74 3 case_insensitive bit (1) unal, 75 3 mbz1 bit (17) unal, 76 2 asterixed_option fixed bin (17) unal, 77 /* or zero if none */ 78 2 option_info (61), /* max is 61 */ 79 3 key char (1) unal, 80 3 pad bit (27) unal, 81 3 line fixed bin, /* where to echo */ 82 3 col fixed bin, 83 2 lines (lines_alloc refer (menu.height)) unal char (chars_alloc refer (menu.width)); 84 85 declare menu_ptr pointer; 86 declare menu_segment_ptr ptr; 87 88 declare MENU_VERSION char (8) aligned internal static options (constant) init ("menu_v_3"); 89 90 declare lines_alloc fixed bin (21); 91 declare chars_alloc fixed bin (21); 92 93 94 /* Parameters of the various entries */ 95 96 declare ( 97 P_choices (*) char (*) varying, 98 P_create_sw bit (1) aligned, 99 P_dname char (*), 100 P_ename char (*), 101 P_menu_name char (*), 102 P_headers (*) char (*) varying, 103 P_trailers (*) char (*) varying, 104 P_format_ptr pointer, 105 P_keys (*) char (1) unal, 106 P_areap pointer, 107 P_needs_ptr pointer, 108 P_menu_ptr pointer, 109 P_code fixed bin (35), 110 P_window pointer, 111 P_function_key_info_ptr 112 pointer, 113 P_fkeyp bit (1) aligned, 114 P_selection fixed bin, 115 P_starname character (*), 116 P_list_ptr pointer, 117 P_mli_version fixed bin 118 ) parameter; 119 120 declare ( 121 error_table_$unimplemented_version, 122 error_table_$noentry 123 ) fixed bin (35) external static; 124 125 declare created_sw bit (1) aligned; 126 127 declare (addr, copy, currentsize, dimension, divide, hbound, index, length, lbound, max, mod, null, sign) 128 builtin; 129 130 declare add_char_offset_ entry (pointer, fixed bin (21)) returns (pointer) reducible; 131 declare get_system_free_area_ entry () returns (ptr); 132 declare get_user_free_area_ entry () returns (pointer); 133 declare hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, 134 fixed bin (35)); 135 declare hcs_$terminate_noname entry (ptr, fixed bin (35)); 136 declare hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); 137 declare value_$init_seg entry (ptr, fixed bin, ptr, fixed bin (19), fixed bin (35)); 138 declare value_$get_data entry (ptr, bit (36) aligned, char (*), ptr, ptr, fixed bin (18), fixed bin (35)) 139 ; 140 declare value_$set_data entry (ptr, bit (36) aligned, char (*), ptr, fixed bin (18), ptr, ptr, 141 fixed bin (18), fixed bin (35)); 142 declare value_$list_data_names entry (pointer, bit (36) aligned, pointer, pointer, pointer, fixed binary (35)); 143 144 145 declare cleanup condition; 146 147 create_menu: 148 create: 149 entry (P_choices, P_headers, P_trailers, P_format_ptr, P_keys, P_areap, P_needs_ptr, P_menu_ptr, P_code); 150 common_create: 151 begin; 152 declare n_choices fixed bin; 153 declare (header_ct, menu_ct, trailer_ct) 154 fixed bin; /* lines devoted to each */ 155 declare menu_et_$too_few_keys fixed bin (35) ext static; 156 declare menu_et_$higher_than_max 157 fixed bin (35) external static; 158 declare menu_et_$too_many_options 159 fixed bin (35) ext static; 160 declare menu_et_$keys_not_unique 161 fixed bin (35) ext static; 162 163 P_code = 0; 164 P_menu_ptr = null (); 165 menu_format_ptr = P_format_ptr; 166 menu_requirements_ptr = P_needs_ptr; 167 n_choices = dimension (P_choices, 1); 168 169 /* check validity of parms */ 170 if menu_format.version ^= menu_format_version_1 | menu_requirements.version ^= menu_requirements_version_1 171 then call ERROR (error_table_$unimplemented_version); 172 if menu_format.pad ^= "0"b 173 then call ERROR (error_table_$unimplemented_version); 174 if n_choices = 0 /* Perhaps this should be an error? */ 175 then ; /* nothing to display */ 176 if n_choices > dimension (P_keys, 1) 177 then call ERROR (menu_et_$too_few_keys); 178 if n_choices > hbound (menu.option_info, 1) 179 then call ERROR (menu_et_$too_many_options); 180 if ^all_keys_unique (n_choices) 181 then call ERROR (menu_et_$keys_not_unique); 182 183 /* parms look good, now calculate size of screen image so we can allocate it */ 184 header_ct = sign (length (P_headers (1))) * dimension (P_headers, 1); 185 menu_ct = divide (n_choices, menu_format.n_columns, 17) + sign (mod (n_choices, menu_format.n_columns)); 186 trailer_ct = sign (length (P_trailers (1))) * dimension (P_trailers, 1); 187 lines_alloc = header_ct + menu_ct + trailer_ct; 188 189 if menu_format.max_height > 0 190 then if lines_alloc > menu_format.max_height 191 then call ERROR (menu_et_$higher_than_max); 192 193 chars_alloc = menu_format.max_width; 194 195 begin; 196 declare based_area area based (areap); 197 declare areap ptr; 198 199 if P_areap ^= null 200 then areap = P_areap; 201 else areap = get_system_free_area_ (); 202 203 allocate menu in (based_area); 204 end; 205 206 /* now fill in data structure */ 207 208 menu.version = MENU_VERSION; 209 menu.height = lines_alloc; 210 menu.width = chars_alloc; 211 menu.n_options = n_choices; 212 menu.flags = ""b; 213 menu.case_insensitive = not_mixed_cases (n_choices); 214 menu.asterixed_option = 0; 215 216 menu.lines (*) = " "; 217 call format_screen (); 218 P_menu_ptr = menu_ptr; 219 220 call fill_requirements_from_menu (); 221 222 return; 223 224 all_keys_unique: 225 procedure (kc) returns (bit (1) aligned); 226 declare kc fixed bin parameter; 227 /* how many matter */ 228 declare i fixed bin; 229 declare (index, substr) builtin; 230 declare key_overlay char (kc) defined (P_keys); 231 do i = 1 to kc - 1; 232 if index (substr (key_overlay, kc + 1), P_keys (i)) > 0 233 then return ("0"b); /* a match ! */ 234 end; 235 return ("1"b); 236 end all_keys_unique; 237 238 not_mixed_cases: 239 proc (kc) returns (bit (1) unal); 240 241 dcl kc fixed bin; 242 243 dcl key_overlay char (kc) defined (P_keys); 244 dcl UPPER_CASE_LETTERS char (26) init ("ABCDEFGHIJKLMNOPQRSTUVWXYZ") internal static options (constant); 245 dcl LOWER_CASE_LETTERS char (26) init ("abcdefghijklmnopqrstuvwxyz") internal static options (constant); 246 247 if (search (key_overlay, UPPER_CASE_LETTERS) = 0) & (search (key_overlay, LOWER_CASE_LETTERS) = 0) 248 then return ("0"b); 249 if (search (key_overlay, UPPER_CASE_LETTERS) ^= 0) & (search (key_overlay, LOWER_CASE_LETTERS) ^= 0) 250 then return ("0"b); 251 return ("1"b); 252 253 end not_mixed_cases; 254 255 256 257 /* BUILD SCREEN IMAGE: 258* 259* +------------------------------------------------------+ -- 260* |_HEADER_ONE___________________________________________| header_ct = 2 261* |_HEADER_TWO___________________________________________| __ 262* |_(1)_choice_one_|_(3)_choice_three_|_(4)_choice four__| menu_ct = 2 263* |_(2)_choice_two_|__________________|__________________| __ 264* |_TRAILER______________________________________________| trailer_ct = 1 265* 266* <- chars_per_box -> 267* 268* choices are positioned as evenly as possible: never more than one extra 269* choice per column. The portion of the screen devoted to choices begins 270* at the "first_option_char"'th char of the display image (lines). The 271* choices are divided into "boxes". If the number of choices is a multiple 272* of the number of columns, the boxes are an array "n_columns" wide, and 273* choices/n_columns high. And if there is a remainder R, the first R columns 274* get an extra choice. 275* 276**/ 277 278 format_screen: 279 procedure; 280 declare i fixed bin; 281 declare (first_header_line, first_menu_line, first_trailer_line) 282 fixed bin; 283 declare chars_per_box fixed bin; 284 declare first_option_char fixed bin (21); 285 declare extra fixed bin; 286 287 first_header_line = 1; 288 first_menu_line = first_header_line + header_ct; 289 first_trailer_line = first_menu_line + menu_ct; 290 291 /* the headers and trailers are easy */ 292 do i = 1 to header_ct; 293 menu.lines (first_header_line + i - 1) = 294 format (P_headers (i), menu_format.center_headers, menu_format.pad_char, menu_format.max_width); 295 end; 296 do i = 1 to trailer_ct; 297 menu.lines (first_trailer_line + i - 1) = 298 format (P_trailers (i), menu_format.center_trailers, menu_format.pad_char, menu_format.max_width); 299 end; 300 301 chars_per_box = divide (menu_format.max_width, menu_format.n_columns, 17); 302 extra = mod (menu_format.max_width, menu_format.n_columns); 303 first_option_char = (header_ct * menu.width) + 1; 304 305 format_boxes: 306 begin; 307 declare 1 boxes (0:menu_ct - 1) defined (menu.lines) position (first_option_char), 308 2 row (0:menu_format.n_columns - 1), 309 3 constant, 310 4 lp char (2) unal,/* " (" */ 311 4 k char (1) unal,/* key image */ 312 4 rp char (2) unal,/* ") " */ 313 3 name char (chars_per_box - 5) unal, 314 2 pad char (extra) unal; 315 declare menu_line fixed bin; 316 declare menu_row fixed bin; 317 318 do i = 1 to hbound (P_choices, 1); 319 menu.option_info (i).key = P_keys (i); 320 call get_box_coords (i, menu_row, menu_line); 321 menu.option_info (i).line = first_menu_line + menu_line; 322 menu.option_info (i).col = 3 + menu_row * chars_per_box; 323 324 boxes (menu_line).row (menu_row).lp = " ("; 325 boxes (menu_line).row (menu_row).k = P_keys (i); 326 boxes (menu_line).row (menu_row).rp = ") "; 327 boxes (menu_line).row (menu_row).name = P_choices (i); 328 end; 329 end format_boxes; 330 return; 331 332 get_box_coords: 333 procedure (mi, bx, by); 334 declare mi fixed bin parameter; 335 /* input */ 336 declare (by, bx) fixed bin parameter; 337 /* output */ 338 339 by = mod (mi - 1, menu_ct); 340 bx = divide (mi - 1, menu_ct, 17); 341 end get_box_coords; 342 343 344 /* This has an implementation limit of 200 chars / line, but 345* surely that is reasonable? - if I use returns (char(*)) I become 346* non-quick */ 347 format: 348 procedure (raw, center, padc, ll) returns (char (200) varying); 349 declare raw char (*) varying parameter; 350 declare center bit (1) unal parameter; 351 declare padc char (1) aligned parameter; 352 declare ll fixed bin parameter; 353 declare lbuf char (200) varying; 354 declare lct fixed bin; 355 356 if ^center 357 then lbuf = raw; 358 else do; 359 lct = divide (max (0, ll - length (raw)), 2, 17); 360 lbuf = copy (padc, lct); 361 lbuf = lbuf || raw; 362 lbuf = lbuf || copy (padc, lct + mod (lct, 2)); 363 end; 364 return (lbuf); 365 end format; 366 end format_screen; 367 368 end common_create; 369 370 display_menu: 371 display: 372 entry (P_window, P_menu_ptr, P_code); 373 call setup (); 374 begin; 375 376 declare window_display_ entry (pointer, (*) char (*) unal, fixed bin (35)); 377 378 call window_display_ (P_window, menu.lines, P_code); 379 if menu.asterixed_option > 0 380 then do; 381 call cursor_to_option ((menu.asterixed_option)); 382 call window_$overwrite_text (P_window, "*", P_code); 383 end; 384 call window_$sync (P_window, P_code); 385 end; /* begin block */ 386 return; 387 388 get_choice: 389 entry (P_window, P_menu_ptr, P_function_key_info_ptr, P_fkeyp, P_selection, P_code); 390 call setup (); 391 function_key_data_ptr = P_function_key_info_ptr; 392 if function_key_data_ptr ^= null 393 then if function_key_data.version ^= function_key_data_version_1 394 then call ERROR (error_table_$unimplemented_version); 395 396 begin; 397 declare c char (1); 398 declare cc char (1); 399 declare ck char (1); 400 declare opx fixed bin; /* index thru options */ 401 declare possible bit (1) aligned; 402 declare fkeyb char (32) varying; 403 declare pseq char (pseql) based (pseqp); 404 declare pseql fixed bin (21); 405 declare pseqp ptr; 406 407 if menu.asterixed_option ^= 0 408 then do; 409 call cursor_to_option ((menu.asterixed_option)); 410 call window_$overwrite_text (P_window, menu.option_info (menu.asterixed_option).key, P_code); 411 if P_code ^= 0 412 then go to RETURN; 413 call window_$sync (P_window, P_code); 414 if P_code ^= 0 415 then go to RETURN; 416 end; 417 418 call cursor_to_option (1); 419 do while ("1"b); /* until valid key hit */ 420 c = read_a_char (); 421 if menu.case_insensitive 422 then cc = upper_case (c); 423 else cc = c; 424 425 do opx = 1 to menu.n_options; 426 if menu.case_insensitive 427 then ck = upper_case ((menu.option_info (opx).key)); 428 else ck = menu.option_info (opx).key; 429 if cc = ck 430 then do; 431 call cursor_to_option (opx); 432 P_fkeyp = "0"b; 433 P_selection = opx; 434 435 call window_$overwrite_text (P_window, "*", P_code); 436 if P_code ^= 0 437 then go to RETURN; 438 menu.asterixed_option = opx; 439 call window_$sync (P_window, P_code); 440 go to RETURN; 441 442 443 end; /* matching option */ 444 end; /* loop thru options */ 445 if function_key_data_ptr ^= null 446 then possible = "1"b; /* enter loop */ 447 else possible = "0"b; 448 fkeyb = c; 449 do while (possible); 450 possible = "0"b; 451 do opx = lbound (function_key_data.function_keys, 1) 452 to hbound (function_key_data.function_keys, 1); 453 pseql = function_key_data.function_keys (opx, KEY_PLAIN).sequence_length; 454 pseqp = 455 add_char_offset_ (function_key_data.seq_ptr, 456 (function_key_data.function_keys (opx, KEY_PLAIN).sequence_index) - 1); 457 458 if length (pseq) = length (fkeyb) & pseq = fkeyb 459 then do; 460 P_fkeyp = "1"b; 461 P_selection = opx; 462 return; 463 end; /* match - Win */ 464 else if ^possible /* look for possibles */ 465 then if length (pseq) > length (fkeyb) 466 /* we hope to match if we grow */ 467 then if index (pseq, fkeyb) = 1 468 /* pseq begins with fkeyb */ 469 then possible = "1"b; 470 end; /* loop thru f keys */ 471 if possible 472 then fkeyb = fkeyb || read_a_char (); 473 end; /* if even one has hopes, keep trying */ 474 475 /* fall out, no match */ 476 call window_$bell (P_window, (0)); 477 478 end; /* loop waiting for good one */ 479 480 read_a_char: 481 procedure returns (char (1)); 482 declare ac char (1); 483 begin; 484 declare break character (1) varying; 485 call window_$get_unechoed_chars (P_window, 1, ac, (0), break, P_code); 486 if P_code ^= 0 487 then goto ERROR_EXIT; 488 if length (break) = 1 489 then ac = break; 490 /*** else ac already has the right thing */ 491 end; 492 return (ac); 493 end read_a_char; 494 495 upper_case: 496 proc (c) returns (char (1)); 497 498 dcl c char (1); 499 500 if (rank (c) < rank ("a")) | (rank (c) > rank ("z")) 501 then return (c); 502 else return (byte (rank (c) - (rank ("a") - rank ("A")))); 503 504 end upper_case; 505 end; /* begin block */ 506 507 store_menu: 508 store: 509 entry (P_dname, P_ename, P_menu_name, P_create_sw, P_menu_ptr, P_code); 510 511 call setup (); 512 menu_segment_ptr = null; 513 created_sw = "0"b; 514 on cleanup call term_menu (); 515 516 call hcs_$initiate (P_dname, P_ename, "", 0, 1, menu_segment_ptr, P_code); 517 if P_code = error_table_$noentry & P_create_sw 518 then do; 519 created_sw = "1"b; 520 call hcs_$make_seg (P_dname, P_ename, "", RW_ACCESS_BIN, menu_segment_ptr, P_code); 521 if menu_segment_ptr = null 522 then go to SEG_ERR; 523 call value_$init_seg (menu_segment_ptr, 0, null, 0, P_code); 524 if P_code ^= 0 525 then go to SEG_ERR; 526 527 end; 528 529 if menu_segment_ptr = null 530 then go to SEG_ERR; 531 532 menu.asterixed_option = 0; 533 534 call value_$set_data (menu_segment_ptr, "01"b, value_name (P_menu_name), P_menu_ptr, currentsize (menu), null, 535 null, (0), P_code); 536 537 if P_code = 0 /* don't let term_menu delete new segment */ 538 then created_sw = "0"b; /* if we succeeded */ 539 call term_menu (); 540 541 return; 542 543 544 delete_menu: 545 delete: 546 entry (P_dname, P_ename, P_menu_name, P_code); 547 548 P_code = 0; 549 created_sw = "0"b; 550 on cleanup call term_menu; 551 call hcs_$initiate (P_dname, P_ename, "", 0, 1, menu_segment_ptr, P_code); 552 if menu_segment_ptr = null 553 then go to SEG_ERR; 554 555 /* Should be changed to use delete_data as soon as that exists */ 556 /* since that will give us an error if the value isn't there to delete */ 557 558 call value_$set_data (menu_segment_ptr, "01"b, value_name (P_menu_name), null, 0, null, null, (0), P_code); 559 /* Null ptr deletes value */ 560 call term_menu (); 561 return; 562 563 retrieve_menu: 564 retrieve: 565 entry (P_dname, P_ename, P_menu_name, P_areap, P_menu_ptr, P_code); 566 567 P_code = 0; 568 P_menu_ptr = null; 569 menu_segment_ptr = null; 570 created_sw = "0"b; 571 on cleanup call term_menu (); 572 573 call hcs_$initiate (P_dname, P_ename, "", 0, 1, menu_segment_ptr, P_code); 574 if menu_segment_ptr = null 575 then go to SEG_ERR; 576 577 begin; 578 579 declare areap ptr; 580 581 if P_areap = null 582 then areap = get_user_free_area_ (); 583 else areap = P_areap; 584 585 call value_$get_data (menu_segment_ptr, "01"b, value_name (P_menu_name), areap, menu_ptr, (0), P_code); 586 if P_code ^= 0 587 then go to SEG_ERR; 588 589 end; /* begin */ 590 591 592 if menu.version ^= MENU_VERSION 593 then do; 594 P_code = error_table_$unimplemented_version; 595 go to SEG_ERR; 596 end; 597 598 P_menu_ptr = menu_ptr; 599 call term_menu (); 600 601 return; 602 603 604 SEG_ERR: 605 call term_menu (); 606 607 go to ERROR_EXIT; 608 609 list_menus: 610 list: 611 entry (P_dname, P_ename, P_starname, P_areap, P_mli_version, P_list_ptr, P_code); 612 613 614 if P_mli_version ^= menu_list_info_version_1 615 then do; 616 P_code = error_table_$unimplemented_version; 617 return; 618 end; 619 620 call LIST (P_dname, P_ename, P_starname, P_areap, P_list_ptr, P_code); 621 return; 622 623 LIST: 624 procedure (dname, ename, starname, area_ptr, list_ptr, code); 625 declare (dname, ename, starname) 626 character (*); 627 declare area_ptr pointer; 628 declare list_ptr pointer; 629 declare (i, listx, vlistx) fixed bin (21); 630 declare code fixed bin (35); 631 declare auto_area_ptr pointer; 632 declare the_general_area area based (auto_area_ptr); 633 634 if area_ptr = null () 635 then auto_area_ptr = get_user_free_area_ (); 636 else auto_area_ptr = area_ptr; 637 638 code = 0; 639 640 list_ptr, menu_segment_ptr, menu_list_info_ptr, match_info_ptr, value_list_info_ptr = null (); 641 642 on cleanup 643 begin; 644 if menu_list_info_ptr ^= null 645 then free menu_list_info; 646 if match_info_ptr ^= null 647 then free match_info; 648 if value_list_info_ptr ^= null 649 then free value_list_info; 650 if menu_segment_ptr ^= null 651 then call hcs_$terminate_noname (menu_segment_ptr, (0)); 652 end; 653 654 call hcs_$initiate (dname, ename, "", 0, 1, menu_segment_ptr, code); 655 if menu_segment_ptr = null 656 then go to SEG_ERR; 657 658 alloc_name_count = 1; 659 alloc_max_name_len = length (value_name (starname)); 660 allocate match_info; 661 662 match_info.version = match_info_version_1; 663 match_info.name_array (1).exclude_sw = "0"b; 664 match_info.name_array (1).regexp_sw = "0"b; 665 match_info.name_array (1).pad = ""b; 666 match_info.name_array (1).name = value_name (starname); 667 668 call value_$list_data_names (menu_segment_ptr, "01"b, match_info_ptr, get_system_free_area_ (), 669 value_list_info_ptr, code); 670 free match_info; 671 if code ^= 0 672 then return; 673 674 675 menu_list_n_names = value_list_info.pair_count; 676 menu_list_name_string_length = 677 sum (value_list_info.name_len) - (value_list_info.pair_count * length (".menu_")); 678 679 allocate menu_list_info in (the_general_area); 680 681 menu_list_info.version = menu_list_info_version_1; 682 683 listx = 1; 684 do i = 1 to value_list_info.pair_count; 685 menu_list_info.position (i) = listx; 686 menu_list_info.length (i) = value_list_info.name_len (i) - length (".menu_"); 687 688 vlistx = value_list_info.name_index (i); 689 690 substr (menu_list_info.name_string, listx, menu_list_info.length (i)) = 691 substr (value_list_info.chars, vlistx, menu_list_info.length (i)); 692 listx = listx + menu_list_info.length (i); 693 end; 694 695 list_ptr = addr (menu_list_info); 696 free value_list_info; 697 call hcs_$terminate_noname (menu_segment_ptr, (0)); 698 end LIST; 699 700 /* This is called whenever we leave store_menu or retrieve_menu. 701* It terminates the null refname. */ 702 703 term_menu: 704 procedure (); 705 706 declare hcs_$terminate_noname entry (ptr, fixed bin (35)); 707 declare delete_$ptr entry (pointer, bit (6), character (*), fixed binary (35)); 708 709 if menu_segment_ptr ^= null 710 then if created_sw 711 then call delete_$ptr (menu_segment_ptr, "100101"b, "", (0)); 712 else call hcs_$terminate_noname (menu_segment_ptr, (0)); 713 714 end term_menu; 715 716 value_name: 717 procedure (name) returns (character (*)); 718 declare name character (*); 719 720 return (rtrim (name) || ".menu_"); /* user may not add the suffix themselves */ 721 end value_name; 722 723 describe_menu: 724 describe: 725 entry (P_menu_ptr, P_needs_ptr, P_code); 726 727 call setup (); 728 menu_requirements_ptr = P_needs_ptr; 729 if menu_requirements.version ^= menu_requirements_version_1 730 then do; 731 P_code = error_table_$unimplemented_version; 732 return; 733 end; 734 735 call fill_requirements_from_menu (); 736 return; 737 738 739 fill_requirements_from_menu: 740 procedure (); 741 742 menu_requirements.lines_needed = menu.height; 743 menu_requirements.width_needed = menu.width; 744 menu_requirements.n_options = menu.n_options; 745 end fill_requirements_from_menu; 746 747 748 749 destroy_menu: 750 destroy: 751 entry (P_menu_ptr, P_code); 752 call setup (); 753 free menu_ptr -> menu; 754 return; 755 756 757 758 setup: 759 procedure (); 760 P_code = 0; 761 if P_menu_ptr -> menu.version ^= MENU_VERSION 762 then call ERROR (error_table_$unimplemented_version); 763 menu_ptr = P_menu_ptr; 764 end setup; 765 766 767 cursor_to_option: 768 procedure (e); 769 declare e fixed bin parameter; 770 call window_$position_cursor (P_window, menu.option_info (e).line, menu.option_info (e).col, P_code); 771 if P_code ^= 0 772 then goto ERROR_EXIT; 773 774 end cursor_to_option; 775 776 777 ERROR: 778 procedure (code); 779 declare code fixed bin (35) parameter; 780 P_code = code; 781 goto ERROR_EXIT; 782 end ERROR; 783 784 RETURN: 785 ERROR_EXIT: 786 return; 787 1 1 /* BEGIN INCLUDE FILE menu_dcls.incl.pl1 1 2* declarations for the menu_ subroutines MTB 493 1 3* James R. Davis 26 Jan 81 to 20 Februrary 81 1 4**/ 1 5 1 6 /* format: off */ 1 7 1 8 dcl menu_$create entry ( 1 9 (*) char (*) varying, /* input: choices */ 1 10 (*) char (*) varying, /* input: headers */ 1 11 (*) char (*) varying, /* input: trailers */ 1 12 pointer, /* input: to format info */ 1 13 (*) char (1) unal, /* input: keys to use */ 1 14 pointer, /* input: to area */ 1 15 pointer, /* input: to needs str. */ 1 16 pointer, /* to menu: output */ 1 17 fixed bin (35) /* code */ 1 18 ); 1 19 1 20 dcl menu_$display entry ( 1 21 pointer, /* window */ 1 22 pointer, /* menu */ 1 23 fixed bin (35) /* code */ 1 24 ); 1 25 1 26 dcl menu_$get_choice entry ( 1 27 pointer, /* window */ 1 28 pointer, /* menu */ 1 29 pointer, /* to function key info */ 1 30 bit (1) aligned, /* function key hi: output */ 1 31 fixed bin, /* output: selection number */ 1 32 fixed bin (35) /* output: code */ 1 33 ); 1 34 1 35 dcl menu_$describe entry ( 1 36 pointer, /* menu */ 1 37 pointer, /* needs */ 1 38 fixed bin (35) /* code */ 1 39 ); 1 40 1 41 dcl menu_$destroy entry ( 1 42 pointer, /* menu */ 1 43 fixed bin (35) /* code */ 1 44 ); 1 45 1 46 dcl menu_$store entry ( 1 47 character (*), 1 48 character (*), 1 49 character (*), 1 50 bit (1) aligned, 1 51 pointer, 1 52 fixed bin (35)); 1 53 1 54 dcl menu_$retrieve entry ( 1 55 character (*), 1 56 character (*), 1 57 character (*), 1 58 pointer, 1 59 pointer, 1 60 fixed bin (35)); 1 61 dcl menu_$delete entry ( 1 62 character (*), 1 63 character (*), 1 64 character (*), 1 65 fixed binary (35)); 1 66 1 67 dcl menu_$list entry ( 1 68 character (*), 1 69 character (*), 1 70 character (*), 1 71 pointer, 1 72 fixed bin, 1 73 pointer, 1 74 fixed bin (35)); 1 75 1 76 dcl 1 menu_format aligned based (menu_format_ptr), 1 77 2 version fixed bin, 1 78 2 constraints, 1 79 3 max_width fixed bin, 1 80 3 max_height fixed bin, 1 81 2 n_columns fixed bin, 1 82 2 flags, 1 83 3 center_headers bit (1) unal, 1 84 3 center_trailers bit (1) unal, 1 85 3 pad bit (34) unal, 1 86 2 pad_char char (1); 1 87 1 88 dcl 1 menu_requirements aligned based (menu_requirements_ptr), 1 89 2 version fixed bin, 1 90 2 lines_needed fixed bin, 1 91 2 width_needed fixed bin, 1 92 2 n_options fixed bin; 1 93 1 94 dcl menu_format_ptr pointer; 1 95 dcl menu_requirements_ptr pointer; 1 96 1 97 dcl (menu_format_version_1, menu_requirements_version_1) 1 98 fixed bin internal static init (1) options (constant); 1 99 1 100 dcl MENU_OPTION_KEYS (35) char (1) unal internal static 1 101 options (constant) init 1 102 ("1", "2", "3", "4", "5", "6", "7", "8", "9", 1 103 "A", "B", "C", "D", "E", "F", "G", "H", "I", 1 104 "J", "K", "L", "M", "N", "O", "P", "Q", "R", 1 105 "S", "T", "U", "V", "W", "X", "Y", "Z"); 1 106 1 107 /* END INCLUDE FILE ... menu_dcls.incl.pl1 */ 788 2 1 /* begin include fine window_dcls.incl.pl1 BIM June 1981 */ 2 2 /* Modified 9 October 1983 by Jon A. Rochlis to add window_$edit_line. */ 2 3 2 4 /* format: style3 */ 2 5 2 6 declare window_$bell entry (pointer, fixed binary (35)); 2 7 declare window_$clear_region 2 8 entry (pointer, fixed binary, fixed binary, fixed binary, fixed binary, fixed binary (35)); 2 9 declare window_$clear_to_end_of_line 2 10 entry (pointer, fixed binary (35)); 2 11 declare window_$clear_to_end_of_window 2 12 entry (pointer, fixed binary (35)); 2 13 declare window_$clear_window 2 14 entry (pointer, fixed binary (35)); 2 15 declare window_$delete_chars 2 16 entry (pointer, fixed binary, fixed binary (35)); 2 17 declare window_$get_cursor_position 2 18 entry (pointer, fixed binary, fixed binary, fixed binary (35)); 2 19 2 20 /* Call window_$get_echoed_chars (iocb_ptr, n_to_read, read_buffer, n_read, read_break, code); */ 2 21 2 22 declare window_$get_echoed_chars 2 23 entry (pointer, fixed binary (21), character (*), fixed binary (21), character (1) var, 2 24 fixed binary (35)); 2 25 declare window_$get_unechoed_chars 2 26 entry (pointer, fixed binary (21), character (*), fixed binary (21), character (1) var, 2 27 fixed binary (35)); 2 28 declare window_$insert_text entry (pointer, character (*), fixed binary (35)); 2 29 declare window_$overwrite_text 2 30 entry (pointer, character (*), fixed binary (35)); 2 31 declare window_$position_cursor 2 32 entry (pointer, fixed binary, fixed binary, fixed binary (35)); 2 33 2 34 /* Call window_$position_cursor_rel (iocb_ptr, delta_line, delta_column, code); */ 2 35 2 36 declare window_$position_cursor_rel 2 37 entry (pointer, fixed binary, fixed binary, fixed binary (35)); 2 38 2 39 /* Call window_$scroll_region (iocb_ptr, first_line_of_region, n_lines_of_region, distance_to_scroll_region_negative_is_up, 2 40* code); */ 2 41 2 42 declare window_$scroll_region 2 43 entry (pointer, fixed binary, fixed binary, fixed binary, fixed binary (35)); 2 44 declare window_$sync entry (pointer, fixed binary (35)); 2 45 2 46 /* Call window_$write_raw_text (iocb_ptr, text_string, code); */ 2 47 2 48 declare window_$write_raw_text 2 49 entry (pointer, character (*), fixed binary (35)); 2 50 2 51 /* Call window_$write_sync_read (iocb_ptr, prompt_string, n_to_read, read_buffer, n_read, break_char, code); */ 2 52 2 53 declare window_$write_sync_read 2 54 entry (pointer, character (*), fixed bin (21), character (*), fixed binary (21), 2 55 character (1) var, fixed binary (35)); 2 56 2 57 /* Call window_$change_line (iocb_ptr, new_line, code); */ 2 58 2 59 declare window_$change_line entry (pointer, fixed binary, fixed binary (35)); 2 60 2 61 /* Call window_$change_column (iocb_ptr, new_column, code); */ 2 62 2 63 declare window_$change_column 2 64 entry (pointer, fixed binary, fixed binary (35)); 2 65 2 66 /* Call window_$get_one_unechoed (iocb_ptr, char_or_len_0, block_flag, code); */ 2 67 declare ( 2 68 window_$get_one_unechoed, 2 69 window_$get_one_unechoed_char 2 70 ) entry (pointer, character (1) var, bit (1) aligned, fixed binary (35)); 2 71 2 72 declare window_$create entry (pointer, pointer, pointer, fixed binary (35)); 2 73 2 74 declare window_$destroy entry (pointer, fixed binary (35)); 2 75 2 76 declare window_$edit_line entry (pointer, pointer, pointer, fixed bin(21), fixed bin(21), fixed bin(35)); 2 77 2 78 /* call window_$edit_line (iocb_ptr, window_edit_line_info_ptr, buffer_ptr, 2 79* buffer_len, n_returned, code); */ 2 80 2 81 2 82 /* end include file window_dcls.incl.pl1 */ 789 3 1 /* BEGIN INCLUDE FILE ... function_key_data.incl.pl1 3 2* 3 3* This include file defines the structure used for ttt_info_$function_key_data 3 4* MCR 4671 James R. Davis Sept 80 3 5**/ 3 6 3 7 dcl 1 function_key_data aligned based (function_key_data_ptr), 3 8 2 version fixed bin, 3 9 2 highest fixed bin, /* highest fkey */ 3 10 2 sequence, /* string of all seqs. */ 3 11 3 seq_ptr pointer, 3 12 3 seq_len fixed bin (21), 3 13 2 cursor_motion_keys, 3 14 3 home (0:3) like key_info, 3 15 3 left (0:3) like key_info, 3 16 3 up (0:3) like key_info, 3 17 3 right (0:3) like key_info, 3 18 3 down (0:3) like key_info, 3 19 2 function_keys (0:function_key_data_highest refer 3 20 (function_key_data.highest), 0:3) like key_info; 3 21 3 22 dcl (KEY_PLAIN init (0), 3 23 KEY_SHIFT init (1), 3 24 KEY_CTRL init (2), 3 25 KEY_CTRL_AND_SHIFT init (3) 3 26 ) fixed bin internal static options (constant); 3 27 3 28 dcl 1 key_info unaligned based (key_info_ptr), 3 29 2 sequence_index fixed bin (12) unsigned unaligned, 3 30 2 sequence_length fixed bin (6) unsigned unaligned; /* 0 -> not exist */ 3 31 3 32 dcl function_key_seqs char (function_key_data.sequence.seq_len) 3 33 based (function_key_data.sequence.seq_ptr); 3 34 dcl function_key_data_ptr ptr; 3 35 dcl function_key_data_highest fixed bin; 3 36 dcl function_key_data_version_1 3 37 fixed bin internal static options (constant) init (1); 3 38 dcl key_info_ptr ptr; 3 39 3 40 3 41 /* END INCLUDE FILE ... function_key_data.incl.pl1 */ 790 4 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 4 2* 4 3* Values for the "access mode" argument so often used in hardcore 4 4* James R. Davis 26 Jan 81 MCR 4844 4 5* Added constants for SM access 4/28/82 Jay Pattin 4 6* Added text strings 03/19/85 Chris Jones 4 7**/ 4 8 4 9 4 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 4 11 dcl ( 4 12 N_ACCESS init ("000"b), 4 13 R_ACCESS init ("100"b), 4 14 E_ACCESS init ("010"b), 4 15 W_ACCESS init ("001"b), 4 16 RE_ACCESS init ("110"b), 4 17 REW_ACCESS init ("111"b), 4 18 RW_ACCESS init ("101"b), 4 19 S_ACCESS init ("100"b), 4 20 M_ACCESS init ("010"b), 4 21 A_ACCESS init ("001"b), 4 22 SA_ACCESS init ("101"b), 4 23 SM_ACCESS init ("110"b), 4 24 SMA_ACCESS init ("111"b) 4 25 ) bit (3) internal static options (constant); 4 26 4 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 4 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 4 29 4 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 4 31 static options (constant); 4 32 4 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 4 34 static options (constant); 4 35 4 36 dcl ( 4 37 N_ACCESS_BIN init (00000b), 4 38 R_ACCESS_BIN init (01000b), 4 39 E_ACCESS_BIN init (00100b), 4 40 W_ACCESS_BIN init (00010b), 4 41 RW_ACCESS_BIN init (01010b), 4 42 RE_ACCESS_BIN init (01100b), 4 43 REW_ACCESS_BIN init (01110b), 4 44 S_ACCESS_BIN init (01000b), 4 45 M_ACCESS_BIN init (00010b), 4 46 A_ACCESS_BIN init (00001b), 4 47 SA_ACCESS_BIN init (01001b), 4 48 SM_ACCESS_BIN init (01010b), 4 49 SMA_ACCESS_BIN init (01011b) 4 50 ) fixed bin (5) internal static options (constant); 4 51 4 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 791 5 1 /* BEGIN value_structures.incl.pl1 */ 5 2 5 3 dcl (match_info_ptr, value_list_info_ptr) ptr; 5 4 dcl (alloc_name_count, alloc_pair_count) fixed bin; 5 5 dcl (alloc_max_name_len, alloc_chars_len) fixed bin (21); 5 6 5 7 dcl 1 match_info aligned based (match_info_ptr), 5 8 2 version fixed bin, /* = 1 */ 5 9 2 name_count fixed bin, 5 10 2 max_name_len fixed bin (21), 5 11 2 name_array (alloc_name_count refer (match_info.name_count)), 5 12 3 exclude_sw bit (1) unaligned, /* ON for -exclude, OFF for -match */ 5 13 3 regexp_sw bit (1) unaligned, /* ON for regular exp. without the //, OFF for starname */ 5 14 3 pad bit (34) unaligned, 5 15 3 name char (alloc_max_name_len refer (match_info.max_name_len)) varying; 5 16 5 17 dcl 1 value_list_info aligned based (value_list_info_ptr), 5 18 2 version fixed bin, /* = 1 */ 5 19 2 pair_count fixed bin, 5 20 2 chars_len fixed bin (21), 5 21 2 pairs (alloc_pair_count refer (value_list_info.pair_count)), 5 22 3 type_switches bit (36), /* correspond to the selection switches arg */ 5 23 3 (name_index, name_len) fixed bin (21), 5 24 3 (value_index, value_len) fixed bin (21), 5 25 2 chars char (alloc_chars_len refer (value_list_info.chars_len)); 5 26 5 27 dcl (match_info_version_1, value_list_info_version_1) fixed bin int static options (constant) init (1); 5 28 5 29 /* END OF value_structures.incl.pl1 */ 792 6 1 /* Begin include file menu_list_info.incl.pl1 BIM July 1981 */ 6 2 /* format: style3 */ 6 3 6 4 declare menu_list_info_ptr pointer; 6 5 declare 1 menu_list_info aligned based (menu_list_info_ptr), 6 6 2 version fixed bin, 6 7 2 n_names fixed bin, 6 8 2 name_string_length 6 9 fixed bin (21), 6 10 2 names (menu_list_n_names refer (menu_list_info.n_names)) aligned, 6 11 3 position fixed bin (21), 6 12 3 length fixed bin (21), 6 13 2 name_string character (menu_list_name_string_length refer (menu_list_info.name_string_length)) 6 14 unaligned; 6 15 6 16 6 17 declare menu_list_n_names fixed bin; 6 18 declare menu_list_name_string_length 6 19 fixed bin (21); 6 20 6 21 declare menu_list_info_version_1 6 22 fixed bin init (1) internal static options (constant); 6 23 6 24 /* End include file menu_list_info.incl.pl1 */ 793 794 end menu_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/08/85 1129.0 menu_.pl1 >spec>on>41-15>menu_.pl1 788 1 03/27/82 0429.3 menu_dcls.incl.pl1 >ldd>include>menu_dcls.incl.pl1 789 2 09/12/84 0916.7 window_dcls.incl.pl1 >ldd>include>window_dcls.incl.pl1 790 3 02/23/81 2146.3 function_key_data.incl.pl1 >ldd>include>function_key_data.incl.pl1 791 4 04/09/85 1109.7 access_mode_values.incl.pl1 >spec>on>41-15>access_mode_values.incl.pl1 792 5 06/24/81 1743.9 value_structures.incl.pl1 >ldd>include>value_structures.incl.pl1 793 6 03/27/82 0424.8 menu_list_info.incl.pl1 >ldd>include>menu_list_info.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. KEY_PLAIN constant fixed bin(17,0) initial dcl 3-22 ref 453 454 LOWER_CASE_LETTERS 000000 constant char(26) initial unaligned dcl 245 ref 247 249 MENU_VERSION 000020 constant char(8) initial dcl 88 ref 203 208 592 761 P_areap parameter pointer dcl 96 set ref 147 147 199 199 563 563 581 583 609 609 620* P_choices parameter varying char array dcl 96 ref 147 147 167 318 327 P_code parameter fixed bin(35,0) dcl 96 set ref 147 147 163* 370 370 378* 382* 384* 388 410* 411 413* 414 435* 436 439* 485* 486 507 507 516* 517 520* 523* 524 534* 537 544 544 548* 551* 558* 563 563 567* 573* 585* 586 594* 609 609 616* 620* 723 723 731* 749 749 760* 770* 771 780* P_create_sw parameter bit(1) dcl 96 ref 507 507 517 P_dname parameter char unaligned dcl 96 set ref 507 507 516* 520* 544 544 551* 563 563 573* 609 609 620* P_ename parameter char unaligned dcl 96 set ref 507 507 516* 520* 544 544 551* 563 563 573* 609 609 620* P_fkeyp parameter bit(1) dcl 96 set ref 388 432* 460* P_format_ptr parameter pointer dcl 96 ref 147 147 165 P_function_key_info_ptr parameter pointer dcl 96 ref 388 391 P_headers parameter varying char array dcl 96 set ref 147 147 184 184 293* P_keys parameter char(1) array unaligned dcl 96 ref 147 147 176 232 232 232 247 247 247 247 249 249 249 249 319 325 P_list_ptr parameter pointer dcl 96 set ref 609 609 620* P_menu_name parameter char unaligned dcl 96 set ref 507 507 534* 544 544 558* 563 563 585* P_menu_ptr parameter pointer dcl 96 set ref 147 147 164* 218* 370 370 388 507 507 534* 563 563 568* 598* 723 723 749 749 761 763 P_mli_version parameter fixed bin(17,0) dcl 96 ref 609 609 614 P_needs_ptr parameter pointer dcl 96 ref 147 147 166 723 723 728 P_selection parameter fixed bin(17,0) dcl 96 set ref 388 433* 461* P_starname parameter char unaligned dcl 96 set ref 609 609 620* P_trailers parameter varying char array dcl 96 set ref 147 147 186 186 297* P_window parameter pointer dcl 96 set ref 370 370 378* 382* 384* 388 410* 413* 435* 439* 476* 485* 770* RW_ACCESS_BIN 000016 constant fixed bin(5,0) initial dcl 4-36 set ref 520* UPPER_CASE_LETTERS 000007 constant char(26) initial unaligned dcl 244 ref 247 249 ac 000362 automatic char(1) unaligned dcl 482 set ref 485* 488* 492 add_char_offset_ 000014 constant entry external dcl 130 ref 454 addr builtin function dcl 127 ref 695 alloc_max_name_len 000131 automatic fixed bin(21,0) dcl 5-5 set ref 659* 660 660 alloc_name_count 000130 automatic fixed bin(17,0) dcl 5-4 set ref 658* 660 660 area_ptr parameter pointer dcl 627 ref 623 634 636 areap 000154 automatic pointer dcl 197 in begin block on line 195 set ref 199* 201* 203 areap 000374 automatic pointer dcl 579 in begin block on line 577 set ref 581* 583* 585* asterixed_option 5(18) based fixed bin(17,0) level 2 packed unaligned dcl 67 set ref 214* 379 381 407 409 410 438* 532* auto_area_ptr 000104 automatic pointer dcl 631 set ref 634* 636* 679 based_area based area(1024) dcl 196 ref 203 boxes defined structure array level 1 packed unaligned dcl 307 break 000364 automatic varying char(1) dcl 484 set ref 485* 488 488 bx parameter fixed bin(17,0) dcl 336 set ref 332 340* by parameter fixed bin(17,0) dcl 336 set ref 332 339* c parameter char(1) unaligned dcl 498 in procedure "upper_case" ref 495 500 500 500 502 c 000330 automatic char(1) unaligned dcl 397 in begin block on line 396 set ref 420* 421* 423 448 case_insensitive 5 based bit(1) level 3 packed unaligned dcl 67 set ref 213* 421 426 cc 000331 automatic char(1) unaligned dcl 398 set ref 421* 423* 429 center parameter bit(1) unaligned dcl 350 ref 347 356 center_headers 4 based bit(1) level 3 packed unaligned dcl 1-76 set ref 293* center_trailers 4(01) based bit(1) level 3 packed unaligned dcl 1-76 set ref 297* chars based char level 2 dcl 5-17 ref 690 chars_alloc 000105 automatic fixed bin(21,0) dcl 91 set ref 193* 203 203 210 chars_len 2 based fixed bin(21,0) level 2 dcl 5-17 ref 648 690 696 chars_per_box 000212 automatic fixed bin(17,0) dcl 283 set ref 301* 307 322 ck 000332 automatic char(1) unaligned dcl 399 set ref 426* 428* 429 cleanup 000110 stack reference condition dcl 145 ref 514 550 571 642 code parameter fixed bin(35,0) dcl 779 in procedure "ERROR" ref 777 780 code parameter fixed bin(35,0) dcl 630 in procedure "LIST" set ref 623 638* 654* 668* 671 col 10 based fixed bin(17,0) array level 3 dcl 67 set ref 322* 770* constant defined structure array level 3 packed unaligned dcl 307 constraints 1 based structure level 2 dcl 1-76 copy builtin function dcl 127 ref 360 362 created_sw 000106 automatic bit(1) dcl 125 set ref 513* 519* 537* 549* 570* 709 currentsize builtin function dcl 127 ref 534 534 delete_$ptr 000066 constant entry external dcl 707 ref 709 dimension builtin function dcl 127 ref 167 176 184 186 divide builtin function dcl 127 ref 185 301 340 359 dname parameter char unaligned dcl 625 set ref 623 654* e parameter fixed bin(17,0) dcl 769 ref 767 770 770 ename parameter char unaligned dcl 625 set ref 623 654* error_table_$noentry 000012 external static fixed bin(35,0) dcl 120 ref 517 error_table_$unimplemented_version 000010 external static fixed bin(35,0) dcl 120 set ref 170* 172* 392* 594 616 731 761* exclude_sw 3 based bit(1) array level 3 packed unaligned dcl 5-7 set ref 663* extra 000214 automatic fixed bin(17,0) dcl 285 set ref 302* 307 first_header_line 000207 automatic fixed bin(17,0) dcl 281 set ref 287* 288 293 first_menu_line 000210 automatic fixed bin(17,0) dcl 281 set ref 288* 289 321 first_option_char 000213 automatic fixed bin(21,0) dcl 284 set ref 303* 324 325 326 327 first_trailer_line 000211 automatic fixed bin(17,0) dcl 281 set ref 289* 297 fkeyb 000335 automatic varying char(32) dcl 402 set ref 448* 458 458 464 464 471* 471 flags 4 based structure level 2 in structure "menu_format" dcl 1-76 in procedure "menu_" flags 5 based structure level 2 in structure "menu" packed unaligned dcl 67 in procedure "menu_" set ref 212* function_key_data based structure level 1 dcl 3-7 function_key_data_ptr 000122 automatic pointer dcl 3-34 set ref 391* 392 392 445 451 451 453 454 454 function_key_data_version_1 constant fixed bin(17,0) initial dcl 3-36 ref 392 function_keys 31 based structure array level 2 dcl 3-7 ref 451 451 get_system_free_area_ 000016 constant entry external dcl 131 ref 201 668 668 get_user_free_area_ 000020 constant entry external dcl 132 ref 581 634 hbound builtin function dcl 127 ref 178 318 451 hcs_$initiate 000022 constant entry external dcl 133 ref 516 551 573 654 hcs_$make_seg 000026 constant entry external dcl 136 ref 520 hcs_$terminate_noname 000064 constant entry external dcl 706 in procedure "term_menu" ref 712 hcs_$terminate_noname 000024 constant entry external dcl 135 in procedure "menu_" ref 650 697 header_ct 000147 automatic fixed bin(17,0) dcl 153 set ref 184* 187 288 292 303 height 2 based fixed bin(17,0) level 3 dcl 67 set ref 203* 209* 216 378 534 534 742 753 highest 1 based fixed bin(17,0) level 2 dcl 3-7 ref 451 i 000206 automatic fixed bin(17,0) dcl 280 in procedure "format_screen" set ref 292* 293 293* 296* 297 297* 318* 319 319 320* 321 322 325 327* i 000100 automatic fixed bin(21,0) dcl 629 in procedure "LIST" set ref 684* 685 686 686 688 690 690 692* i 000164 automatic fixed bin(17,0) dcl 228 in procedure "all_keys_unique" set ref 231* 232* index builtin function dcl 229 in procedure "all_keys_unique" ref 232 index builtin function dcl 127 in procedure "menu_" ref 464 k 0(18) defined char(1) array level 4 packed unaligned dcl 307 set ref 325* kc parameter fixed bin(17,0) dcl 226 in procedure "all_keys_unique" ref 224 230 231 232 kc parameter fixed bin(17,0) dcl 241 in procedure "not_mixed_cases" ref 238 243 key 6 based char(1) array level 3 packed unaligned dcl 67 set ref 319* 410* 426 428 key_info based structure level 1 packed unaligned dcl 3-28 key_overlay defined char unaligned dcl 243 in procedure "not_mixed_cases" ref 247 247 249 249 key_overlay defined char unaligned dcl 230 in procedure "all_keys_unique" ref 232 lbound builtin function dcl 127 ref 451 lbuf 000244 automatic varying char(200) dcl 353 set ref 356* 360* 361* 361 362* 362 364 lct 000327 automatic fixed bin(17,0) dcl 354 set ref 359* 360 362 362 length 4 based fixed bin(21,0) array level 3 in structure "menu_list_info" dcl 6-5 in procedure "menu_" set ref 686* 690 690 692 length builtin function dcl 127 in procedure "menu_" ref 184 186 359 458 458 464 464 488 659 676 686 line 7 based fixed bin(17,0) array level 3 dcl 67 set ref 321* 770* lines 275 based char array level 2 packed unaligned dcl 67 set ref 216* 293* 297* 324* 324 325* 325 326* 326 327* 327 378* lines_alloc 000104 automatic fixed bin(21,0) dcl 90 set ref 187* 189 203 203 209 lines_needed 1 based fixed bin(17,0) level 2 dcl 1-88 set ref 742* list_ptr parameter pointer dcl 628 set ref 623 640* 695* listx 000101 automatic fixed bin(21,0) dcl 629 set ref 683* 685 690 692* 692 ll parameter fixed bin(17,0) dcl 352 ref 347 359 lp defined char(2) array level 4 packed unaligned dcl 307 set ref 324* match_info based structure level 1 dcl 5-7 set ref 646 660 670 match_info_ptr 000124 automatic pointer dcl 5-3 set ref 640* 646 646 660* 662 663 664 665 666 668* 670 match_info_version_1 constant fixed bin(17,0) initial dcl 5-27 ref 662 max builtin function dcl 127 ref 359 max_height 2 based fixed bin(17,0) level 3 dcl 1-76 ref 189 189 max_name_len 2 based fixed bin(21,0) level 2 dcl 5-7 set ref 646 660* 663 663 664 664 665 665 666 666 666 670 max_width 1 based fixed bin(17,0) level 3 dcl 1-76 set ref 193 293* 297* 301 302 menu based structure level 1 dcl 67 set ref 203 534 534 753 menu_ct 000150 automatic fixed bin(17,0) dcl 153 set ref 185* 187 289 307 339 340 menu_et_$higher_than_max 000054 external static fixed bin(35,0) dcl 156 set ref 189* menu_et_$keys_not_unique 000060 external static fixed bin(35,0) dcl 160 set ref 180* menu_et_$too_few_keys 000052 external static fixed bin(35,0) dcl 155 set ref 176* menu_et_$too_many_options 000056 external static fixed bin(35,0) dcl 158 set ref 178* menu_format based structure level 1 dcl 1-76 menu_format_ptr 000116 automatic pointer dcl 1-94 set ref 165* 170 172 185 185 189 189 193 293 293 293 297 297 297 301 301 302 302 307 menu_format_version_1 constant fixed bin(17,0) initial dcl 1-97 ref 170 menu_line 000217 automatic fixed bin(17,0) dcl 315 set ref 320* 321 324 325 326 327 menu_list_info based structure level 1 dcl 6-5 set ref 644 679 695 menu_list_info_ptr 000132 automatic pointer dcl 6-4 set ref 640* 644 644 679* 681 685 686 690 690 690 692 695 menu_list_info_version_1 constant fixed bin(17,0) initial dcl 6-21 ref 614 681 menu_list_n_names 000134 automatic fixed bin(17,0) dcl 6-17 set ref 675* 679 679 menu_list_name_string_length 000135 automatic fixed bin(21,0) dcl 6-18 set ref 676* 679 679 menu_ptr 000100 automatic pointer dcl 85 set ref 178 203* 208 209 210 211 212 213 214 216 218 293 297 303 319 321 322 324 325 326 327 378 379 381 407 409 410 410 421 425 426 426 428 438 532 534 534 585* 592 598 742 743 744 753 763* 770 770 menu_requirements based structure level 1 dcl 1-88 menu_requirements_ptr 000120 automatic pointer dcl 1-95 set ref 166* 170 728* 729 742 743 744 menu_requirements_version_1 constant fixed bin(17,0) initial dcl 1-97 ref 170 729 menu_row 000220 automatic fixed bin(17,0) dcl 316 set ref 320* 322 324 325 326 327 menu_segment_ptr 000102 automatic pointer dcl 86 set ref 512* 516* 520* 521 523* 529 534* 551* 552 558* 569* 573* 574 585* 640* 650 650* 654* 655 668* 697* 709 709* 712* mi parameter fixed bin(17,0) dcl 334 ref 332 339 340 mod builtin function dcl 127 ref 185 302 339 362 n_choices 000146 automatic fixed bin(17,0) dcl 152 set ref 167* 174 176 178 180* 185 185 211 213* n_columns 3 based fixed bin(17,0) level 2 dcl 1-76 ref 185 185 301 302 307 n_names 1 based fixed bin(17,0) level 2 dcl 6-5 set ref 644 679* 690 n_options 3 based fixed bin(17,0) level 2 in structure "menu_requirements" dcl 1-88 in procedure "menu_" set ref 744* n_options 4 based fixed bin(17,0) level 2 in structure "menu" dcl 67 in procedure "menu_" set ref 211* 425 744 name 4 based varying char array level 3 in structure "match_info" dcl 5-7 in procedure "menu_" set ref 666* name parameter char unaligned dcl 718 in procedure "value_name" ref 716 720 name 1(09) defined char array level 3 in structure "boxes" packed unaligned dcl 307 in begin block on line 305 set ref 327* name_array 3 based structure array level 2 dcl 5-7 name_count 1 based fixed bin(17,0) level 2 dcl 5-7 set ref 646 660* 670 name_index 4 based fixed bin(21,0) array level 3 dcl 5-17 ref 688 name_len 5 based fixed bin(21,0) array level 3 dcl 5-17 ref 676 686 name_string based char level 2 packed unaligned dcl 6-5 set ref 690* name_string_length 2 based fixed bin(21,0) level 2 dcl 6-5 set ref 644 679* 690 names 3 based structure array level 2 dcl 6-5 null builtin function dcl 127 ref 164 199 392 445 512 521 523 523 529 534 534 534 534 552 558 558 558 558 558 558 568 569 574 581 634 640 644 646 648 650 655 709 option_info 6 based structure array level 2 dcl 67 set ref 178 opx 000333 automatic fixed bin(17,0) dcl 400 set ref 425* 426 428 431* 433 438* 451* 453 454 461* pad 4(02) based bit(34) level 3 in structure "menu_format" packed unaligned dcl 1-76 in procedure "menu_" ref 172 pad 3(02) based bit(34) array level 3 in structure "match_info" packed unaligned dcl 5-7 in procedure "menu_" set ref 665* pad_char 5 based char(1) level 2 dcl 1-76 set ref 293* 297* padc parameter char(1) dcl 351 ref 347 360 362 pair_count 1 based fixed bin(17,0) level 2 dcl 5-17 ref 648 675 676 676 684 690 696 pairs 3 based structure array level 2 dcl 5-17 position 3 based fixed bin(21,0) array level 3 dcl 6-5 set ref 685* possible 000334 automatic bit(1) dcl 401 set ref 445* 447* 449 450* 464 464* 471 pseq based char unaligned dcl 403 ref 458 458 464 464 pseql 000346 automatic fixed bin(21,0) dcl 404 set ref 453* 458 458 464 464 pseqp 000350 automatic pointer dcl 405 set ref 454* 458 458 464 464 raw parameter varying char dcl 349 ref 347 356 359 361 regexp_sw 3(01) based bit(1) array level 3 packed unaligned dcl 5-7 set ref 664* row defined structure array level 2 packed unaligned dcl 307 rp 0(27) defined char(2) array level 4 packed unaligned dcl 307 set ref 326* seq_ptr 2 based pointer level 3 dcl 3-7 set ref 454* sequence 2 based structure level 2 dcl 3-7 sequence_index 31 based fixed bin(12,0) array level 3 packed unsigned unaligned dcl 3-7 ref 454 sequence_length 31(12) based fixed bin(6,0) array level 3 packed unsigned unaligned dcl 3-7 ref 453 sign builtin function dcl 127 ref 184 185 186 starname parameter char unaligned dcl 625 set ref 623 659* 666* substr builtin function dcl 229 ref 232 the_general_area based area(1024) dcl 632 ref 679 trailer_ct 000151 automatic fixed bin(17,0) dcl 153 set ref 186* 187 296 value_$get_data 000032 constant entry external dcl 138 ref 585 value_$init_seg 000030 constant entry external dcl 137 ref 523 value_$list_data_names 000036 constant entry external dcl 142 ref 668 value_$set_data 000034 constant entry external dcl 140 ref 534 558 value_list_info based structure level 1 dcl 5-17 ref 648 696 value_list_info_ptr 000126 automatic pointer dcl 5-3 set ref 640* 648 648 668* 675 676 676 684 686 688 690 696 version based fixed bin(17,0) level 2 in structure "match_info" dcl 5-7 in procedure "menu_" set ref 662* version based fixed bin(17,0) level 2 in structure "menu_format" dcl 1-76 in procedure "menu_" ref 170 version based fixed bin(17,0) level 2 in structure "menu_list_info" dcl 6-5 in procedure "menu_" set ref 681* version based fixed bin(17,0) level 2 in structure "menu_requirements" dcl 1-88 in procedure "menu_" ref 170 729 version based fixed bin(17,0) level 2 in structure "function_key_data" dcl 3-7 in procedure "menu_" ref 392 version based char(8) initial level 2 in structure "menu" dcl 67 in procedure "menu_" set ref 203* 208* 592 761 vlistx 000102 automatic fixed bin(21,0) dcl 629 set ref 688* 690 width 3 based fixed bin(17,0) level 3 dcl 67 set ref 203* 210* 216 216 216 293 293 293 297 297 297 303 324 325 326 327 378 378 378 534 534 743 753 width_needed 2 based fixed bin(17,0) level 2 dcl 1-88 set ref 743* window_$bell 000040 constant entry external dcl 2-6 ref 476 window_$get_unechoed_chars 000042 constant entry external dcl 2-25 ref 485 window_$overwrite_text 000044 constant entry external dcl 2-29 ref 382 410 435 window_$position_cursor 000046 constant entry external dcl 2-31 ref 770 window_$sync 000050 constant entry external dcl 2-44 ref 384 413 439 window_display_ 000062 constant entry external dcl 376 ref 378 window_requirements 2 based structure level 2 dcl 67 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. A_ACCESS internal static bit(3) initial unaligned dcl 4-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 DIR_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 4-33 E_ACCESS internal static bit(3) initial unaligned dcl 4-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 KEY_CTRL internal static fixed bin(17,0) initial dcl 3-22 KEY_CTRL_AND_SHIFT internal static fixed bin(17,0) initial dcl 3-22 KEY_SHIFT internal static fixed bin(17,0) initial dcl 3-22 MENU_OPTION_KEYS internal static char(1) initial array unaligned dcl 1-100 M_ACCESS internal static bit(3) initial unaligned dcl 4-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 N_ACCESS internal static bit(3) initial unaligned dcl 4-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 REW_ACCESS internal static bit(3) initial unaligned dcl 4-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 RE_ACCESS internal static bit(3) initial unaligned dcl 4-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 RW_ACCESS internal static bit(3) initial unaligned dcl 4-11 R_ACCESS internal static bit(3) initial unaligned dcl 4-11 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 SA_ACCESS internal static bit(3) initial unaligned dcl 4-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 4-30 SMA_ACCESS internal static bit(3) initial unaligned dcl 4-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 SM_ACCESS internal static bit(3) initial unaligned dcl 4-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 S_ACCESS internal static bit(3) initial unaligned dcl 4-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 W_ACCESS internal static bit(3) initial unaligned dcl 4-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 4-36 alloc_chars_len automatic fixed bin(21,0) dcl 5-5 alloc_pair_count automatic fixed bin(17,0) dcl 5-4 function_key_data_highest automatic fixed bin(17,0) dcl 3-35 function_key_seqs based char unaligned dcl 3-32 key_info_ptr automatic pointer dcl 3-38 menu_$create 000000 constant entry external dcl 1-8 menu_$delete 000000 constant entry external dcl 1-61 menu_$describe 000000 constant entry external dcl 1-35 menu_$destroy 000000 constant entry external dcl 1-41 menu_$display 000000 constant entry external dcl 1-20 menu_$get_choice 000000 constant entry external dcl 1-26 menu_$list 000000 constant entry external dcl 1-67 menu_$retrieve 000000 constant entry external dcl 1-54 menu_$store 000000 constant entry external dcl 1-46 value_list_info_version_1 internal static fixed bin(17,0) initial dcl 5-27 window_$change_column 000000 constant entry external dcl 2-63 window_$change_line 000000 constant entry external dcl 2-59 window_$clear_region 000000 constant entry external dcl 2-7 window_$clear_to_end_of_line 000000 constant entry external dcl 2-9 window_$clear_to_end_of_window 000000 constant entry external dcl 2-11 window_$clear_window 000000 constant entry external dcl 2-13 window_$create 000000 constant entry external dcl 2-72 window_$delete_chars 000000 constant entry external dcl 2-15 window_$destroy 000000 constant entry external dcl 2-74 window_$edit_line 000000 constant entry external dcl 2-76 window_$get_cursor_position 000000 constant entry external dcl 2-17 window_$get_echoed_chars 000000 constant entry external dcl 2-22 window_$get_one_unechoed 000000 constant entry external dcl 2-67 window_$get_one_unechoed_char 000000 constant entry external dcl 2-67 window_$insert_text 000000 constant entry external dcl 2-28 window_$position_cursor_rel 000000 constant entry external dcl 2-36 window_$scroll_region 000000 constant entry external dcl 2-42 window_$write_raw_text 000000 constant entry external dcl 2-48 window_$write_sync_read 000000 constant entry external dcl 2-53 NAMES DECLARED BY EXPLICIT CONTEXT. ERROR 005200 constant entry internal dcl 777 ref 170 172 176 178 180 189 392 761 ERROR_EXIT 004122 constant label dcl 784 ref 486 607 771 781 LIST 004124 constant entry internal dcl 623 ref 620 RETURN 004122 constant label dcl 784 ref 411 414 436 440 SEG_ERR 003632 constant label dcl 604 ref 521 524 529 552 574 586 595 655 all_keys_unique 000553 constant entry internal dcl 224 ref 180 common_create 000205 constant label dcl 150 create 000106 constant entry external dcl 147 create_menu 000147 constant entry external dcl 147 cursor_to_option 005152 constant entry internal dcl 767 ref 381 409 418 431 delete 003025 constant entry external dcl 544 delete_menu 003060 constant entry external dcl 544 describe 004003 constant entry external dcl 723 describe_menu 004022 constant entry external dcl 723 destroy 004057 constant entry external dcl 749 destroy_menu 004074 constant entry external dcl 749 display 001503 constant entry external dcl 370 display_menu 001520 constant entry external dcl 370 fill_requirements_from_menu 005115 constant entry internal dcl 739 ref 220 735 format 001351 constant entry internal dcl 347 ref 293 297 format_boxes 001132 constant label dcl 305 format_screen 000712 constant entry internal dcl 278 ref 217 get_box_coords 001334 constant entry internal dcl 332 ref 320 get_choice 001645 constant entry external dcl 388 list 003645 constant entry external dcl 609 list_menus 003702 constant entry external dcl 609 menu_ 000071 constant entry external dcl 10 not_mixed_cases 000631 constant entry internal dcl 238 ref 213 read_a_char 002255 constant entry internal dcl 480 ref 420 471 retrieve 003315 constant entry external dcl 563 retrieve_menu 003354 constant entry external dcl 563 setup 005127 constant entry internal dcl 758 ref 373 390 511 727 752 store 002413 constant entry external dcl 507 store_menu 002450 constant entry external dcl 507 term_menu 004770 constant entry internal dcl 703 ref 514 539 550 560 571 599 604 upper_case 002336 constant entry internal dcl 495 ref 421 426 value_name 005047 constant entry internal dcl 716 ref 534 558 585 659 666 NAMES DECLARED BY CONTEXT OR IMPLICATION. byte builtin function ref 502 rank builtin function ref 500 500 500 500 502 502 502 rtrim builtin function ref 720 search builtin function ref 247 247 249 249 substr builtin function ref 690 690 sum builtin function ref 676 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 6410 6500 5672 6420 Length 7110 5672 70 373 516 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME menu_ 608 external procedure is an external procedure. begin block on line 150 begin block shares stack frame of external procedure menu_. begin block on line 195 begin block shares stack frame of external procedure menu_. all_keys_unique internal procedure shares stack frame of external procedure menu_. not_mixed_cases internal procedure shares stack frame of external procedure menu_. format_screen internal procedure shares stack frame of external procedure menu_. begin block on line 305 begin block shares stack frame of external procedure menu_. get_box_coords internal procedure shares stack frame of external procedure menu_. format internal procedure shares stack frame of external procedure menu_. begin block on line 374 begin block shares stack frame of external procedure menu_. begin block on line 396 begin block shares stack frame of external procedure menu_. read_a_char internal procedure shares stack frame of external procedure menu_. begin block on line 483 begin block shares stack frame of external procedure menu_. upper_case internal procedure shares stack frame of external procedure menu_. on unit on line 514 64 on unit on unit on line 550 64 on unit on unit on line 571 64 on unit begin block on line 577 begin block shares stack frame of external procedure menu_. LIST 124 internal procedure enables or reverts conditions. on unit on line 642 72 on unit term_menu 86 internal procedure is called by several nonquick procedures. value_name 67 internal procedure uses returns(char(*)) or returns(bit(*)). fill_requirements_from_menu internal procedure shares stack frame of external procedure menu_. setup internal procedure shares stack frame of external procedure menu_. cursor_to_option internal procedure shares stack frame of external procedure menu_. ERROR internal procedure shares stack frame of external procedure menu_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME LIST 000100 i LIST 000101 listx LIST 000102 vlistx LIST 000104 auto_area_ptr LIST menu_ 000100 menu_ptr menu_ 000102 menu_segment_ptr menu_ 000104 lines_alloc menu_ 000105 chars_alloc menu_ 000106 created_sw menu_ 000116 menu_format_ptr menu_ 000120 menu_requirements_ptr menu_ 000122 function_key_data_ptr menu_ 000124 match_info_ptr menu_ 000126 value_list_info_ptr menu_ 000130 alloc_name_count menu_ 000131 alloc_max_name_len menu_ 000132 menu_list_info_ptr menu_ 000134 menu_list_n_names menu_ 000135 menu_list_name_string_length menu_ 000146 n_choices begin block on line 150 000147 header_ct begin block on line 150 000150 menu_ct begin block on line 150 000151 trailer_ct begin block on line 150 000154 areap begin block on line 195 000164 i all_keys_unique 000206 i format_screen 000207 first_header_line format_screen 000210 first_menu_line format_screen 000211 first_trailer_line format_screen 000212 chars_per_box format_screen 000213 first_option_char format_screen 000214 extra format_screen 000217 menu_line begin block on line 305 000220 menu_row begin block on line 305 000244 lbuf format 000327 lct format 000330 c begin block on line 396 000331 cc begin block on line 396 000332 ck begin block on line 396 000333 opx begin block on line 396 000334 possible begin block on line 396 000335 fkeyb begin block on line 396 000346 pseql begin block on line 396 000350 pseqp begin block on line 396 000362 ac read_a_char 000364 break begin block on line 483 000374 areap begin block on line 577 THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other begin_return return tra_ext sign mpfx2 mod_fx1 enable shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc repeat set_cs_eis index_cs_eis return_chars_eis alloc_based alloc_based_storage free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. add_char_offset_ delete_$ptr get_system_free_area_ get_user_free_area_ hcs_$initiate hcs_$make_seg hcs_$terminate_noname hcs_$terminate_noname value_$get_data value_$init_seg value_$list_data_names value_$set_data window_$bell window_$get_unechoed_chars window_$overwrite_text window_$position_cursor window_$sync window_display_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$noentry error_table_$unimplemented_version menu_et_$higher_than_max menu_et_$keys_not_unique menu_et_$too_few_keys menu_et_$too_many_options LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 10 000070 12 000076 147 000077 163 000205 164 000206 165 000210 166 000214 167 000217 170 000227 172 000244 174 000257 176 000261 178 000301 180 000313 184 000327 185 000352 186 000364 187 000405 189 000411 193 000424 199 000427 201 000437 203 000446 208 000466 209 000471 210 000473 211 000475 212 000477 213 000503 214 000514 216 000517 217 000544 218 000545 220 000547 222 000550 368 000552 224 000553 230 000555 231 000557 232 000567 234 000623 235 000625 238 000631 243 000633 247 000635 249 000674 251 000705 278 000712 287 000713 288 000715 289 000717 292 000721 293 000731 295 001013 296 001015 297 001025 299 001111 301 001113 302 001117 303 001123 307 001132 318 001156 319 001167 320 001211 321 001213 322 001222 324 001233 325 001254 326 001277 327 001305 328 001331 330 001333 332 001334 339 001336 340 001344 341 001350 347 001351 356 001362 359 001402 360 001412 361 001427 362 001442 363 001466 364 001467 370 001476 373 001532 378 001533 379 001570 381 001575 382 001600 384 001624 386 001636 388 001637 390 001657 391 001660 392 001664 407 001702 409 001707 410 001712 411 001741 413 001743 414 001755 418 001757 419 001763 420 001764 421 001766 423 001775 425 001777 426 002007 428 002022 429 002025 431 002034 432 002036 433 002040 435 002042 436 002065 438 002067 439 002072 440 002104 444 002105 445 002107 447 002116 448 002117 449 002124 450 002126 451 002127 453 002137 454 002146 458 002165 460 002176 461 002201 462 002203 464 002205 470 002222 471 002224 473 002237 476 002240 478 002253 505 002254 480 002255 485 002257 486 002317 488 002321 492 002330 495 002336 500 002340 502 002365 507 002404 511 002502 512 002503 513 002505 514 002506 516 002530 517 002576 519 002606 520 002610 521 002645 523 002651 524 002674 529 002676 532 002702 534 002705 537 003007 539 003013 541 003017 544 003020 548 003110 549 003111 550 003112 551 003134 552 003202 558 003206 560 003301 561 003306 563 003307 567 003410 568 003411 569 003413 570 003414 571 003415 573 003437 574 003505 581 003511 583 003525 585 003530 586 003610 592 003613 594 003620 595 003623 598 003624 599 003625 601 003631 604 003632 607 003636 609 003637 614 003734 616 003740 617 003743 620 003744 621 004000 723 004001 727 004036 728 004037 729 004042 731 004045 732 004050 735 004051 736 004052 749 004053 752 004106 753 004107 754 004121 784 004122 623 004123 634 004151 636 004165 638 004170 640 004172 642 004201 644 004215 646 004235 648 004254 650 004275 652 004315 654 004316 655 004365 658 004375 659 004400 660 004425 662 004445 663 004447 664 004451 665 004461 666 004463 668 004520 670 004555 671 004567 675 004572 676 004576 679 004625 681 004646 683 004650 684 004652 685 004663 686 004671 688 004677 690 004702 692 004727 693 004731 695 004733 696 004737 697 004753 698 004766 703 004767 709 004775 712 005034 714 005045 716 005046 720 005062 739 005115 742 005116 743 005122 744 005124 745 005126 758 005127 760 005130 761 005131 763 005146 764 005151 767 005152 770 005154 771 005175 774 005177 777 005200 780 005202 781 005204 ----------------------------------------------------------- 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