COMPILATION LISTING OF SEGMENT find_operator_name_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/05/86 1030.9 mst Wed Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* format: style3,^indnoniterdo */ 12 find_operator_name_: 13 proc (tname, callp, op_name); 14 15 /* This procedure is given a pointer to an instruction transferring to pl1_operators_ (or cobol_operators_, etc.) 16* and returns the name of the operator being referenced. 17* 18* coded by M. Weaver 11 July 1973 19**/ 20 /* Modified by M. Weaver 1/12/74 for 10-bit opcodes */ 21 /* Modified by S.E. Barr 7/76 to remove version I operator decoding */ 22 /* Modified: 5-4-77 by SHW for more general operator name segments */ 23 /* Modified 7/81 by M. Weaver for algol68 and to call hcs_$make_ptr */ 24 /* Modified 5/82 by M. Weaver to fix bug in above change */ 25 /* Modified 9/82 by JM Athane for pascal compiler and bug fix */ 26 /* Changed to use interpret_link_info.incl.pl1 05/12/83 S. Herbst */ 27 28 declare tname char (*); /* name of translator or operator segment */ 29 declare (callp, nptr, linkp, entryp) 30 ptr; 31 32 declare (op_index, offset, nsize, i) 33 fixed bin; 34 declare code fixed bin (35); 35 36 declare op_name char (32) aligned; 37 declare onp ptr; 38 declare name char (nsize) based (nptr) aligned; 39 40 declare word bit (36) aligned based, 41 masked_word bit (36) aligned; 42 43 dcl ( 44 mask init ("700000777777"b3), 45 tsx0_ap init ("000000700100"b3), /* tsx0 pr0|0 */ 46 tsp2_bp init ("200000272100"b3), /* tsp2 pr2|0 */ 47 tra_ap init ("000000710100"b3), /* tra pr0|0 */ 48 tsp3_ap init ("000000273100"b3), /* tsp3 pr0|0 */ 49 tsp3_lp init ("400000273100"b3) /* tsp3 pr4|0 */ 50 ) bit (36) aligned static; 51 52 declare ( 53 tsx0 init ("1110000000"b), 54 tsp2 init ("0101110100"b), 55 tra init ("1110010000"b), 56 tsp3 init ("0101110110"b), 57 tsp4 init ("1101110000"b) 58 ) bit (10) aligned; 59 60 61 dcl other_language_names 62 (4) char (8) varying static options (constant) init ("cobol", "basic", "pascal", "algol68"); 63 dcl other_language_xfer_instruction 64 (4) bit (36) aligned static options (constant) init ("000000700100"b3, 65 /* tsx0 pr0|0 */ 66 "000000707100"b3, /* tsx7 pr0|0 */ 67 "000000273100"b3, /* tsp3 pr0|0 */ 68 "000000702100"b3) /* tsx2 */; 69 dcl other_language_masks 70 (4) bit (36) aligned static options (constant) 71 init ("700000777777"b3, "700000777777"b3, "700000777777"b3, "000000777777"b3); 72 73 dcl pl1_operator_names_$pl1_operator_names_ 74 ext; 75 1 1 /* BEGIN INCLUDE FILE operator_names.incl.pl1 77-5-2 SHW */ 1 2 1 3 /* Modified June 83 JMAthane for full qualification of "refer" args in dcls */ 1 4 1 5 dcl op_names_pt ptr; 1 6 1 7 dcl 1 operator_names aligned based (op_names_pt), 1 8 2 first fixed bin (18), /* offset of first operator in operator segment */ 1 9 2 last fixed bin (18), /* offset of last operator in operator segment */ 1 10 2 first_special fixed bin (18), /* offset of first special operator */ 1 11 2 last_special fixed bin (18), /* offset of last special operator */ 1 12 2 number_special fixed bin, /* number of special operators */ 1 13 1 14 2 names (1 refer (operator_names.first):1 refer (operator_names.last)), /* array of pointers to and lengths of names */ 1 15 3 namep bit (18) unal, /* rel pointer to ACI string for name */ 1 16 3 len fixed bin (17) unal, /* length of this operator name */ 1 17 1 18 2 special (0 refer (operator_names.number_special)), /* array of info about special operators */ 1 19 3 offset fixed bin (18), /* offset of start of code for this operator */ 1 20 3 namep bit (18) unal, /* rel pointer to ACI string for name */ 1 21 3 len fixed bin (17) unal; /* length of this operator name */ 1 22 1 23 /* END INCLUDE FILE operator_names.incl.pl1 */ 76 77 2 1 /* BEGIN INCLUDE FILE interpret_link_info.incl.pl1 */ 2 2 2 3 /* Written 05/12/83 by S. Herbst */ 2 4 2 5 dcl 1 interpret_link_info aligned based (interpret_link_info_ptr), 2 6 2 version char (8), 2 7 2 segment_name char (32) aligned, 2 8 2 entry_point_name char (260) aligned, 2 9 2 expression char (8) aligned, 2 10 2 modifier char (4) aligned, 2 11 2 trap char (48) aligned; 2 12 2 13 dcl INTERPRET_LINK_INFO_VERSION_1 char (8) int static options (constant) init ("ILI 1.0"); 2 14 2 15 dcl interpret_link_info_ptr ptr; 2 16 2 17 /* END INCLUDE FILE interpret_link_info.incl.pl1 */ 78 79 declare interpret_link_ entry (ptr, ptr, fixed bin (35)); 80 declare get_operator_names_ptr_ 81 entry (char (*), ptr); 82 declare get_link_ptr_ entry (ptr, ptr, ptr); 83 declare hcs_$make_ptr entry (ptr, char (*), char (*), ptr, fixed bin (35)); 84 85 declare (addr, bin, hbound, lbound, null, ptr, rel, substr) 86 builtin; 87 88 declare 1 inst aligned based, /* template for instruction word */ 89 2 base bit (3) unal, 90 2 address bit (15) unal, 91 2 opcode bit (10) unal, 92 2 junk1 bit (1) unal, 93 2 base_flag bit (1) unal, 94 2 junk2 bit (6) unal; 95 96 declare 1 name_pair aligned based, /* template for word in operator name table */ 97 2 rel_ptr bit (18) unal, 98 2 size fixed bin (17) unal; 99 100 dcl 1 auto_interpret_link_info 101 aligned like interpret_link_info; 102 103 104 /* */ 3 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 3 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 3 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 3 4 /* Modified April 1983 by C. Hornig for tasking */ 3 5 3 6 /****^ HISTORY COMMENTS: 3 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 3 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 3 9* added the heap_header_ptr definition. 3 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 3 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 3 12* Modified to support control point management. These changes were actually 3 13* made in February 1985 by G. Palter. 3 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 3 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 3 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 3 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 3 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 3 19* (ITS pair). 3 20* END HISTORY COMMENTS */ 3 21 3 22 /* format: style2 */ 3 23 3 24 dcl sb ptr; /* the main pointer to the stack header */ 3 25 3 26 dcl 1 stack_header based (sb) aligned, 3 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 3 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 3 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 3 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 3 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 3 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 3 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 3 34 2 pad4 bit (2) unal, 3 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 3 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 3 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 3 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 3 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 3 40 2 null_ptr ptr, /* (16) */ 3 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 3 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 3 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 3 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 3 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 3 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 3 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 3 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 3 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 3 50 2 return_no_pop_op_ptr 3 51 ptr, /* (36) pointer to standard return / no pop operator */ 3 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 3 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 3 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 3 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 3 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 3 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 3 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 3 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 3 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 3 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 3 62 2 trace, 3 63 3 frames, 3 64 4 count fixed bin, /* (58) number of trace frames */ 3 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 3 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 3 67 2 pad2 bit (36), /* (61) */ 3 68 2 pad5 pointer; /* (62) pointer to future stuff */ 3 69 3 70 /* The following offset refers to a table within the pl1 operator table. */ 3 71 3 72 dcl tv_offset fixed bin init (361) internal static; 3 73 /* (551) octal */ 3 74 3 75 3 76 /* The following constants are offsets within this transfer vector table. */ 3 77 3 78 dcl ( 3 79 call_offset fixed bin init (271), 3 80 push_offset fixed bin init (272), 3 81 return_offset fixed bin init (273), 3 82 return_no_pop_offset fixed bin init (274), 3 83 entry_offset fixed bin init (275) 3 84 ) internal static; 3 85 3 86 3 87 3 88 3 89 3 90 /* The following declaration is an overlay of the whole stack header. Procedures which 3 91* move the whole stack header should use this overlay. 3 92**/ 3 93 3 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 3 95 3 96 3 97 3 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 105 106 107 /* */ 108 109 op_name = ""; /* initialize output arg */ 110 call get_operator_names_ptr_ (tname, onp); /* map translator name into appropriate pointer */ 111 masked_word = callp -> word & mask; 112 113 offset = bin (callp -> inst.address, 15); /* get offset in op transfer vector */ 114 if offset > 16384 115 then offset = offset - 32768; 116 117 if onp = addr (pl1_operator_names_$pl1_operator_names_) 118 then do; 119 120 if masked_word = tsp3_lp 121 then do; /* xfer to math routines via link */ 122 call get_link_ptr_ (callp, linkp, entryp); 123 /* get ptr to link */ 124 if linkp = null 125 then return; /* can't find name */ 126 127 auto_interpret_link_info.version = INTERPRET_LINK_INFO_VERSION_1; 128 129 call interpret_link_ (addr (auto_interpret_link_info), linkp, code); 130 if code = 0 131 then op_name = substr (auto_interpret_link_info.entry_point_name, 2); 132 return; 133 end; 134 135 if masked_word ^= tsx0_ap 136 then if masked_word ^= tsp3_ap 137 then if masked_word ^= tsp2_bp 138 then if masked_word ^= tra_ap 139 then go to try_alm_ops; /* not tsx0 pr0|k or tsp2 pr2|k or tsp3 pr0|k */ 140 141 call standard_operator_names; 142 143 end; 144 145 else if onp = null 146 then do; /* try alm */ 147 try_alm_ops: 148 sb = ptr (addr (nptr), 0); /* get ptr to stack header */ 149 if ^((callp -> inst.base_flag) & (callp -> inst.base = "111"b)) 150 then return; /* doesn't reference stack header */ 151 if callp -> inst.opcode = tsp4 152 then do; 153 if "000"b || callp -> inst.address = rel (addr (sb -> stack_header.call_op_ptr)) 154 then op_name = "alm_call"; 155 end; 156 else if callp -> inst.opcode = tsp2 157 then do; 158 if "000"b || callp -> inst.address = rel (addr (sb -> stack_header.push_op_ptr)) 159 then op_name = "alm_push"; 160 else if "000"b || callp -> inst.address = rel (addr (sb -> stack_header.entry_op_ptr)) 161 then op_name = "alm_entry"; 162 end; 163 else if callp -> inst.opcode = tra 164 then do; 165 if "000"b || callp -> inst.address = rel (addr (sb -> stack_header.return_op_ptr)) 166 then op_name = "alm_return"; 167 else if "000"b || callp -> inst.address = rel (addr (sb -> stack_header.return_no_pop_op_ptr)) 168 then op_name = "alm_return_no_pop"; 169 end; 170 else return; 171 end; 172 173 else do i = lbound (other_language_names, 1) to hbound (other_language_names, 1); 174 175 if onp = operator_names_ptr (other_language_names (i)) 176 then do; 177 if (callp -> word & other_language_masks (i)) = other_language_xfer_instruction (i) 178 then call standard_operator_names; 179 return; 180 end; 181 end; 182 183 return; /* unknown operator seg */ 184 185 operator_names_ptr: 186 proc (language_name) returns (ptr); 187 188 declare language_name char (8) varying; 189 declare op_names_segname char (24); 190 declare op_names_ptr ptr; 191 192 op_names_segname = language_name || "_operator_names_"; 193 call hcs_$make_ptr (onp, op_names_segname, op_names_segname, op_names_ptr, code); 194 195 return (op_names_ptr); 196 197 end; 198 199 200 standard_operator_names: 201 proc; 202 203 op_names_pt = onp; 204 if offset >= operator_names.first & offset <= operator_names.last 205 then do; 206 nptr = addr (operator_names.names (offset)); 207 goto common; 208 end; 209 210 else if offset >= operator_names.first_special & offset <= operator_names.last_special 211 then do; 212 do op_index = 1 to operator_names.number_special; 213 if operator_names.special (op_index).offset = offset 214 then do; 215 nptr = addr (operator_names.special (op_index).namep); 216 goto common; 217 end; 218 end; 219 end; 220 221 return; 222 223 common: 224 nsize = nptr -> name_pair.size; /* get size of name */ 225 nptr = ptr (nptr, nptr -> name_pair.rel_ptr); 226 227 op_name = name; /* copy name into arg */ 228 229 return; 230 end; 231 232 end find_operator_name_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/86 1033.8 find_operator_name_.pl1 >special_ldd>install>MR12.0-1206>find_operator_name_.pl1 76 1 11/02/83 1845.0 operator_names.incl.pl1 >ldd>include>operator_names.incl.pl1 78 2 06/06/83 0917.4 interpret_link_info.incl.pl1 >ldd>include>interpret_link_info.incl.pl1 105 3 11/04/86 1324.3 stack_header.incl.pl1 >special_ldd>install>MR12.0-1206>stack_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. INTERPRET_LINK_INFO_VERSION_1 000000 constant char(8) initial unaligned dcl 2-13 ref 127 addr builtin function dcl 85 ref 117 129 129 147 153 158 160 165 167 206 215 address 0(03) based bit(15) level 2 packed unaligned dcl 88 ref 113 153 158 160 165 167 auto_interpret_link_info 000126 automatic structure level 1 dcl 100 set ref 129 129 base based bit(3) level 2 packed unaligned dcl 88 ref 149 base_flag 0(29) based bit(1) level 2 packed unaligned dcl 88 ref 149 bin builtin function dcl 85 ref 113 call_op_ptr 36 based pointer level 2 dcl 3-26 set ref 153 callp parameter pointer dcl 29 set ref 12 111 113 122* 149 149 151 153 156 158 160 163 165 167 177 code 000112 automatic fixed bin(35,0) dcl 34 set ref 129* 130 193* entry_op_ptr 46 based pointer level 2 dcl 3-26 set ref 160 entry_point_name 12 000126 automatic char(260) level 2 dcl 100 set ref 130 entryp 000104 automatic pointer dcl 29 set ref 122* first based fixed bin(18,0) level 2 dcl 1-7 ref 204 206 213 215 first_special 2 based fixed bin(18,0) level 2 dcl 1-7 ref 210 get_link_ptr_ 000016 constant entry external dcl 82 ref 122 get_operator_names_ptr_ 000014 constant entry external dcl 80 ref 110 hbound builtin function dcl 85 ref 173 hcs_$make_ptr 000020 constant entry external dcl 83 ref 193 i 000111 automatic fixed bin(17,0) dcl 32 set ref 173* 175 177 177* inst based structure level 1 dcl 88 interpret_link_ 000012 constant entry external dcl 79 ref 129 interpret_link_info based structure level 1 dcl 2-5 language_name parameter varying char(8) dcl 188 ref 185 192 last 1 based fixed bin(18,0) level 2 dcl 1-7 ref 204 213 215 last_special 3 based fixed bin(18,0) level 2 dcl 1-7 ref 210 lbound builtin function dcl 85 ref 173 linkp 000102 automatic pointer dcl 29 set ref 122* 124 129* mask 000030 constant bit(36) initial dcl 43 ref 111 masked_word 000116 automatic bit(36) dcl 40 set ref 111* 120 135 135 135 135 name based char dcl 38 ref 227 name_pair based structure level 1 dcl 96 namep based bit(18) array level 3 packed unaligned dcl 1-7 set ref 215 names 5 based structure array level 2 dcl 1-7 set ref 206 nptr 000100 automatic pointer dcl 29 set ref 147 206* 215* 223 225* 225 225 227 nsize 000110 automatic fixed bin(17,0) dcl 32 set ref 223* 227 null builtin function dcl 85 ref 124 145 number_special 4 based fixed bin(17,0) level 2 dcl 1-7 ref 212 offset 000107 automatic fixed bin(17,0) dcl 32 in procedure "find_operator_name_" set ref 113* 114 114* 114 204 204 206 210 210 213 offset based fixed bin(18,0) array level 3 in structure "operator_names" dcl 1-7 in procedure "find_operator_name_" ref 213 onp 000114 automatic pointer dcl 37 set ref 110* 117 145 175 193* 203 op_index 000106 automatic fixed bin(17,0) dcl 32 set ref 212* 213 215* op_name parameter char(32) dcl 36 set ref 12 109* 130* 153* 158* 160* 165* 167* 227* op_names_pt 000124 automatic pointer dcl 1-5 set ref 203* 204 204 206 210 210 212 213 215 op_names_ptr 000276 automatic pointer dcl 190 set ref 193* 195 op_names_segname 000270 automatic char(24) unaligned dcl 189 set ref 192* 193* 193* opcode 0(18) based bit(10) level 2 packed unaligned dcl 88 ref 151 156 163 operator_names based structure level 1 dcl 1-7 other_language_masks 000002 constant bit(36) initial array dcl 69 ref 177 other_language_names 000012 constant varying char(8) initial array dcl 61 set ref 173 173 175* other_language_xfer_instruction 000006 constant bit(36) initial array dcl 63 ref 177 pl1_operator_names_$pl1_operator_names_ 000010 external static fixed bin(17,0) dcl 73 set ref 117 ptr builtin function dcl 85 ref 147 225 push_op_ptr 40 based pointer level 2 dcl 3-26 set ref 158 rel builtin function dcl 85 ref 153 158 160 165 167 rel_ptr based bit(18) level 2 packed unaligned dcl 96 ref 225 return_no_pop_op_ptr 44 based pointer level 2 dcl 3-26 set ref 167 return_op_ptr 42 based pointer level 2 dcl 3-26 set ref 165 sb 000260 automatic pointer dcl 3-24 set ref 147* 153 158 160 165 167 size 0(18) based fixed bin(17,0) level 2 packed unaligned dcl 96 ref 223 special based structure array level 2 dcl 1-7 stack_header based structure level 1 dcl 3-26 substr builtin function dcl 85 ref 130 tname parameter char unaligned dcl 28 set ref 12 110* tra 000121 automatic bit(10) initial dcl 52 set ref 52* 163 tra_ap constant bit(36) initial dcl 43 ref 135 tsp2 000120 automatic bit(10) initial dcl 52 set ref 52* 156 tsp2_bp 000027 constant bit(36) initial dcl 43 ref 135 tsp3 000122 automatic bit(10) initial dcl 52 set ref 52* tsp3_ap constant bit(36) initial dcl 43 ref 135 tsp3_lp 000026 constant bit(36) initial dcl 43 ref 120 tsp4 000123 automatic bit(10) initial dcl 52 set ref 52* 151 tsx0 000117 automatic bit(10) initial dcl 52 set ref 52* tsx0_ap constant bit(36) initial dcl 43 ref 135 version 000126 automatic char(8) level 2 dcl 100 set ref 127* word based bit(36) dcl 40 ref 111 177 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. call_offset internal static fixed bin(17,0) initial dcl 3-78 entry_offset internal static fixed bin(17,0) initial dcl 3-78 interpret_link_info_ptr automatic pointer dcl 2-15 push_offset internal static fixed bin(17,0) initial dcl 3-78 return_no_pop_offset internal static fixed bin(17,0) initial dcl 3-78 return_offset internal static fixed bin(17,0) initial dcl 3-78 stack_header_overlay based fixed bin(17,0) array dcl 3-94 tv_offset internal static fixed bin(17,0) initial dcl 3-72 NAMES DECLARED BY EXPLICIT CONTEXT. common 000570 constant label dcl 223 ref 207 216 find_operator_name_ 000071 constant entry external dcl 12 operator_names_ptr 000434 constant entry internal dcl 185 ref 175 standard_operator_names 000510 constant entry internal dcl 200 ref 141 177 try_alm_ops 000253 constant label dcl 147 ref 135 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 706 730 610 716 Length 1166 610 22 222 75 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME find_operator_name_ 248 external procedure is an external procedure. operator_names_ptr internal procedure shares stack frame of external procedure find_operator_name_. standard_operator_names internal procedure shares stack frame of external procedure find_operator_name_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME find_operator_name_ 000100 nptr find_operator_name_ 000102 linkp find_operator_name_ 000104 entryp find_operator_name_ 000106 op_index find_operator_name_ 000107 offset find_operator_name_ 000110 nsize find_operator_name_ 000111 i find_operator_name_ 000112 code find_operator_name_ 000114 onp find_operator_name_ 000116 masked_word find_operator_name_ 000117 tsx0 find_operator_name_ 000120 tsp2 find_operator_name_ 000121 tra find_operator_name_ 000122 tsp3 find_operator_name_ 000123 tsp4 find_operator_name_ 000124 op_names_pt find_operator_name_ 000126 auto_interpret_link_info find_operator_name_ 000260 sb find_operator_name_ 000270 op_names_segname operator_names_ptr 000276 op_names_ptr operator_names_ptr THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp call_ext_out_desc call_ext_out return_mac shorten_stack ext_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. get_link_ptr_ get_operator_names_ptr_ hcs_$make_ptr interpret_link_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. pl1_operator_names_$pl1_operator_names_ LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 000065 52 000104 109 000116 110 000123 111 000137 113 000144 114 000152 117 000156 120 000165 122 000170 124 000202 127 000206 129 000210 130 000225 132 000234 135 000235 141 000245 143 000246 145 000247 147 000253 149 000256 151 000265 153 000274 155 000307 156 000310 158 000312 160 000330 162 000341 163 000342 165 000344 167 000362 169 000373 170 000374 171 000375 173 000376 175 000403 177 000420 179 000430 181 000431 183 000433 185 000434 192 000436 193 000455 195 000504 200 000510 203 000511 204 000513 206 000521 207 000524 210 000525 212 000532 213 000541 215 000557 216 000564 218 000565 221 000567 223 000570 225 000574 227 000601 229 000607 ----------------------------------------------------------- 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