COMPILATION LISTING OF SEGMENT set_translator_search_rules Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 02/16/88 1442.0 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 14 /****^ HISTORY COMMENTS: 15* 1) change(88-02-16,Lippard), approve(88-02-16,MCR7822), 16* audit(88-02-16,Blair): 17* Modified to use "uid" instead of "pad2". 18* END HISTORY COMMENTS */ 19 20 /* Translator Search Rules Commands 21* This is just a write-around to search_paths_ and the "translator" search list. 22* 23* Rewritten 6-Nov-78 by Monte Davidoff. 24**/ 25 set_translator_search_rules: 26 stsr: 27 procedure; 28 29 /* automatic */ 30 31 declare command char (32); /* what command this is */ 32 declare sl_info_ptr pointer; 33 34 /* builtin */ 35 36 declare null builtin; 37 declare search builtin; 38 declare substr builtin; 39 40 /* condition */ 41 42 declare cleanup condition; 43 44 /* internal static */ 45 46 declare LIST char (10) internal static options (constant) initial ("translator"); 47 48 /* external static */ 49 50 declare error_table_$action_not_performed 51 fixed binary (35) external static; 52 declare error_table_$badopt fixed binary (35) external static; 53 54 /* external entry */ 55 56 declare absolute_pathname_ entry (char (*), char (*), fixed binary (35)); 57 declare com_err_ entry options (variable); 58 declare cu_$arg_count entry (fixed binary); 59 declare cu_$arg_ptr entry (fixed binary, pointer, fixed binary (21), fixed binary (35)); 60 declare expand_pathname_ entry (char (*), char (*), char (*), fixed binary (35)); 61 declare get_system_free_area_ entry () returns (pointer); 62 declare hcs_$status_minf entry (char (*), char (*), fixed binary (1), fixed binary (2), fixed binary (24), 63 fixed binary (35)); 64 declare ioa_ entry options (variable); 65 declare search_paths_$get entry (char (*), bit (36), char (*), pointer, pointer, fixed binary, pointer, 66 fixed binary (35)); 67 declare search_paths_$set entry (char (*), pointer, pointer, fixed binary (35)); 68 1 1 /* BEGIN INCLUDE FILE . . . sl_info.incl.pl1 */ 1 2 1 3 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(87-11-16,Lippard), approve(87-12-21,MCR7822), 1 7* audit(88-02-09,Blair), install(88-02-16,MR12.2-1023): 1 8* Modified to add INITIATED_SEGS type. 1 9* 2) change(87-11-19,Lippard), approve(87-12-21,MCR7822), 1 10* audit(88-02-09,Blair), install(88-02-16,MR12.2-1023): 1 11* Added uid to sl_info structure. 1 12* END HISTORY COMMENTS */ 1 13 1 14 1 15 declare 1 sl_info aligned based (sl_info_p), 1 16 2 version fixed binary, /* Must be 1 */ 1 17 2 num_paths fixed binary, /* Number of search paths */ 1 18 2 change_index_p pointer, /* Pointer to search list's update count */ 1 19 2 change_index fixed binary (71), /* This search list's update count */ 1 20 2 pad1 (6) bit (36), /* Must be zero */ 1 21 2 paths (sl_info_num_paths refer (sl_info.num_paths)), 1 22 3 type fixed binary, /* Type of search path */ 1 23 3 code fixed binary (35), /* Standard status code of search path */ 1 24 3 uid bit (36), /* Unique ID */ 1 25 3 pathname char (168) unaligned; /* Search pathname */ 1 26 1 27 declare sl_info_num_paths fixed binary; 1 28 declare sl_info_p pointer; 1 29 declare sl_info_version_1 fixed binary internal static options (constant) initial (1); 1 30 1 31 /* Keyword Types */ 1 32 1 33 declare ABSOLUTE_PATH fixed binary internal static options (constant) initial (0); 1 34 declare UNEXPANDED_PATH fixed binary internal static options (constant) initial (1); 1 35 declare REFERENCING_DIR fixed binary internal static options (constant) initial (3); 1 36 declare WORKING_DIR fixed binary internal static options (constant) initial (4); 1 37 declare PROCESS_DIR fixed binary internal static options (constant) initial (5); 1 38 declare HOME_DIR fixed binary internal static options (constant) initial (6); 1 39 declare INITIATED_SEGS fixed binary internal static options (constant) initial (7); 1 40 1 41 /* END INCLUDE FILE . . . sl_info.incl.pl1 */ 69 70 71 /* set_translator_search_rules */ 72 73 command = "set_translator_search_rules"; 74 sl_info_ptr = null; 75 on cleanup 76 call cleanup_; 77 call set_translator_search_rules_; 78 call cleanup_; 79 return; 80 81 print_translator_search_rules: 82 ptsr: 83 entry; 84 85 command = "print_translator_search_rules"; 86 sl_info_ptr = null; 87 on cleanup 88 call cleanup_; 89 begin; 90 declare code fixed binary (35); 91 declare pathx fixed binary; 92 93 call search_paths_$get (LIST, ""b, "", null, get_system_free_area_ (), sl_info_version_1, sl_info_ptr, code); 94 if code = 0 95 then do pathx = 1 to sl_info_ptr -> sl_info.num_paths; 96 call ioa_ ("^a", sl_info_ptr -> sl_info.paths (pathx).pathname); 97 end; 98 else call com_err_ (code, command, LIST); 99 end; 100 call cleanup_; 101 return; 102 103 set_translator_search_rules_: 104 procedure; 105 106 declare arg_count fixed binary; 107 declare arg_length fixed binary (21); 108 declare arg_ptr pointer; 109 declare argx fixed binary; 110 declare code fixed binary (35); 111 declare default_sw bit (1); 112 declare pathx fixed binary; 113 114 declare arg_string char (arg_length) based (arg_ptr); 115 116 call cu_$arg_count (arg_count); 117 default_sw = "0"b; 118 do argx = 1 to arg_count while ( ^default_sw); 119 call cu_$arg_ptr (argx, arg_ptr, arg_length, code); 120 if code ^= 0 121 then do; 122 call com_err_ (code, command, "Argument ^d.", argx); 123 return; 124 end; 125 if arg_string = "-default" 126 then default_sw = "1"b; 127 end; 128 129 if default_sw 130 then call create_sl_info (arg_count + 2, sl_info_ptr); 131 else call create_sl_info (arg_count, sl_info_ptr); 132 133 pathx = 0; 134 do argx = 1 to arg_count; 135 pathx = pathx + 1; 136 call cu_$arg_ptr (argx, arg_ptr, arg_length, code); 137 if code ^= 0 138 then do; 139 call com_err_ (code, command, "Argument ^d.", argx); 140 return; 141 end; 142 if arg_string = "-default" 143 then do; 144 sl_info_ptr -> sl_info.paths (pathx).type = WORKING_DIR; 145 sl_info_ptr -> sl_info.paths (pathx).pathname = "-working_dir"; 146 call check_for_duplicates (sl_info_ptr, pathx, code); 147 if code ^= 0 148 then return; 149 pathx = pathx + 1; 150 151 sl_info_ptr -> sl_info.paths (pathx).type = UNEXPANDED_PATH; 152 sl_info_ptr -> sl_info.paths (pathx).pathname = ">udd>[user project]>include"; 153 call check_for_duplicates (sl_info_ptr, pathx, code); 154 if code ^= 0 155 then return; 156 pathx = pathx + 1; 157 158 sl_info_ptr -> sl_info.paths (pathx).type = ABSOLUTE_PATH; 159 sl_info_ptr -> sl_info.paths (pathx).pathname = ">ldd>include"; 160 call check_for_duplicates (sl_info_ptr, pathx, code); 161 if code ^= 0 162 then return; 163 end; 164 else do; 165 call get_path_type (arg_string, sl_info_ptr -> sl_info.paths (pathx).type, 166 sl_info_ptr -> sl_info.paths (pathx).pathname, code); 167 if code ^= 0 168 then return; 169 170 call check_for_duplicates (sl_info_ptr, pathx, code); 171 if code ^= 0 172 then return; 173 end; 174 end; 175 176 call set_the_search_paths_of_a_search_list (sl_info_ptr, code); 177 if code ^= 0 178 then return; 179 180 call check_paths_for_warnings (sl_info_ptr); 181 end set_translator_search_rules_; 182 183 /* Allocate and initialize an sl_info structure */ 184 185 create_sl_info: 186 procedure (path_count, sl_info_ptr); 187 188 declare path_count fixed binary; /* (Input) number of search paths in sl_info */ 189 declare sl_info_ptr pointer; /* (Output) pointer to sl_info */ 190 191 sl_info_ptr = null; 192 if path_count ^= 0 193 then do; 194 sl_info_num_paths = path_count; 195 allocate sl_info set (sl_info_ptr); 196 197 sl_info_ptr -> sl_info.version = sl_info_version_1; 198 sl_info_ptr -> sl_info.change_index_p = null; 199 sl_info_ptr -> sl_info.change_index = 0; 200 sl_info_ptr -> sl_info.pad1 (*) = ""b; 201 sl_info_ptr -> sl_info.paths (*).code = 0; 202 sl_info_ptr -> sl_info.paths (*).uid = ""b; 203 end; 204 end create_sl_info; 205 206 /* Convert an argument into a search path type and pathname */ 207 208 get_path_type: 209 procedure (search_path, type, pathname, code); 210 211 declare search_path char (*); /* (Input) search path to convert */ 212 declare type fixed binary; /* (Output) search path type */ 213 declare pathname char (*); /* (Output) search pathname */ 214 declare code fixed binary (35); /* (Output) standard status code */ 215 216 type = 0; 217 pathname = search_path; 218 code = 0; 219 if is_control_arg (search_path) 220 then if search_path = "-home_dir" 221 then type = HOME_DIR; 222 else if search_path = "-referencing_dir" 223 then type = REFERENCING_DIR; 224 else if search_path = "-working_dir" | search_path = "-wd" 225 then do; 226 type = WORKING_DIR; 227 pathname = "-working_dir"; 228 end; 229 else do; 230 code = error_table_$badopt; 231 call com_err_ (code, command, "^a", search_path); 232 end; 233 else do; 234 if search (search_path, "[]") = 0 235 then type = ABSOLUTE_PATH; 236 else type = UNEXPANDED_PATH; 237 238 call absolute_pathname_ (search_path, pathname, code); 239 if code ^= 0 240 then call com_err_ (code, command, "^a", search_path); 241 end; 242 end get_path_type; 243 244 /* Check for a duplicate entry in sl_info */ 245 246 check_for_duplicates: 247 procedure (sl_info_ptr, pathx, code); 248 249 declare sl_info_ptr pointer; /* (Input) pointer to sl_info */ 250 declare pathx fixed binary; /* (Input) last used entry in sl_info */ 251 declare code fixed binary (35); /* (Output) non-standard status code */ 252 253 code = 0; 254 if path_index (sl_info_ptr, sl_info_ptr -> sl_info.paths (pathx).pathname) >= pathx 255 then return; 256 257 call com_err_ (0, command, "Search path specified twice. ^a", sl_info_ptr -> sl_info.paths (pathx).pathname); 258 code = 1; 259 end check_for_duplicates; 260 261 /* Check if an argument is a control-argument. 262* 263* A control-argument is defined for this procedure to be anything starting with a hyphen. 264**/ 265 is_control_arg: 266 procedure (arg) returns (bit (1)); 267 268 declare arg char (*); /* (Input) a command argument */ 269 270 if arg = "" 271 then return ("0"b); 272 else return (substr (arg, 1, 1) = "-"); 273 end is_control_arg; 274 275 /* Find the index of a search path in sl_info */ 276 277 path_index: 278 procedure (sl_info_ptr, pathname) returns (fixed binary); 279 280 declare sl_info_ptr pointer; /* (Input) pointer to sl_info */ 281 declare pathname char (*); /* (Input) pathname to look for */ 282 283 declare pathx fixed binary; 284 285 do pathx = 1 to sl_info_ptr -> sl_info.num_paths while (pathname ^= sl_info_ptr -> sl_info.paths (pathx).pathname); 286 end; 287 if pathx > sl_info_ptr -> sl_info.num_paths 288 then return (0); 289 else return (pathx); 290 end path_index; 291 292 /* Change a search list. 293* 294* Appropriate error and warning messages are printed. 295**/ 296 set_the_search_paths_of_a_search_list: 297 procedure (sl_info_ptr, code); 298 299 declare sl_info_ptr pointer; /* (Updated) pointer to sl_info with the new search list */ 300 declare code fixed binary (35); /* (Output) standard status code */ 301 302 call search_paths_$set (LIST, null, sl_info_ptr, code); 303 if code ^= 0 304 then do; 305 if code = error_table_$action_not_performed 306 then do; /* change to "begin;" when compiler bug 1789 is fixed in MR7.0 */ 307 declare pathx fixed binary; 308 309 do pathx = 1 to sl_info_ptr -> sl_info.num_paths; 310 if sl_info_ptr -> sl_info.paths (pathx).code ^= 0 311 then call com_err_ (sl_info_ptr -> sl_info.paths (pathx).code, command, "^a", 312 sl_info_ptr -> sl_info.paths (pathx).pathname); 313 end; 314 end; 315 316 else call com_err_ (code, command, LIST); 317 end; 318 319 if sl_info_ptr ^= null 320 then do; 321 free sl_info_ptr -> sl_info; 322 sl_info_ptr = null; 323 end; 324 end set_the_search_paths_of_a_search_list; 325 326 /* Warn the user if directories being added to the search list don't exist */ 327 328 check_paths_for_warnings: 329 procedure (sl_info_ptr); 330 331 declare sl_info_ptr pointer; /* (Output) pointer to allocate sl_info in */ 332 333 declare code fixed binary (35); 334 335 call search_paths_$get (LIST, "1"b, "", null, get_system_free_area_ (), sl_info_version_1, sl_info_ptr, code); 336 if sl_info_ptr ^= null 337 then do; /* change to "begin;" when compiler bug 1789 is fixed in MR7.0 */ 338 declare pathx fixed binary; 339 340 do pathx = 1 to sl_info_ptr -> sl_info.num_paths; 341 if sl_info_ptr -> sl_info.paths (pathx).type = ABSOLUTE_PATH 342 | sl_info_ptr -> sl_info.paths (pathx).type = UNEXPANDED_PATH 343 then do; /* change to "begin;" when compiler bug 1789 is fixed in MR7.0 */ 344 declare bit_count fixed binary (24); 345 declare dir_name char (168); 346 declare entry_type fixed binary (2); 347 declare entryname char (32); 348 349 call expand_pathname_ (sl_info_ptr -> sl_info.paths (pathx).pathname, dir_name, entryname, 350 code); 351 call hcs_$status_minf (dir_name, entryname, 0, entry_type, bit_count, code); 352 if code ^= 0 353 then call com_err_ (code, command, "Warning. ^a", 354 sl_info_ptr -> sl_info.paths (pathx).pathname); 355 end; 356 end; 357 358 free sl_info_ptr -> sl_info; 359 sl_info_ptr = null; 360 end; 361 end check_paths_for_warnings; 362 363 cleanup_: 364 procedure; 365 366 if sl_info_ptr ^= null 367 then do; 368 free sl_info_ptr -> sl_info; 369 sl_info_ptr = null; 370 end; 371 end cleanup_; 372 373 end set_translator_search_rules; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 02/16/88 1442.0 set_translator_search_rules.pl1 >spec>install>MR12.2-1023>set_translator_search_rules.pl1 69 1 02/16/88 1407.4 sl_info.incl.pl1 >spec>install>MR12.2-1023>sl_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. ABSOLUTE_PATH constant fixed bin(17,0) initial dcl 1-33 ref 158 234 341 HOME_DIR constant fixed bin(17,0) initial dcl 1-38 ref 219 LIST 000000 constant char(10) initial unaligned dcl 46 set ref 93* 98* 302* 316* 335* REFERENCING_DIR constant fixed bin(17,0) initial dcl 1-35 ref 222 UNEXPANDED_PATH constant fixed bin(17,0) initial dcl 1-34 ref 151 236 341 WORKING_DIR constant fixed bin(17,0) initial dcl 1-36 ref 144 226 absolute_pathname_ 000014 constant entry external dcl 56 ref 238 arg parameter char unaligned dcl 268 ref 265 270 272 arg_count 000132 automatic fixed bin(17,0) dcl 106 set ref 116* 118 129 131* 134 arg_length 000133 automatic fixed bin(21,0) dcl 107 set ref 119* 125 136* 142 165 165 arg_ptr 000134 automatic pointer dcl 108 set ref 119* 125 136* 142 165 arg_string based char unaligned dcl 114 set ref 125 142 165* argx 000136 automatic fixed bin(17,0) dcl 109 set ref 118* 119* 122* 134* 136* 139* bit_count 000226 automatic fixed bin(24,0) dcl 344 set ref 351* change_index 4 based fixed bin(71,0) level 2 dcl 1-15 set ref 199* change_index_p 2 based pointer level 2 dcl 1-15 set ref 198* cleanup 000112 stack reference condition dcl 42 ref 75 87 code 000137 automatic fixed bin(35,0) dcl 110 in procedure "set_translator_search_rules_" set ref 119* 120 122* 136* 137 139* 146* 147 153* 154 160* 161 165* 167 170* 171 176* 177 code parameter fixed bin(35,0) dcl 214 in procedure "get_path_type" set ref 208 218* 230* 231* 238* 239 239* code 000224 automatic fixed bin(35,0) dcl 333 in procedure "check_paths_for_warnings" set ref 335* 349* 351* 352 352* code 000121 automatic fixed bin(35,0) dcl 90 in begin block on line 89 set ref 93* 94 98* code parameter fixed bin(35,0) dcl 300 in procedure "set_the_search_paths_of_a_search_list" set ref 296 302* 303 305 316* code 15 based fixed bin(35,0) array level 3 in structure "sl_info" dcl 1-15 in procedure "stsr" set ref 201* 310 310* code parameter fixed bin(35,0) dcl 251 in procedure "check_for_duplicates" set ref 246 253* 258* com_err_ 000016 constant entry external dcl 57 ref 98 122 139 231 239 257 310 316 352 command 000100 automatic char(32) unaligned dcl 31 set ref 73* 85* 98* 122* 139* 231* 239* 257* 310* 316* 352* cu_$arg_count 000020 constant entry external dcl 58 ref 116 cu_$arg_ptr 000022 constant entry external dcl 59 ref 119 136 default_sw 000140 automatic bit(1) unaligned dcl 111 set ref 117* 118 125* 129 dir_name 000227 automatic char(168) unaligned dcl 345 set ref 349* 351* entry_type 000301 automatic fixed bin(2,0) dcl 346 set ref 351* entryname 000302 automatic char(32) unaligned dcl 347 set ref 349* 351* error_table_$action_not_performed 000010 external static fixed bin(35,0) dcl 50 ref 305 error_table_$badopt 000012 external static fixed bin(35,0) dcl 52 ref 230 expand_pathname_ 000024 constant entry external dcl 60 ref 349 get_system_free_area_ 000026 constant entry external dcl 61 ref 93 93 335 335 hcs_$status_minf 000030 constant entry external dcl 62 ref 351 ioa_ 000032 constant entry external dcl 64 ref 96 null builtin function dcl 36 ref 74 86 93 93 191 198 302 302 319 322 335 335 336 359 366 369 num_paths 1 based fixed bin(17,0) level 2 dcl 1-15 set ref 94 195* 201 202 285 287 309 321 340 358 368 pad1 6 based bit(36) array level 2 dcl 1-15 set ref 200* path_count parameter fixed bin(17,0) dcl 188 ref 185 192 194 pathname 17 based char(168) array level 3 in structure "sl_info" packed unaligned dcl 1-15 in procedure "stsr" set ref 96* 145* 152* 159* 165* 254* 257* 285 310* 349* 352* pathname parameter char unaligned dcl 213 in procedure "get_path_type" set ref 208 217* 227* 238* pathname parameter char unaligned dcl 281 in procedure "path_index" ref 277 285 paths 14 based structure array level 2 dcl 1-15 pathx 000214 automatic fixed bin(17,0) dcl 307 in procedure "set_the_search_paths_of_a_search_list" set ref 309* 310 310 310* pathx 000225 automatic fixed bin(17,0) dcl 338 in procedure "check_paths_for_warnings" set ref 340* 341 341 349 352* pathx 000141 automatic fixed bin(17,0) dcl 112 in procedure "set_translator_search_rules_" set ref 133* 135* 135 144 145 146* 149* 149 151 152 153* 156* 156 158 159 160* 165 165 170* pathx 000122 automatic fixed bin(17,0) dcl 91 in begin block on line 89 set ref 94* 96* pathx 000204 automatic fixed bin(17,0) dcl 283 in procedure "path_index" set ref 285* 285* 287 289 pathx parameter fixed bin(17,0) dcl 250 in procedure "check_for_duplicates" ref 246 254 254 257 search builtin function dcl 37 ref 234 search_path parameter char unaligned dcl 211 set ref 208 217 219* 219 222 224 224 231* 234 238* 239* search_paths_$get 000034 constant entry external dcl 65 ref 93 335 search_paths_$set 000036 constant entry external dcl 67 ref 302 sl_info based structure level 1 dcl 1-15 set ref 195 321 358 368 sl_info_num_paths 000120 automatic fixed bin(17,0) dcl 1-27 set ref 194* 195 195 sl_info_ptr parameter pointer dcl 189 in procedure "create_sl_info" set ref 185 191* 195* 197 198 199 200 201 202 sl_info_ptr 000110 automatic pointer dcl 32 in procedure "stsr" set ref 74* 86* 93* 94 96 129* 131* 144 145 146* 151 152 153* 158 159 160* 165 165 170* 176* 180* 366 368 369* sl_info_ptr parameter pointer dcl 280 in procedure "path_index" ref 277 285 285 287 sl_info_ptr parameter pointer dcl 299 in procedure "set_the_search_paths_of_a_search_list" set ref 296 302* 309 310 310 310 319 321 322* sl_info_ptr parameter pointer dcl 249 in procedure "check_for_duplicates" set ref 246 254* 254 257 sl_info_ptr parameter pointer dcl 331 in procedure "check_paths_for_warnings" set ref 328 335* 336 340 341 341 349 352 358 359* sl_info_version_1 000026 constant fixed bin(17,0) initial dcl 1-29 set ref 93* 197 335* substr builtin function dcl 38 ref 272 type 14 based fixed bin(17,0) array level 3 in structure "sl_info" dcl 1-15 in procedure "stsr" set ref 144* 151* 158* 165* 341 341 type parameter fixed bin(17,0) dcl 212 in procedure "get_path_type" set ref 208 216* 219* 222* 226* 234* 236* uid 16 based bit(36) array level 3 dcl 1-15 set ref 202* version based fixed bin(17,0) level 2 dcl 1-15 set ref 197* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. INITIATED_SEGS internal static fixed bin(17,0) initial dcl 1-39 PROCESS_DIR internal static fixed bin(17,0) initial dcl 1-37 sl_info_p automatic pointer dcl 1-28 NAMES DECLARED BY EXPLICIT CONTEXT. check_for_duplicates 001322 constant entry internal dcl 246 ref 146 153 160 170 check_paths_for_warnings 001713 constant entry internal dcl 328 ref 180 cleanup_ 002172 constant entry internal dcl 363 ref 75 78 87 100 create_sl_info 000755 constant entry internal dcl 185 ref 129 131 get_path_type 001057 constant entry internal dcl 208 ref 165 is_control_arg 001424 constant entry internal dcl 265 ref 219 path_index 001462 constant entry internal dcl 277 ref 254 print_translator_search_rules 000203 constant entry external dcl 81 ptsr 000174 constant entry external dcl 81 set_the_search_paths_of_a_search_list 001534 constant entry internal dcl 296 ref 176 set_translator_search_rules 000131 constant entry external dcl 25 set_translator_search_rules_ 000404 constant entry internal dcl 103 ref 77 stsr 000122 constant entry external dcl 25 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2702 2742 2455 2712 Length 3174 2455 40 216 225 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME stsr 446 external procedure is an external procedure. on unit on line 75 64 on unit on unit on line 87 64 on unit begin block on line 89 begin block shares stack frame of external procedure stsr. set_translator_search_rules_ internal procedure shares stack frame of external procedure stsr. create_sl_info internal procedure shares stack frame of external procedure stsr. get_path_type internal procedure shares stack frame of external procedure stsr. check_for_duplicates internal procedure shares stack frame of external procedure stsr. is_control_arg internal procedure shares stack frame of external procedure stsr. path_index internal procedure shares stack frame of external procedure stsr. set_the_search_paths_of_a_search_list internal procedure shares stack frame of external procedure stsr. check_paths_for_warnings internal procedure shares stack frame of external procedure stsr. cleanup_ 64 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME stsr 000100 command stsr 000110 sl_info_ptr stsr 000120 sl_info_num_paths stsr 000121 code begin block on line 89 000122 pathx begin block on line 89 000132 arg_count set_translator_search_rules_ 000133 arg_length set_translator_search_rules_ 000134 arg_ptr set_translator_search_rules_ 000136 argx set_translator_search_rules_ 000137 code set_translator_search_rules_ 000140 default_sw set_translator_search_rules_ 000141 pathx set_translator_search_rules_ 000204 pathx path_index 000214 pathx set_the_search_paths_of_a_search_list 000224 code check_paths_for_warnings 000225 pathx check_paths_for_warnings 000226 bit_count check_paths_for_warnings 000227 dir_name check_paths_for_warnings 000301 entry_type check_paths_for_warnings 000302 entryname check_paths_for_warnings THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_out_desc call_ext_out call_int_this call_int_other return_mac enable_op ext_entry int_entry alloc_storage op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. absolute_pathname_ com_err_ cu_$arg_count cu_$arg_ptr expand_pathname_ get_system_free_area_ hcs_$status_minf ioa_ search_paths_$get search_paths_$set THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$badopt LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 25 000121 73 000136 74 000141 75 000143 77 000165 78 000166 79 000172 81 000173 85 000210 86 000213 87 000215 93 000237 94 000315 96 000327 97 000353 98 000356 100 000377 101 000403 103 000404 116 000405 117 000414 118 000415 119 000427 120 000444 122 000446 123 000477 125 000500 127 000510 129 000512 131 000522 133 000524 134 000525 135 000535 136 000536 137 000553 139 000555 140 000606 142 000607 144 000615 145 000623 146 000627 147 000631 149 000634 151 000635 152 000643 153 000647 154 000651 156 000654 158 000655 159 000663 160 000667 161 000671 163 000674 165 000675 167 000733 170 000736 171 000740 174 000743 176 000745 177 000747 180 000752 181 000754 185 000755 191 000757 192 000761 194 000763 195 000764 197 000775 198 000777 199 001001 200 001005 201 001021 202 001040 204 001056 208 001057 216 001075 217 001077 218 001105 219 001106 222 001140 224 001147 226 001157 227 001161 228 001166 230 001167 231 001172 232 001221 234 001222 236 001242 238 001244 239 001266 242 001321 246 001322 253 001324 254 001325 257 001361 258 001420 259 001423 265 001424 270 001435 272 001450 277 001462 285 001473 286 001520 287 001522 289 001532 296 001534 302 001536 303 001565 305 001570 309 001573 310 001605 313 001650 314 001652 316 001653 319 001673 321 001700 322 001707 324 001712 328 001713 335 001715 336 001774 340 002001 341 002013 349 002024 351 002054 352 002112 356 002153 358 002155 359 002165 361 002170 363 002171 366 002177 368 002204 369 002212 371 002215 ----------------------------------------------------------- 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