COMPILATION LISTING OF SEGMENT cv_acl_type_ Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/19/84 1108.2 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1984 * 4* * * 5* *********************************************************** */ 6 cv_acl_type_: 7 procedure (); 8 9 /* * CV_ACL_TYPE_ -- Procedure used by ACL commands to convert from one format 10* * of ACL representation to another. 11* * 12* * This family of procedures converts from one format of ACL structure to 13* * another, in order to accomodate the different formats used by existing 14* * hcs_ entrypoints. The ACL structures are reallocated, copied, and 15* * freed. There is only one ACL structure in use at any given time in 16* * this program: it is pointed to by acl_ptr, and the number of entries is 17* * given by acl_count. Except when actually calling the primitives, only 18* * the appropriate general ACL structure format will be used. Now, this 19* * may look rather inefficient, and, in truth, it is, but it is only used 20* * relatively rarely: IACL manipulations, since they are not now supported 21* * by fs_util_, privileged operations, likewise unsupported, and 22* * force_no_type operations, presumably infrequent. Also, the conversion 23* * if incoming ACL structures (that is, prior to calling the primitive) is 24* * restricted to uses in list_acl (and IACL) where specific access names 25* * were requested. The normal case, where no names were requested, will 26* * simply result in an immediate return because the pointer is null (or 27* * the count zero) 28* * 29* * 2 October 1983, W. Olin Sibert 30* */ 31 32 declare P_acl_ptr pointer parameter; 33 declare P_new_acl_ptr pointer parameter; 34 declare P_acl_count fixed bin parameter; 35 declare P_area_ptr pointer parameter; 36 declare P_old_type char (32) parameter; 37 declare P_new_type char (32) parameter; 38 39 declare system_area_ptr pointer; 40 declare system_area area based (system_area_ptr); 41 declare based_stuff fixed bin aligned based; /* For (invalid) general-purpose freeing operations */ 42 43 declare replace_sw bit (1) aligned; 44 declare old_acl_ptr pointer; 45 declare new_acl_ptr pointer; 46 declare old_type fixed bin; 47 declare new_type fixed bin; 48 49 declare acle_idx fixed bin; 50 declare old_acle_ptr pointer; 51 declare new_acle_ptr pointer; 52 53 declare sub_err_ entry options (variable); 54 55 declare GENERAL init (101) fixed bin internal static options (constant); 56 declare GENERAL_EXTENDED init (102) fixed bin internal static options (constant); 57 declare GENERAL_DELETE init (103) fixed bin internal static options (constant); 58 declare SEGMENT_ARRAY init (104) fixed bin internal static options (constant); 59 declare SEGMENT_STRUCTURE init (105) fixed bin internal static options (constant); 60 declare DIRECTORY_ARRAY init (106) fixed bin internal static options (constant); 61 declare DIRECTORY_STRUCTURE init (107) fixed bin internal static options (constant); 62 declare DELETE init (108) fixed bin internal static options (constant); 63 64 declare (addr, null) builtin; 65 66 /* */ 67 68 cv_acl_type_$create: 69 entry (P_acl_ptr, P_acl_count, P_area_ptr, P_old_type, P_new_type, P_new_acl_ptr); 70 71 replace_sw = "0"b; 72 goto COMMON; 73 74 75 76 cv_acl_type_$replace: 77 entry (P_acl_ptr, P_acl_count, P_area_ptr, P_old_type, P_new_type); 78 79 replace_sw = "1"b; 80 goto COMMON; 81 82 83 COMMON: 84 acl_ptr = P_acl_ptr; 85 acl_count = P_acl_count; 86 system_area_ptr = P_area_ptr; 87 88 /* Either a null pointer of zero count is sufficient evidence that there is nothing 89* there, and a null pointer and zero count will always be returned in that case */ 90 91 if (acl_count = 0) | (acl_ptr = null ()) then do; 92 if replace_sw then do; /* Update the output parameters */ 93 P_acl_count = 0; 94 P_acl_ptr = null (); 95 if (acl_ptr ^= null ()) then free acl_ptr -> based_stuff in (system_area); 96 end; 97 return; 98 end; 99 100 call get_type (P_old_type, old_type); 101 call get_type (P_new_type, new_type); 102 103 old_acl_ptr = acl_ptr; 104 105 /* These procedures do their own allocation, but the old one is freed after all is done. 106* There is a race here: if this procedure is interrupted during the copying, the old one 107* will never be freed. This, however, hardly seems exciting, or worth the expense of 108* setting up a cleanup handler to handle. */ 109 110 /* Only a few of the sensible conversion are supported in this procedure, by the way: 111* those which are of interest to the standard ACL commands. */ 112 113 if (old_type = GENERAL) & (new_type = SEGMENT_ARRAY) then call general_to_segment_array (); 114 else if (old_type = GENERAL) & (new_type = DIRECTORY_ARRAY) then call general_to_directory_array (); 115 else if (old_type = SEGMENT_ARRAY) & (new_type = GENERAL) then call segment_array_to_general (); 116 else if (old_type = DIRECTORY_ARRAY) & (new_type = GENERAL) then call directory_array_to_general (); 117 else call bad_conversion (); 118 119 if replace_sw then do; 120 P_acl_ptr = new_acl_ptr; 121 free old_acl_ptr -> based_stuff in (system_area); 122 end; 123 else P_new_acl_ptr = new_acl_ptr; 124 125 return; 126 127 /* */ 128 129 general_to_segment_array: 130 procedure (); 131 132 if (acl_ptr -> general_acl.version ^= GENERAL_ACL_VERSION_1) then call bad_type (); 133 134 allocate segment_acl_array in (system_area) set (new_acl_ptr); 135 136 do acle_idx = 1 to acl_count; /* Copy relevant portions of each entry */ 137 old_acle_ptr = addr (acl_ptr -> general_acl.entries (acle_idx)); 138 new_acle_ptr = addr (new_acl_ptr -> segment_acl_array (acle_idx)); 139 new_acle_ptr -> segment_acl_entry.access_name = old_acle_ptr -> general_acl_entry.access_name; 140 new_acle_ptr -> segment_acl_entry.mode = old_acle_ptr -> general_acl_entry.mode; 141 new_acle_ptr -> segment_acl_entry.status_code = old_acle_ptr -> general_acl_entry.status_code; 142 new_acle_ptr -> segment_acl_entry.extended_mode = ""b; 143 end; 144 145 return; 146 end general_to_segment_array; 147 148 149 150 general_to_directory_array: 151 procedure (); 152 153 if (acl_ptr -> general_acl.version ^= GENERAL_ACL_VERSION_1) then call bad_type (); 154 155 allocate directory_acl_array in (system_area) set (new_acl_ptr); 156 157 do acle_idx = 1 to acl_count; /* Copy relevant portions of each entry */ 158 old_acle_ptr = addr (acl_ptr -> general_acl.entries (acle_idx)); 159 new_acle_ptr = addr (new_acl_ptr -> directory_acl_array (acle_idx)); 160 new_acle_ptr -> directory_acl_entry.access_name = old_acle_ptr -> general_acl_entry.access_name; 161 new_acle_ptr -> directory_acl_entry.mode = old_acle_ptr -> general_acl_entry.mode; 162 new_acle_ptr -> directory_acl_entry.status_code = old_acle_ptr -> general_acl_entry.status_code; 163 end; 164 165 return; 166 end general_to_directory_array; 167 168 /* */ 169 170 segment_array_to_general: 171 procedure (); 172 173 allocate general_acl in (system_area) set (new_acl_ptr); 174 new_acl_ptr -> general_acl.count = acl_count; 175 new_acl_ptr -> general_acl.version = GENERAL_ACL_VERSION_1; 176 177 do acle_idx = 1 to acl_count; /* Copy relevant portions of each entry */ 178 old_acle_ptr = addr (acl_ptr -> segment_acl_array (acle_idx)); 179 new_acle_ptr = addr (new_acl_ptr -> general_acl.entries (acle_idx)); 180 new_acle_ptr -> general_acl_entry.access_name = old_acle_ptr -> segment_acl_entry.access_name; 181 new_acle_ptr -> general_acl_entry.mode = old_acle_ptr -> segment_acl_entry.mode; 182 new_acle_ptr -> general_acl_entry.status_code = old_acle_ptr -> segment_acl_entry.status_code; 183 end; 184 185 return; 186 end segment_array_to_general; 187 188 189 190 directory_array_to_general: 191 procedure (); 192 193 allocate general_acl in (system_area) set (new_acl_ptr); 194 new_acl_ptr -> general_acl.count = acl_count; 195 new_acl_ptr -> general_acl.version = GENERAL_ACL_VERSION_1; 196 197 do acle_idx = 1 to acl_count; /* Copy relevant portions of each entry */ 198 old_acle_ptr = addr (acl_ptr -> directory_acl_array (acle_idx)); 199 new_acle_ptr = addr (new_acl_ptr -> general_acl.entries (acle_idx)); 200 new_acle_ptr -> general_acl_entry.access_name = old_acle_ptr -> directory_acl_entry.access_name; 201 new_acle_ptr -> general_acl_entry.mode = old_acle_ptr -> directory_acl_entry.mode; 202 new_acle_ptr -> general_acl_entry.status_code = old_acle_ptr -> directory_acl_entry.status_code; 203 end; 204 205 return; 206 end directory_array_to_general; 207 208 /* */ 209 210 get_type: 211 procedure (P_type_name, P_type); 212 213 declare P_type_name char (*) parameter; 214 declare P_type fixed bin parameter; 215 216 declare type_name char (32); 217 218 /* This procedure is strictly used as an interface by acl_commands_; nonetheless, in order 219* to avoid having to share definitions for the type constants, types are passed as 220* character strings to make things more readable, and converted here to integers for 221* greater efficiency. */ 222 223 224 type_name = P_type_name; 225 if (type_name = "general") then P_type = GENERAL; 226 else if (type_name = "segment_array") then P_type = SEGMENT_ARRAY; 227 else if (type_name = "directory_array") then P_type = DIRECTORY_ARRAY; 228 else if (type_name = "general_extended") then P_type = GENERAL_EXTENDED; 229 else if (type_name = "general_delete") then P_type = GENERAL_DELETE; 230 else if (type_name = "delete") then P_type = DELETE; 231 else if (type_name = "segment_structure") then P_type = SEGMENT_STRUCTURE; 232 else if (type_name = "directory_structure") then P_type = DIRECTORY_STRUCTURE; 233 else call bad_conversion (); 234 235 return; 236 end get_type; 237 238 239 240 bad_conversion: 241 procedure (); 242 243 call sub_err_ (0, "cv_acl_type_", ACTION_CANT_RESTART, (null ()), (0), 244 "Undefined operation: cannot convert from ACL type ""^a"" to type ""^a"".", 245 P_old_type, P_new_type); 246 247 end bad_conversion; 248 249 250 251 bad_type: 252 procedure (); 253 254 call sub_err_ (0, "cv_acl_type_", ACTION_CANT_RESTART, (null ()), (0), 255 "Input ACL is not of specified type ""^a"".", P_old_type); 256 257 end bad_type; 258 259 /* Begin include file -- acl_structures.incl.pl1 BIM 3/82 */ 1 2 /* format: style3,indcomtxt,idind30 */ 1 3 1 4 declare acl_ptr pointer; 1 5 declare acl_count fixed bin; 1 6 1 7 declare 1 general_acl aligned based (acl_ptr), /* for fs_util_ */ 1 8 2 version char (8) aligned, 1 9 2 count fixed bin, 1 10 2 entries (acl_count refer (general_acl.count)) aligned like general_acl_entry; 1 11 1 12 declare 1 general_acl_entry based, 1 13 2 access_name character (32) unaligned, 1 14 2 mode bit (36) aligned, 1 15 2 status_code fixed bin (35); 1 16 1 17 1 18 declare 1 general_extended_acl aligned based (acl_ptr), /* for fs_util_ */ 1 19 2 version char (8) aligned, 1 20 2 count fixed bin, 1 21 2 entries (acl_count refer (general_extended_acl.count)) aligned like general_extended_acl_entry; 1 22 1 23 declare 1 general_extended_acl_entry aligned based, 1 24 2 access_name character (32) unaligned, 1 25 2 mode bit (36) aligned, 1 26 2 extended_mode bit (36) aligned, 1 27 2 status_code fixed bin (35); 1 28 1 29 1 30 declare 1 general_delete_acl aligned based (acl_ptr), /* for file_system_ */ 1 31 2 version char (8) aligned, 1 32 2 count fixed bin, 1 33 2 entries (acl_count refer (general_delete_acl.count)) aligned like delete_acl_entry; 1 34 1 35 declare 1 general_delete_acl_entry aligned based, 1 36 2 access_name character (32) unaligned, 1 37 2 status_code fixed bin (35); 1 38 1 39 1 40 declare 1 segment_acl aligned based (acl_ptr), 1 41 2 version fixed bin, 1 42 2 count fixed bin, 1 43 2 entries (acl_count refer (segment_acl.count)) aligned like segment_acl_entry; 1 44 1 45 declare 1 segment_acl_entry like general_extended_acl_entry aligned based; 1 46 declare 1 segment_acl_array (acl_count) aligned like segment_acl_entry based (acl_ptr); 1 47 1 48 1 49 declare 1 directory_acl aligned based (acl_ptr), 1 50 2 version fixed bin, 1 51 2 count fixed bin, 1 52 2 entries (acl_count refer (directory_acl.count)) aligned like directory_acl_entry; 1 53 1 54 declare 1 directory_acl_entry like general_acl_entry aligned based; 1 55 declare 1 directory_acl_array (acl_count) aligned like directory_acl_entry based (acl_ptr); 1 56 1 57 1 58 declare 1 delete_acl based (acl_ptr) aligned, 1 59 2 version fixed bin, 1 60 2 count fixed bin, 1 61 2 entries (acl_count refer (delete_acl.count)) aligned like delete_acl_entry; 1 62 1 63 declare 1 delete_acl_entry like general_delete_acl_entry aligned based; 1 64 declare 1 delete_acl_array (acl_count) aligned like delete_acl_entry based (acl_ptr); 1 65 1 66 1 67 declare (SEG_ACL_VERSION_1 init ("sga1"), 1 68 DIR_ACL_VERSION_1 init ("dra1"), 1 69 DELETE_ACL_VERSION_1 init ("dla1")) 1 70 char (4) int static options (constant); 1 71 1 72 declare (GENERAL_ACL_VERSION_1 init ("gacl001"), 1 73 GENERAL_EXTENDED_ACL_VERSION_1 init ("gxacl001"), 1 74 GENERAL_DELETE_ACL_VERSION_1 init ("gdacl001")) 1 75 char (8) internal static options (constant); 1 76 1 77 declare ACL_VERSION_1 fixed bin init (1) int static options (constant); 1 78 1 79 /* End include file acl_structures.incl.pl1 */ 259 260 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 2 2 /* format: style3 */ 2 3 2 4 /* These constants are to be used for the flags argument of sub_err_ */ 2 5 /* They are just "string (condition_info_header.action_flags)" */ 2 6 2 7 declare ( 2 8 ACTION_CAN_RESTART init (""b), 2 9 ACTION_CANT_RESTART init ("1"b), 2 10 ACTION_DEFAULT_RESTART 2 11 init ("01"b), 2 12 ACTION_QUIET_RESTART 2 13 init ("001"b), 2 14 ACTION_SUPPORT_SIGNAL 2 15 init ("0001"b) 2 16 ) bit (36) aligned internal static options (constant); 2 17 2 18 /* End include file */ 260 261 262 end cv_acl_type_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/19/84 1106.5 cv_acl_type_.pl1 >special_ldd>online>6974-11/19/84>cv_acl_type_.pl1 259 1 10/14/83 1606.6 acl_structures.incl.pl1 >ldd>include>acl_structures.incl.pl1 260 2 04/16/82 0958.1 sub_err_flags.incl.pl1 >ldd>include>sub_err_flags.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. ACTION_CANT_RESTART 000010 constant bit(36) initial dcl 2-7 set ref 243* 254* DELETE constant fixed bin(17,0) initial dcl 62 ref 230 DIRECTORY_ARRAY constant fixed bin(17,0) initial dcl 60 ref 114 116 227 DIRECTORY_STRUCTURE constant fixed bin(17,0) initial dcl 61 ref 232 GENERAL constant fixed bin(17,0) initial dcl 55 ref 113 114 115 116 225 GENERAL_ACL_VERSION_1 000000 constant char(8) initial unaligned dcl 1-72 ref 132 153 175 195 GENERAL_DELETE constant fixed bin(17,0) initial dcl 57 ref 229 GENERAL_EXTENDED constant fixed bin(17,0) initial dcl 56 ref 228 P_acl_count parameter fixed bin(17,0) dcl 34 set ref 68 76 85 93* P_acl_ptr parameter pointer dcl 32 set ref 68 76 83 94* 120* P_area_ptr parameter pointer dcl 35 ref 68 76 86 P_new_acl_ptr parameter pointer dcl 33 set ref 68 123* P_new_type parameter char(32) unaligned dcl 37 set ref 68 76 101* 243* P_old_type parameter char(32) unaligned dcl 36 set ref 68 76 100* 243* 254* P_type parameter fixed bin(17,0) dcl 214 set ref 210 225* 226* 227* 228* 229* 230* 231* 232* P_type_name parameter char unaligned dcl 213 ref 210 224 SEGMENT_ARRAY constant fixed bin(17,0) initial dcl 58 ref 113 115 226 SEGMENT_STRUCTURE constant fixed bin(17,0) initial dcl 59 ref 231 access_name based char(32) level 2 in structure "general_acl_entry" packed unaligned dcl 1-12 in procedure "cv_acl_type_" set ref 139 160 180* 200* access_name based char(32) level 2 in structure "directory_acl_entry" packed unaligned dcl 1-54 in procedure "cv_acl_type_" set ref 160* 200 access_name based char(32) level 2 in structure "segment_acl_entry" packed unaligned dcl 1-45 in procedure "cv_acl_type_" set ref 139* 180 acl_count 000122 automatic fixed bin(17,0) dcl 1-5 set ref 85* 91 134 136 155 157 173 173 174 177 193 193 194 197 acl_ptr 000120 automatic pointer dcl 1-4 set ref 83* 91 95 95 103 132 137 153 158 178 198 acle_idx 000112 automatic fixed bin(17,0) dcl 49 set ref 136* 137 138* 157* 158 159* 177* 178 179* 197* 198 199* addr builtin function dcl 64 ref 137 138 158 159 178 179 198 199 based_stuff based fixed bin(17,0) dcl 41 ref 95 121 count 2 based fixed bin(17,0) level 2 dcl 1-7 set ref 173* 174* 193* 194* delete_acl_entry based structure level 1 dcl 1-63 directory_acl_array based structure array level 1 dcl 1-55 set ref 155 159 198 directory_acl_entry based structure level 1 dcl 1-54 entries 3 based structure array level 2 dcl 1-7 set ref 137 158 179 199 extended_mode 11 based bit(36) level 2 dcl 1-45 set ref 142* general_acl based structure level 1 dcl 1-7 set ref 173 193 general_acl_entry based structure level 1 unaligned dcl 1-12 general_delete_acl_entry based structure level 1 dcl 1-35 general_extended_acl_entry based structure level 1 dcl 1-23 mode 10 based bit(36) level 2 in structure "general_acl_entry" dcl 1-12 in procedure "cv_acl_type_" set ref 140 161 181* 201* mode 10 based bit(36) level 2 in structure "directory_acl_entry" dcl 1-54 in procedure "cv_acl_type_" set ref 161* 201 mode 10 based bit(36) level 2 in structure "segment_acl_entry" dcl 1-45 in procedure "cv_acl_type_" set ref 140* 181 new_acl_ptr 000106 automatic pointer dcl 45 set ref 120 123 134* 138 155* 159 173* 174 175 179 193* 194 195 199 new_acle_ptr 000116 automatic pointer dcl 51 set ref 138* 139 140 141 142 159* 160 161 162 179* 180 181 182 199* 200 201 202 new_type 000111 automatic fixed bin(17,0) dcl 47 set ref 101* 113 114 115 116 null builtin function dcl 64 ref 91 94 95 243 254 old_acl_ptr 000104 automatic pointer dcl 44 set ref 103* 121 old_acle_ptr 000114 automatic pointer dcl 50 set ref 137* 139 140 141 158* 160 161 162 178* 180 181 182 198* 200 201 202 old_type 000110 automatic fixed bin(17,0) dcl 46 set ref 100* 113 114 115 116 replace_sw 000102 automatic bit(1) dcl 43 set ref 71* 79* 92 119 segment_acl_array based structure array level 1 dcl 1-46 set ref 134 138 178 segment_acl_entry based structure level 1 dcl 1-45 status_code 11 based fixed bin(35,0) level 2 in structure "directory_acl_entry" dcl 1-54 in procedure "cv_acl_type_" set ref 162* 202 status_code 12 based fixed bin(35,0) level 2 in structure "segment_acl_entry" dcl 1-45 in procedure "cv_acl_type_" set ref 141* 182 status_code 11 based fixed bin(35,0) level 2 in structure "general_acl_entry" dcl 1-12 in procedure "cv_acl_type_" set ref 141 162 182* 202* sub_err_ 000010 constant entry external dcl 53 ref 243 254 system_area based area(1024) dcl 40 ref 95 121 134 155 173 193 system_area_ptr 000100 automatic pointer dcl 39 set ref 86* 95 121 134 155 173 193 type_name 000172 automatic char(32) unaligned dcl 216 set ref 224* 225 226 227 228 229 230 231 232 version based char(8) level 2 dcl 1-7 set ref 132 153 175* 195* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACL_VERSION_1 internal static fixed bin(17,0) initial dcl 1-77 ACTION_CAN_RESTART internal static bit(36) initial dcl 2-7 ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 2-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 2-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 2-7 DELETE_ACL_VERSION_1 internal static char(4) initial unaligned dcl 1-67 DIR_ACL_VERSION_1 internal static char(4) initial unaligned dcl 1-67 GENERAL_DELETE_ACL_VERSION_1 internal static char(8) initial unaligned dcl 1-72 GENERAL_EXTENDED_ACL_VERSION_1 internal static char(8) initial unaligned dcl 1-72 SEG_ACL_VERSION_1 internal static char(4) initial unaligned dcl 1-67 delete_acl based structure level 1 dcl 1-58 delete_acl_array based structure array level 1 dcl 1-64 directory_acl based structure level 1 dcl 1-49 general_delete_acl based structure level 1 dcl 1-30 general_extended_acl based structure level 1 dcl 1-18 segment_acl based structure level 1 dcl 1-40 NAMES DECLARED BY EXPLICIT CONTEXT. COMMON 000153 constant label dcl 83 ref 72 80 bad_conversion 000662 constant entry internal dcl 240 ref 117 233 bad_type 000743 constant entry internal dcl 251 ref 132 153 cv_acl_type_ 000113 constant entry external dcl 6 cv_acl_type_$create 000127 constant entry external dcl 68 cv_acl_type_$replace 000143 constant entry external dcl 76 directory_array_to_general 000504 constant entry internal dcl 190 ref 116 general_to_directory_array 000367 constant entry internal dcl 150 ref 114 general_to_segment_array 000316 constant entry internal dcl 129 ref 113 get_type 000552 constant entry internal dcl 210 ref 100 101 segment_array_to_general 000434 constant entry internal dcl 170 ref 115 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1110 1122 1021 1120 Length 1330 1021 12 171 66 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME cv_acl_type_ 264 external procedure is an external procedure. general_to_segment_array internal procedure shares stack frame of external procedure cv_acl_type_. general_to_directory_array internal procedure shares stack frame of external procedure cv_acl_type_. segment_array_to_general internal procedure shares stack frame of external procedure cv_acl_type_. directory_array_to_general internal procedure shares stack frame of external procedure cv_acl_type_. get_type internal procedure shares stack frame of external procedure cv_acl_type_. bad_conversion internal procedure shares stack frame of external procedure cv_acl_type_. bad_type internal procedure shares stack frame of external procedure cv_acl_type_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME cv_acl_type_ 000100 system_area_ptr cv_acl_type_ 000102 replace_sw cv_acl_type_ 000104 old_acl_ptr cv_acl_type_ 000106 new_acl_ptr cv_acl_type_ 000110 old_type cv_acl_type_ 000111 new_type cv_acl_type_ 000112 acle_idx cv_acl_type_ 000114 old_acle_ptr cv_acl_type_ 000116 new_acle_ptr cv_acl_type_ 000120 acl_ptr cv_acl_type_ 000122 acl_count cv_acl_type_ 000172 type_name get_type THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_out_desc return ext_entry alloc_based free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. sub_err_ NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 6 000112 68 000120 71 000134 72 000135 76 000136 79 000150 80 000152 83 000153 85 000157 86 000161 91 000164 92 000171 93 000173 94 000174 95 000176 97 000203 100 000204 101 000220 103 000235 113 000237 114 000251 115 000260 116 000272 117 000301 119 000302 120 000304 121 000307 122 000311 123 000312 125 000315 129 000316 132 000317 134 000325 136 000333 137 000343 138 000347 139 000354 140 000357 141 000361 142 000363 143 000364 145 000366 150 000367 153 000370 155 000376 157 000404 158 000413 159 000417 160 000422 161 000425 162 000427 163 000431 165 000433 170 000434 173 000435 175 000446 177 000451 178 000461 179 000465 180 000472 181 000475 182 000477 183 000501 185 000503 190 000504 193 000505 195 000516 197 000521 198 000531 199 000535 200 000540 201 000543 202 000545 203 000547 205 000551 210 000552 224 000563 225 000570 226 000577 227 000606 228 000615 229 000624 230 000633 231 000642 232 000651 233 000660 235 000661 240 000662 243 000663 247 000742 251 000743 254 000744 257 001020 ----------------------------------------------------------- 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