COMPILATION LISTING OF SEGMENT command_processor_ Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 1014.0 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 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 /* format: off */ 13 14 /* The Multics Command Processor */ 15 16 /* Created: 1 May 1976 by Steve Herbst */ 17 /* Modified and reorganized by Jay Goldman, '77 */ 18 /* Reorganized and fixed bugs: February-March 1978 by Gary Palter */ 19 /* Modified: June 1978 by G. Palter to fix several bugs and implement new definition of |[, ||[, |], and |; */ 20 /* Modified: 5-6 August 1978 by G. Palter to make command_processor_$af work properly */ 21 /* Modified: 13 August 1978 by G. Palter to not forget about temporary segments */ 22 /* Modified: 11 September 1978 by G. Palter to remove definition of |; */ 23 /* Modified: 31 October 1978 by G. Palter to call fc_no_message when invoked as cp_$af */ 24 /* Modified: 29 November 1978 by G. Palter to implement newer definition of |[ */ 25 /* Modified: 23 June 1979 by G. Palter to make null iteration sets within brackets not be considered an error 26* but instead return no value */ 27 /* Modified: 13 July 1979 by G. Palter to fix a bug wherein an &if clause in an exec_com with unbalanced brackets 28* causes a fault in match_iters */ 29 /* Modified: 16 August 1979 by G. Palter to not bother to zero the automatic node block before returning */ 30 /* Modified: 14 March 1980 by G. Palter to add faster simple command processing */ 31 /* Modified: 31 March 1980 by G. Palter to add new directly callable interfaces and the subsystem entries */ 32 /* Modified: 5 May 1980 by G. Palter to change calling sequence of eval_string entries and add include file for active 33* string types */ 34 /* Modified: 7 May 1980 by G. Palter to change calling sequence of subsys* entries to include a subsys_cp_info_ptr; this 35* pointer is presently unused, however */ 36 /* Modified: 3 October 1980 by G. Palter to fix bug #0016 -- the command processor takes an out_of_bounds fault when 37* passed a zero-length input line (TR07834) */ 38 /* Modified: 1 December 1980 by G. Palter to fix bug #0017 -- the command processor may cause the PL/1 free_based 39* operator to take a random fault when processing a null command line */ 40 /* Modified: May-June 1982 by G. Palter to (1) make simple_command_processor a quick block, (2) create the 41* complex_command_processor internal procedure to hold all automatic storage not shared by the simple and complex 42* command processor cases, (3) add support for tailoring the request line language within subsystems (eg: disabling 43* iteration), (4) delete command_processor_$af (finally!), and (5) fix several bugs relating to temporary segment 44* management and treatment of semicolons in active function/request return values (command_processor 5, 21, 22) */ 45 /* Modified: March 1984 by Keith Loepere for non-existant error_table_$bad_subr_call */ 46 /* Modified: July 1984 by G. Palter to use multiple permanent scratch segments in order to improve the performance of 47* recursive invocations of the evaluate_active_string entrypoints such as those made by the LINUS Report Writer */ 48 49 50 /****^ HISTORY COMMENTS: 51* 1) change(86-05-17,GDixon), approve(86-05-17,MCR7357), 52* audit(86-06-16,Farley), install(86-07-17,MR12.0-1097): 53* Change call to tct_ to reference find_char_$first_in_table instead. This 54* subroutine has been renamed. 55* 2) change(86-05-17,DGHowe), approve(86-05-15,MCR7375), 56* audit(86-07-15,Schroth), install(86-08-01,MR12.0-1108): 57* added the ability to save the command name given on the command line to 58* simple_command_processor and produce_argument_list. 59* 3) change(87-07-13,GWMay), approve(87-07-13,MCR7730), audit(87-08-10,JRGray), 60* install(87-09-10,MR12.1-1104): 61* Added the ability to pipe data between commands and files. 62* 4) change(87-09-10,GWMay), approve(87-09-10,MCR7730), audit(87-09-10,GDixon), 63* install(87-09-10,MR12.1-1104): 64* Changed position within the code where the pipe structure is suspended 65* and restored. Fixed several problems found by the security auditor. 66* 5) change(87-09-10,GWMay), approve(87-09-10,PBF7730), audit(87-09-14,GDixon), 67* install(87-09-15,MR12.1-1107): 68* Remove extra call to copy_thru_pipe from the process_pipe_command routine. 69* Matching attaches are handled in the process_attach_description code. 70* 6) change(87-12-15,GWMay), approve(87-12-15,MCR7810), audit(87-12-15,GDixon), 71* install(88-01-12,MR12.2-1011): 72* Changed call main error return call to com_err_ to only output a newline 73* when there is error text. 74* 7) change(88-02-03,GWMay), approve(88-02-25,MCR7848), 75* audit(88-02-26,Fawcett), install(88-03-01,MR12.2-1029): 76* Changed pipe facility to allow $ in the name of a command. 77* END HISTORY COMMENTS */ 78 79 /* LIMITATIONS AN KNOWN BUGS: */ 80 81 /* 1) Nested iteration sets will not return the expected results. 82* 83* example: 84* 85* string (xxx_(a b) (c d)_yyy zzz) 86* 87* intermixes the inner interation set. 88* 89* 2) The pipe processing code cannot deal with pipes that are 90* embedded as part of an active return string. 91* 92* examples: 93* 94* string "show;|cols";| xx 95* ls;| [contents xx;|] 96* 97* string [[ioa_ "string (ab a bc cd ae ef);|match /a/";|]] 98* 99* Because the pipe code evaluates the command line as it is input, 100* the value returned by the active string will not be diagnosed 101* correctly as a pipe. 102**/ 103 104 /* format: on,style4,delnl,insnl,ifthenstmt,ifthen */ 105 106 command_processor_: 107 procedure (P_line_ptr, P_line_len, P_code); 108 109 110 /* Parameters */ 111 112 dcl P_line_ptr pointer parameter; /* command_processor_: -> line to process (input) */ 113 dcl P_line_len fixed binary (21) parameter; /* command_processor_: length of line to process (input) */ 114 115 dcl P_line character (*) parameter; /* *execute_line, *eval_string: line to process (input) */ 116 117 dcl P_return_value character (*) varying parameter; /* *eval_string: result of evaluation (output) */ 118 119 dcl P_eval_string_options_ptr pointer parameter; /* eval_string: -> options controlling interpretation of the 120* active string (unused at present) (input) */ 121 122 dcl P_active_string_type fixed binary parameter; /* *eval_string: type of active string (input) */ 123 124 dcl P_cp_subsys_info_ptr pointer parameter; /* subsys_*, validate_cp_subsys_info: -> options controlling 125* interpretation of the request line (input) */ 126 127 dcl P_subsystem_name character (*) parameter; /* subsys_*: the subsystem (input) */ 128 dcl P_subsystem_info_ptr pointer parameter; /* subsys_*: -> data used by the subsystem (input) */ 129 dcl P_execute_request entry (pointer, character (*), pointer, fixed binary (35)) variable parameter; 130 /* subsys_*: procedure to lookup & execute request (input) */ 131 132 dcl P_old_execute_request entry (character (*), pointer, fixed binary (35)) variable parameter; 133 /* execute_command_line_: same as above (input) */ 134 135 dcl P_code fixed binary (35) parameter; /* *: status code (output) */ 136 137 138 /* Local copies of parameters */ 139 140 dcl line character (line_len) unaligned based (line_ptr); 141 dcl line_ptr pointer; 142 dcl line_len fixed binary (21); 143 144 dcl execute_request entry (pointer, character (*), pointer, fixed binary (35)) variable; 145 dcl old_execute_request entry (character (*), pointer, fixed binary (35)) variable; 146 147 dcl code fixed binary (35); 148 dcl ignore_code fixed bin (35); /* this value is for speed, never check it */ 149 150 /* Remaining declarations */ 151 152 dcl multics_cp bit (1) aligned; /* ON => Multics entry; OFF => subsystem entry */ 153 dcl evaluate_string bit (1) aligned; /* ON => called to evaluate an active string */ 154 dcl new_subsystem_call bit (1) aligned; /* ON => new form of execute_request, etc */ 155 156 dcl null_cl bit (1) aligned; /* ON => command line is only whitspace */ 157 158 dcl complex_line bit (1) aligned; /* ON => command line contains quoting, iteration, active 159* strings, or commands with more than 32 arguments */ 160 161 dcl lss_on bit (1) aligned; /* ON => running Limited Service System */ 162 163 dcl use_standard_language bit (1) aligned; /* ON => can use PL/I builtins for search */ 164 165 dcl executing bit (1) aligned; /* ON => executing a command at the moment */ 166 dcl abort_command_execution label variable; 167 168 dcl top_level_string_type fixed binary; /* for evaluating active strings: [], |[], ||[] */ 169 170 dcl start fixed binary (21); 171 172 dcl error_message char (256) varying; 173 174 dcl COMMAND_PROCESSOR_ character (32) static options (constant) initial ("command_processor_"); 175 dcl EXECUTE_COMMAND_LINE_ character (32) static options (constant) initial ("execute_command_line_"); 176 177 dcl MAX_STACK_EXTENSION fixed binary (21) static options (constant) initial (16384); 178 /* do not extend stack more than 16 pages */ 179 dcl MIN_AF_RETURN_LTH fixed binary (21) static options (constant) initial (32768); 180 /* always give active function at least 32K chars */ 181 182 /* format: off */ 183 dcl (error_table_$bad_file_name, 184 error_table_$bad_pipe_syntax, 185 error_table_$bad_subr_arg, 186 error_table_$command_line_overflow, 187 error_table_$mismatched_iter, 188 error_table_$null_brackets, 189 error_table_$no_file, 190 error_table_$noentry, 191 error_table_$unbalanced_brackets, 192 error_table_$unbalanced_parentheses, 193 error_table_$unbalanced_quotes, 194 error_table_$unimplemented_version) 195 fixed binary (35) external; 196 /* format: on */ 197 198 dcl sys_info$max_seg_size fixed binary (19) external; 199 200 dcl absolute_pathname_ entry (char (*), char (*), fixed bin (35)); 201 dcl check_star_name_ entry (char (*), bit (36), fixed bin (2), fixed bin (35)); 202 dcl com_err_ entry () options (variable); 203 dcl cu_$gen_call entry (pointer, pointer); 204 dcl cu_$grow_stack_frame entry (fixed binary (21), pointer, fixed binary (35)); 205 dcl find_char_$first_in_table entry (char (*), char (512) aligned) returns (fixed bin (21)) reducible; 206 dcl find_command_ entry (pointer, fixed binary, pointer, fixed binary (35)); 207 dcl find_command_$fc_no_message entry (pointer, fixed binary, pointer, fixed binary (35)); 208 dcl get_system_free_area_ entry () returns (pointer); 209 dcl get_temp_segment_ entry (character (*), pointer, fixed binary (35)); 210 dcl get_wdir_ entry () returns (char (168)); 211 dcl hcs_$get_uid_file entry (char (*), char (*), bit (36) aligned, fixed bin (35)); 212 dcl pipe_$terminate entry (ptr, ptr, fixed bin (35)); 213 dcl release_temp_segment_ entry (character (*), pointer, fixed binary (35)); 214 dcl release_temp_segments_ entry (character (*), (*) pointer, fixed binary (35)); 215 dcl sub_err_ entry () options (variable); 216 dcl transform_command_ entry (pointer, fixed binary, pointer, fixed binary (35)); 217 218 dcl (cleanup, command_abort_, request_abort_) condition; 219 220 dcl (addr, addcharno, addrel, after, before, bit, currentsize, dimension, divide, fixed, hbound, index, lbound, length, 221 ltrim, low, max, maxlength, min, mod, null, rank, rtrim, search, stacq, substr, unspec, verify) builtin; 222 223 /* Various combinations of those characters special to command language: many almost blank listing pages follow ... */ 224 225 dcl BREAKS character (12) static options (constant) initial (";()[]""| 226 "); /* command language break characters and NL, HT, SP, VT, FF */ 227 228 dcl TOKEN_BREAKS character (6) static options (constant) initial (""" 229 "); /* breaks for tokens only: " NL HT SP VT FF */ 230 231 dcl SIMPLE_BREAKS character (6) static options (constant) initial ("; 232 "); /* ; and whitespace (NL HT SP VT FF) */ 233 234 dcl NON_SIMPLE_BREAKS character (6) static options (constant) initial ("()[]""|"); 235 /* characters requiring special processing */ 236 237 dcl PIPE_BREAK character (2) static options (constant) initial (";|"); 238 239 dcl LEFT_BRACKET character (1) static options (constant) initial ("["); 240 241 dcl RIGHT_BRACKET character (1) static options (constant) initial ("]"); 242 243 dcl VERTICAL_BAR character (1) static options (constant) initial ("|"); 244 245 dcl COMMAND_BREAKS character (2) static options (constant) initial ("; 246 "); /* characters which separate command invocations (;, NL) */ 247 dcl SPACE character (1) internal static options (constant) init (" "); 248 249 /* Execute a Multics command line: this entry is intended to be called only via cu_$cp */ 250 251 /* command_processor_: entry (P_line_ptr, P_line_len, P_code); */ 252 253 multics_cp = "1"b; /* not a subsystem invocation */ 254 new_subsystem_call = "0"b; 255 evaluate_string = "0"b; 256 line_ptr = P_line_ptr; 257 line_len = P_line_len; 258 go to CONTINUE_SETUP; 259 260 261 /* Evaluate a Multics active string */ 262 263 eval_string: 264 entry (P_eval_string_options_ptr, P_line, P_active_string_type, P_return_value, P_code); 265 266 multics_cp = "1"b; /* not a subsystem */ 267 new_subsystem_call = "0"b; 268 evaluate_string = "1"b; 269 top_level_string_type = max (P_active_string_type, NORMAL_ACTIVE_STRING); 270 top_level_string_type = min (top_level_string_type, ATOMIC_ACTIVE_STRING); 271 /* defaults to [] */ 272 go to SETUP; 273 274 275 /* Execute a subsystem request line: the caller must supply a procedure which is used to find and execute each request */ 276 277 subsys_execute_line: 278 entry (P_subsystem_name, P_subsystem_info_ptr, P_execute_request, P_cp_subsys_info_ptr, P_line, P_code); 279 280 multics_cp = "0"b; /* this is a subsystem */ 281 new_subsystem_call = "1"b; 282 evaluate_string = "0"b; 283 lss_on = "0"b; 284 go to SETUP; 285 286 287 /* Execute a subsystem request line: this is an obsolete entry provided for compatibility */ 288 289 execute_command_line_: 290 entry (P_line, P_old_execute_request, P_code); 291 292 multics_cp = "0"b; 293 new_subsystem_call = "0"b; /* use old fashioned calling sequence */ 294 evaluate_string = "0"b; 295 lss_on = "0"b; 296 go to SETUP; 297 298 299 /* Evaluate a subsystem active string */ 300 301 subsys_eval_string: 302 entry (P_subsystem_name, P_subsystem_info_ptr, P_execute_request, P_cp_subsys_info_ptr, P_line, P_active_string_type, 303 P_return_value, P_code); 304 305 multics_cp = "0"b; 306 new_subsystem_call = "1"b; 307 evaluate_string = "1"b; 308 lss_on = "0"b; 309 top_level_string_type = max (P_active_string_type, NORMAL_ACTIVE_STRING); 310 top_level_string_type = min (top_level_string_type, ATOMIC_ACTIVE_STRING); 311 go to SETUP; 312 313 /* Execute/evaluate the command/request line/active-string: for simplicity, all future references will assume that a 314* Multics command line is being executed */ 315 316 SETUP: 317 line_ptr = addr (P_line); /* this point is reached by all but command_processor_ */ 318 line_len = length (P_line); 319 320 CONTINUE_SETUP: /* command_processor_ joins here */ 321 error_message = ""; 322 code = 0; 323 324 use_standard_language = "1"b; /* until proven otherwise: assume normal case */ 325 326 if ^multics_cp then /* subsystem entries: check for special request language */ 327 if new_subsystem_call then 328 if P_cp_subsys_info_ptr ^= null () then do; 329 cp_subsys_info_ptr = P_cp_subsys_info_ptr; 330 if cp_subsys_info.version ^= CP_SUBSYS_INFO_VERSION_1 then do; 331 RESIGNAL_INCOMPATIBLE_SUBSYSTEM_INFO: /* wrong version is quite fatal */ 332 call sub_err_ (error_table_$unimplemented_version, COMMAND_PROCESSOR_, ACTION_CANT_RESTART, 333 null (), (0), "^24.3b from subsystem ^a.", unspec (cp_subsys_info.version), 334 P_subsystem_name); 335 go to RESIGNAL_INCOMPATIBLE_SUBSYSTEM_INFO; 336 end; 337 use_standard_language = ^cp_subsys_info.non_standard_language; 338 end; 339 340 if evaluate_string then P_return_value = ""; /* initialize the return value */ 341 342 if use_standard_language then do; /* can perform some short cuts for the normal language */ 343 line_len = length (rtrim (line, SIMPLE_BREAKS)); 344 start = verify (line, SIMPLE_BREAKS); /* ... strip leading/trailing whitespace/null commands */ 345 null_cl = (start = 0); 346 if null_cl then do; /* ... the line is empty */ 347 complex_line = "0"b; 348 go to SILENTLY_RETURN_FROM_CP; 349 end; 350 end; 351 else do; /* have no idea what the whitespace characters are ... */ 352 start = 1; /* ... must scan the entire line */ 353 null_cl = "1"b; /* ... until proven otherwise by complex_command_processor */ 354 end; 355 356 if multics_cp then 357 lss_on = cp_data_$under_lss; /* running under Limited Service System */ 358 else do; /* a subsystem entry: get the appropriate apply procedure */ 359 if new_subsystem_call then 360 execute_request = P_execute_request; 361 else old_execute_request = P_old_execute_request; 362 end; 363 364 if evaluate_string then /* evaluating an active string: always a complex operation */ 365 complex_line = "1"b; 366 else if use_standard_language then /* standard language: try faster command processor if OK */ 367 /* The pipe token ";|" does not need to be checked here */ 368 /* because "|" is a non-simple break which will set the */ 369 /* complex line switch on. */ 370 complex_line = (search (substr (line, start), NON_SIMPLE_BREAKS) ^= 0); 371 else complex_line = "1"b; /* no idea what the language is like */ 372 373 if ^complex_line then do; /* first try faster command processor ... */ 374 executing = "0"b; /* ... execution is not in progress */ 375 abort_command_execution = SILENTLY_RETURN_FROM_CP; 376 if multics_cp then /* ... establish appropriate abort handler once */ 377 on condition (command_abort_) 378 begin; 379 if executing then go to abort_command_execution; 380 end; 381 else on condition (request_abort_) 382 begin; 383 if executing then go to abort_command_execution; 384 end; 385 call simple_command_processor (line_ptr, line_len, start, complex_line); 386 if multics_cp then 387 revert condition (command_abort_); 388 else revert condition (request_abort_); 389 end; 390 391 if complex_line then call complex_command_processor (line_ptr, line_len, start); 392 393 RETURN_FROM_CP: 394 if (code ^= 0) & ^evaluate_string then 395 if multics_cp then call com_err_ (code, COMMAND_PROCESSOR_, 396 "^[^/^]^a", error_message ^= "", error_message); 397 else if new_subsystem_call then call com_err_ (code, P_subsystem_name, "^/^a", error_message); 398 else call com_err_ (code, EXECUTE_COMMAND_LINE_, "^/^a", error_message); 399 400 SILENTLY_RETURN_FROM_CP: 401 if (code = 0) & null_cl then code = 100; 402 403 P_code = code; 404 405 return; 406 407 /* Simple command processor: processes command lines which do not contain quoted strings, iteration, or active strings. 408* Argument lists are constructed and commands invoked until either the entire command line is processed or a command 409* invocation if found with more than 32 arguments in which case the full command processor must be used */ 410 411 simple_command_processor: 412 procedure (p_line_ptr, p_line_lth, p_start, p_complex_line) /* options (quick) */; 413 414 415 /* Parameters */ 416 417 dcl p_line_ptr pointer parameter; /* -> command line to execute */ 418 dcl p_line_lth fixed binary (21) parameter; /* length of above command line */ 419 dcl p_start fixed binary (21) parameter; /* where to start in the command line */ 420 dcl p_complex_line bit (1) aligned parameter; /* set ON => something in this command line was too much to 421* handle -- the normal processor must be used */ 422 423 424 /* Local copies of parameters */ 425 426 dcl line character (line_lth) unaligned based (line_ptr); /* command line being processed */ 427 dcl (line_lth, start) fixed binary (21); 428 dcl line_ptr pointer; 429 430 431 /* Remaining declarations */ 432 433 dcl 1 arg_list aligned, /* the argument list being constructed */ 434 2 twice_n_arguments fixed binary (18) unaligned unsigned, 435 2 tag bit (18) unaligned initial ("000004"b3), /* PL/1 */ 436 2 twice_n_descriptors fixed binary (18) unaligned unsigned, 437 2 has_command_name bit (1) unal, 438 2 pad bit (17) unal, 439 2 arg_ptrs (32) pointer, 440 2 descriptor_ptrs (32) pointer, 441 2 name, 442 3 command_name_ptr pointer, 443 3 command_name_length fixed bin (21); 444 445 dcl 1 descriptors (32) aligned, /* descriptions of above arguments */ 446 2 bits bit (12) unaligned, /* flag(1), type(6), packed(1), ndims(4) */ 447 2 size fixed binary (24) unaligned unsigned; 448 449 dcl descriptor_ptrs_for_move bit (72 * n_arguments) aligned based; 450 /* to move descriptor pointers to proper place in arglist */ 451 dcl command_name_for_move bit (144) aligned based; 452 dcl arg_list_overlay (68) bit (72) based (addr (arg_list.arg_ptrs (1))); 453 dcl saved_start fixed binary (21); /* where each command start in case it aborts */ 454 455 dcl reading_command_name bit (1) aligned; /* ON => picking up command name, not an argument */ 456 dcl end_of_command bit (1) aligned; /* ON => reached the end of a command */ 457 458 dcl n_arguments fixed binary; /* # of arguments for this command */ 459 460 dcl (token_lth, next_start) fixed binary (21); 461 462 dcl command_name character (command_name_lth) unaligned based (command_name_ptr); 463 dcl command_name_ptr pointer; /* -> name of the command to invoke */ 464 dcl command_name_lth fixed binary; 465 dcl command_entry_ptr pointer; /* -> the actual command to be run */ 466 467 line_ptr = p_line_ptr; 468 line_lth = p_line_lth; 469 start = p_start; 470 471 abort_command_execution = ABORT_COMMAND_EXECUTION;/* bypass PL/I's lexical scoping rules */ 472 473 do while (start <= line_lth); 474 475 saved_start = start; /* save start of command in case not simple */ 476 477 reading_command_name = "1"b; 478 end_of_command = "0"b; 479 n_arguments = 0; 480 481 do while (^end_of_command); 482 483 token_lth = search (substr (line, start), SIMPLE_BREAKS) - 1; 484 485 if token_lth = -1 then /* rest of the command line */ 486 token_lth = line_lth - start + 1; /* break is one beyond the end */ 487 488 if reading_command_name then do; 489 command_name_ptr = addr (substr (line, start, 1)); 490 command_name_lth = token_lth; 491 reading_command_name = "0"b; 492 end; 493 else do; 494 n_arguments = n_arguments + 1; 495 if n_arguments > hbound (arg_list.arg_ptrs, 1) then do; 496 p_start = saved_start; /* command has too many arguments: use full processor */ 497 p_complex_line = "1"b; 498 return; 499 end; 500 arg_list.arg_ptrs (n_arguments) = addr (substr (line, start, 1)); 501 arg_list.descriptor_ptrs (n_arguments) = addr (descriptors (n_arguments)); 502 descriptors (n_arguments).bits = "5260"b3; 503 /* unaligned, nonvarying string */ 504 descriptors (n_arguments).size = token_lth; 505 end; 506 507 start = start + token_lth; /* skip over token to delimiters */ 508 509 if (start > line_lth) then 510 end_of_command = "1"b; /* entire line used */ 511 512 else do; /* search for next token and check for end of a command 513* invocation (semicolon or newline in delimiters) */ 514 next_start = verify (substr (line, start), SIMPLE_BREAKS); 515 if (next_start = 0) then do; /* rest of line is delimiters */ 516 next_start = line_lth - start + 2; 517 end_of_command = "1"b; 518 end; 519 else end_of_command = (search (substr (line, start, (next_start - 1)), COMMAND_BREAKS) ^= 0); 520 start = start + next_start - 1; 521 end; 522 end; 523 524 arg_list.twice_n_arguments, arg_list.twice_n_descriptors = 2 * n_arguments; 525 526 /* save the name on the current argument list NOTE this is a new structure */ 527 528 arg_list.has_command_name = "1"b; 529 arg_list.name.command_name_length = command_name_lth; 530 arg_list.name.command_name_ptr = command_name_ptr; 531 532 533 if n_arguments < hbound (arg_list.arg_ptrs, 1) then do; 534 /* need to move descriptor pointers down */ 535 addr (arg_list.arg_ptrs (n_arguments + 1)) -> descriptor_ptrs_for_move = 536 addr (arg_list.descriptor_ptrs) -> descriptor_ptrs_for_move; 537 addr (arg_list_overlay (2 * n_arguments + 1)) -> command_name_for_move = 538 addr (arg_list.name) -> command_name_for_move; 539 end; 540 541 542 if multics_cp then do; /* executing a Multics command line */ 543 if lss_on then do; /* running within Limited Service System */ 544 call transform_command_ (command_name_ptr, command_name_lth, cp_data_$command_table_ptr, code); 545 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 546 end; 547 call find_command_ (command_name_ptr, command_name_lth, command_entry_ptr, code); 548 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 549 executing = "1"b; /* handle command_abort_ now */ 550 call cu_$gen_call (command_entry_ptr, addr (arg_list)); 551 end; 552 553 else if new_subsystem_call /* new type of subsystem request line */ 554 then do; 555 executing = "1"b; /* handler request_abort_ now */ 556 call execute_request (P_subsystem_info_ptr, command_name, addr (arg_list), code); 557 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 558 end; 559 560 else do; /* executing an old-fashioned subsystem request line */ 561 executing = "1"b; /* handler request_abort_ now */ 562 call old_execute_request (command_name, addr (arg_list), code); 563 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 564 end; 565 566 ABORT_COMMAND_EXECUTION: 567 executing = "0"b; 568 end; 569 570 return; 571 572 end simple_command_processor; 573 574 /* Complex command processor: processes command lines which contain quoted strings, iteration, or active strings. In 575* order to solve several bugs in the command processor, this procedure will have to be rewritten */ 576 577 complex_command_processor: 578 procedure (p_line_ptr, p_line_len, p_start) options (non_quick); 579 580 581 /* Parameters */ 582 583 dcl p_line_ptr pointer parameter; /* -> the command line/active string */ 584 dcl p_line_len fixed binary (21) parameter; /* length of the line */ 585 dcl p_start fixed binary (21) parameter; /* where in the line to start procesing */ 586 587 588 /* Local copies of paramerters */ 589 590 dcl (line_len, start) fixed binary (21); 591 dcl line_ptr pointer; 592 593 594 /* Nodes */ 595 596 dcl 1 atom aligned based, 597 2 next pointer unaligned, /* forward thread */ 598 2 pad1 pointer unaligned, 599 2 string_ptr pointer unaligned, /* pointer into command line */ 600 2 type fixed binary, 601 2 pad2 fixed binary, 602 2 string_len fixed binary (21), /* length of substring */ 603 2 flags aligned, 604 3 space bit (1); /* followed by white space */ 605 606 dcl 1 iter_begin aligned based, 607 2 next pointer unaligned, /* forward thread */ 608 2 end pointer unaligned, /* forward thread to matching ) */ 609 2 parent pointer unaligned, /* pointer to parent iter or af node */ 610 2 type fixed binary, 611 2 delimiter_class fixed binary, /* which of 8 possible end iteration set breaks to match */ 612 2 pad fixed binary (21), 613 2 flags aligned, 614 3 space bit (1); /* this value is ignored */ 615 616 dcl 1 iter_end aligned based, 617 2 next pointer unaligned, /* forward thread */ 618 2 begin pointer unaligned, /* backward thread to matching ( */ 619 2 parent pointer unaligned, /* pointer to parent iter or af node */ 620 2 type fixed binary, 621 2 pad fixed binary, 622 2 level fixed binary (21), /* number of iter sets not ended */ 623 2 flags aligned, 624 3 space bit (1); /* if iteration set is followed by white space */ 625 626 dcl 1 af aligned based, 627 2 next pointer unaligned, /* forward thread */ 628 2 prev pointer unaligned, /* backward thread */ 629 2 parent pointer unaligned, /* pointer to parent iter or af node */ 630 2 type fixed binary, 631 2 delimiter_class fixed binary, /* which of 8 possible end active string breaks to match */ 632 2 level fixed binary (21), /* iter level at start of af */ 633 2 flags aligned, 634 3 space bit (1), /* this value is ignored */ 635 3 atom_sw bit (1), /* result is to be a single atom */ 636 3 tokens_sw bit (1), /* result is to be broken into tokens only */ 637 3 catenate_sw bit (1); /* catenate results of iterations */ 638 639 dcl 1 node aligned based, 640 2 next pointer unaligned, /* forward thread */ 641 2 af_prev pointer unaligned, /* backward thread */ 642 2 af_iter_parent pointer unaligned, /* pointer to parent iter or af node */ 643 2 type fixed binary, 644 2 delimiter_class fixed binary, /* which of 8 possible end iteration/active string breaks */ 645 2 len_or_level fixed binary (21), /* length of character string for atom nodes, or 646* iter level at start of af or after iter_end */ 647 2 flags aligned, 648 3 space bit (1), /* followed by white space */ 649 3 af_atom_sw bit (1), /* result is a single atom */ 650 3 af_tokens_sw bit (1), /* result is to be broken into tokens only */ 651 3 af_catenate_sw bit (1); /* catenate results of iterations */ 652 653 /* format: off */ 654 dcl (ATOM initial (1), /* a piece of text which will form part of an argument */ 655 BEGIN_ITERATION initial (2), /* start of an iteration set */ 656 END_ITERATION initial (3), /* end of one or more iteration sets */ 657 ACTIVE_STRING initial (4), /* an active string */ 658 END_OF_COMMAND initial (5)) /* a command delimter returned by an active function */ 659 fixed binary static options (constant); 660 /* format: on */ 661 662 663 /* Data used for scratch segment management: The command processor maintains two lists of scratch segments -- the 664* "permanent" scratch segments are obtained only once per-process and are shared amongst various invocations of the 665* command processor through the use of a simple locking scheme. (In actuality, the permanent segments will be released 666* every cp_data_$scratch_release_factor uses to help keep process directory usage low). The other list of scratch 667* segments is a per-invocation list of temporary segments which are allocated and then released once per top-level 668* command/request (ie: once per semicolon) */ 669 670 dcl scratch_lock_id bit (36) aligned; /* unique identifier for acquiring "permanent" segments */ 671 672 dcl 1 temporary_scratch_segment_list aligned based (temporary_scratch_segment_list_ptr), 673 2 header, 674 3 n_allocated fixed binary, /* # of available temporary scratch segments */ 675 3 n_used fixed binary, /* # actually in use at present */ 676 2 segment_ptrs (temporary_scratch_segment_list_n_allocated refer (temporary_scratch_segment_list.n_allocated)) 677 pointer; 678 679 dcl 1 local_temporary_scratch_segment_list aligned, /* initial set of temporary scratch segments */ 680 2 header like temporary_scratch_segment_list.header, 681 2 segment_ptrs (8) pointer; 682 683 dcl temporary_scratch_segment_list_ptr pointer; 684 dcl temporary_scratch_segment_list_n_allocated fixed binary; 685 686 687 /* Remaining declarations */ 688 689 dcl 1 dummy_node aligned like node; 690 dcl 1 dummy_af_node aligned like af; /* top level active string for evaluate entries */ 691 692 dcl 1 node_block aligned based (block_ptr), /* block of thirty nodes */ 693 2 array (30) like node, /* four words each */ 694 2 next pointer; /* forward thread */ 695 dcl block_ptr pointer; 696 dcl last_block_ptr pointer; /* for chaining blocks */ 697 698 dcl node_index fixed binary (5); /* index of free node in a block */ 699 700 dcl 1 stack_space like node_block aligned; /* space in stack for first block of nodes */ 701 702 dcl system_area area based (system_area_ptr); /* area to allocate later blocks if needed */ 703 dcl system_area_ptr pointer; 704 705 dcl atom_string character (atom_len) based (atom_ptr); 706 dcl atom_len fixed binary (21); 707 dcl atom_ptr pointer; 708 709 dcl return_string character (return_len) aligned varying based (return_ptr); 710 dcl return_ptr pointer; /* -> AF return string */ 711 dcl return_len fixed binary (21); 712 713 dcl 1 full_language like cp_data_$standard_language aligned based (full_language_ptr); 714 dcl full_language_ptr pointer; /* defines the full language being interpreted */ 715 716 dcl 1 token_language like cp_data_$standard_language aligned based (token_language_ptr); 717 dcl token_language_ptr pointer; /* defines the language with non-whitespace, non-quoting 718* special characters treated normally */ 719 720 dcl using_stack bit (1) aligned; /* ON => arguments are being constructed on the stack */ 721 722 dcl last_np pointer; 723 dcl (first_node, new_first_node) pointer; /* node pointers for match_iters & read_list */ 724 dcl arg_count fixed binary; /* number of arguments to command/af, set by match_iters */ 725 dcl (count, iter_count, iter_index) fixed binary; /* number of iterations, set by match_iters */ 726 727 /* format: off */ 728 dcl (command initial ("0"b), /* executing a command */ 729 active_function initial ("1"b)) /* evaluating an active function */ 730 bit (1) aligned static options (constant); 731 /* format: on */ 732 733 dcl make_list_depth fixed binary; /* recursion depth of make_list procedure */ 734 dcl iter_level fixed binary; /* depth of ()'s in line */ 735 /* for use by the pipe facility only */ 736 dcl command_pipe_control_ptr ptr; 737 dcl 1 command_pipe_control aligned based (command_pipe_control_ptr), 738 2 Npipes_in_line fixed bin, /* occurances of ;| in a line */ 739 2 Niters fixed bin, /* iteration level */ 740 2 niters fixed bin, /* iteration count */ 741 2 Sevaluate_pipe bit (1) aligned, /* on = processing an active function */ 742 2 Sbuild_return_string bit (1) aligned, /* on = build the af return str */ 743 2 Sinclude_NL_in_af_ret_str bit (1) aligned, /* on = do not remove NLs from the ret str */ 744 2 Sterminate bit (1) aligned, /* on = delete pipe files and free storage */ 745 2 pipe_input_path char (58), /* built by pipe_$initiate */ 746 2 pipe_output_path char (58), /* built by pipe_$initiate */ 747 2 previous_pipe_ptr ptr, /* data before the ;| */ 748 2 previous_pipe_len fixed bin, 749 2 current_pipe_ptr ptr, /* current command line */ 750 2 current_pipe_len fixed bin, 751 2 next_pipe_ptr ptr, /* data after the next ;| */ 752 2 next_pipe_len fixed bin, 753 2 input_ptr ptr, /* input attachment */ 754 2 output_ptr ptr; /* output attachment */ 755 756 command_pipe_control_ptr = null; 757 line_ptr = p_line_ptr; 758 line_len = p_line_len; 759 start = p_start; 760 761 system_area_ptr = get_system_free_area_ (); 762 763 block_ptr = addr (stack_space); /* initialize node allocation variables */ 764 unspec (node_block) = "0"b; 765 node_block.next = null (); 766 node_index = 0; 767 768 call initialize_scratch_segments ("1"b); /* setup scratch segment management */ 769 770 on condition (cleanup) 771 begin; /* non-local goto in progress ... */ 772 if command_pipe_control_ptr ^= null then do; 773 call pipe_$terminate (addr (command_pipe_control.pipe_input_path), 774 addr (command_pipe_control.pipe_output_path), ignore_code); 775 776 free command_pipe_control in (system_area); 777 command_pipe_control_ptr = null; 778 end; 779 780 call free_nodes ("1"b); /* ... don't zero automatic storage */ 781 call release_scratch_segments ("1"b); /* ... or setup scratch segments for another pass */ 782 end; 783 784 if use_standard_language then /* pick up character type from constant definition */ 785 full_language_ptr, token_language_ptr = addr (cp_data_$standard_language); 786 else do; /* strange language: caller has supplied the definitions */ 787 full_language_ptr = addr (cp_subsys_info.full_tct_table); 788 token_language_ptr = addr (cp_subsys_info.tokens_only_tct_table); 789 end; 790 791 /* Process the line one command at a time -- a command invocation is delimited by non-quoted semicolons and newlines. 792* Evaluating an active string in the command line may return semicolons -- this case is handled by make_list and 793* match_iters */ 794 795 do while (start > 0); 796 797 iter_level = 0; /* no unclosed iteration sets */ 798 iter_count = 0; 799 iter_index = 0; 800 make_list_depth = 0; 801 802 return_ptr = null (); /* no place for return values yet */ 803 using_stack = "1"b; /* read_list will use additional stack space if necessary */ 804 805 unspec (dummy_node) = "0"b; 806 last_np = addr (dummy_node); 807 dummy_node.next = null (); 808 dummy_node.type = ATOM; 809 810 if evaluate_string then do; /* evaluating active string: make dummy AF node */ 811 unspec (dummy_af_node) = "0"b; 812 last_np = addr (dummy_af_node); 813 dummy_af_node.type = ACTIVE_STRING; 814 dummy_af_node.prev = addr (dummy_node); /* make sure result is seen */ 815 dummy_af_node.parent = null (); 816 if (top_level_string_type = TOKENS_ONLY_ACTIVE_STRING) then dummy_af_node.tokens_sw = "1"b; 817 /* caller requested |[] */ 818 else if (top_level_string_type = ATOMIC_ACTIVE_STRING) then dummy_af_node.atom_sw = "1"b; 819 /* caller requested ||[] */ 820 end; 821 822 call make_list (line_ptr, line_len, ("0"b), start, command_pipe_control_ptr); 823 /* parse line up to first explicit semicolon */ 824 825 do first_node = dummy_node.next /* process this command */ 826 repeat (new_first_node) /* and any within it from AF's */ 827 while (first_node ^= null ()); 828 call match_iters (first_node, evaluate_string, arg_count, iter_count, new_first_node); 829 do iter_index = 1 to iter_count; /* process parentheses */ 830 if command_pipe_control_ptr ^= null then do; 831 command_pipe_control.Niters = iter_count; 832 command_pipe_control.niters = iter_index; 833 end; 834 835 if ^evaluate_string then 836 call read_list (first_node, evaluate_string, arg_count, command_pipe_control_ptr); 837 else do; /* cp_$af: get list as a string */ 838 call write_list (first_node, evaluate_string, arg_count, command_pipe_control_ptr); 839 if (iter_index < iter_count) | (new_first_node ^= null ()) then 840 P_return_value = P_return_value || ";"; 841 end; /* if not last element of list */ 842 end; 843 end; 844 845 call free_nodes ((start = 0)); /* forget command but zero automatic only if more to do */ 846 call release_scratch_segments ((start = 0)); 847 848 if command_pipe_control_ptr ^= null then 849 if command_pipe_control.Sterminate then do; 850 call pipe_$terminate (addr (command_pipe_control.pipe_input_path), 851 addr (command_pipe_control.pipe_output_path), ignore_code); 852 853 free command_pipe_control in (system_area); 854 command_pipe_control_ptr = null; 855 end; 856 857 end; 858 859 return; 860 861 /* Construct the token list: Evaluates active strings and properly threads parentheses for use by match_iters and 862* read_list */ 863 864 make_list: 865 procedure (p_line_ptr, p_line_len, p_token_breaks_sw, p_start, p_pipe_control_ptr); 866 867 dcl p_line_ptr pointer parameter; 868 dcl (p_line_len, p_start) fixed binary (21) parameter; 869 dcl p_token_breaks_sw bit (1) aligned parameter; /* controls if ()[}; recognized */ 870 dcl p_pipe_control_ptr ptr; 871 872 dcl line_ptr pointer; /* parameter copies */ 873 dcl (line_len, start, pipe_line_pos) fixed binary (21); 874 dcl token_breaks_sw bit (1) aligned; 875 876 dcl line character (line_len) based (line_ptr); 877 dcl c (line_len) character (1) unaligned based (line_ptr); 878 879 dcl af_is_atom bit (1) aligned; /* ON => return value is not to be rescanned */ 880 dcl af_is_tokens bit (1) aligned; /* ON => return value should be tokenized only */ 881 dcl catenate_values bit (1) aligned; /* ON => iteration in active string catenates */ 882 dcl semicolon_in_af bit (1) aligned; /* ON => command separator within an active string */ 883 884 dcl (pp, np, top_level_pp) pointer; 885 dcl processing_type fixed binary (9); 886 887 dcl (afp, first_node, new_first_node, af_line_ptr) pointer; 888 dcl (the_character, next_character, next_next_character) character (1); 889 dcl continue_scan bit (1) aligned; 890 dcl (arg_count, iter_count, iter_index) fixed binary; 891 dcl (af_line_len, af_start, idx) fixed binary (21); 892 893 dcl sv_pipe_control_ptr ptr; 894 dcl 1 pipe_control aligned like command_pipe_control based (p_pipe_control_ptr); 895 dcl current_pipe aligned char (pipe_control.current_pipe_len) based (pipe_control.current_pipe_ptr); 896 dcl next_pipe aligned char (pipe_control.next_pipe_len) based (pipe_control.next_pipe_ptr); 897 dcl after_bracket_idx fixed bin (21); 898 899 make_list_depth = make_list_depth + 1; 900 line_ptr = p_line_ptr; 901 line_len = p_line_len; 902 token_breaks_sw = p_token_breaks_sw; 903 start = p_start; 904 sv_pipe_control_ptr = null; 905 906 if (make_list_depth = 1) & evaluate_string then do; 907 top_level_pp, pp = addr (dummy_af_node);/* need a psuedo "[" for string evaluation */ 908 semicolon_in_af = "0"b; /* ... and be sure not to confuse it */ 909 afp = null (); 910 end; 911 else pp = null (); 912 913 /* Main scanning loop */ 914 915 /* pipe line position offset equals the starting char less 1. */ 916 917 pipe_line_pos = start - 1; 918 919 do while (start <= line_len); 920 921 if token_breaks_sw then /* ignore iteration, active strings, and multiple commands */ 922 if use_standard_language then 923 atom_len = search (substr (line, start), TOKEN_BREAKS) - 1; 924 else atom_len = 925 find_char_$first_in_table (substr (line, start), cp_subsys_info.tokens_only_tct_table) 926 - 1; 927 else do; /* allow all features defined in this language */ 928 if use_standard_language then /* ... default situation: all features are enabled */ 929 atom_len = search (substr (line, start), BREAKS) - 1; 930 else atom_len = 931 find_char_$first_in_table (substr (line, start), cp_subsys_info.full_tct_table) - 1; 932 end; 933 934 if atom_len = -1 then do; /* rest of line is ordinary characters ... */ 935 atom_len = line_len - start + 1; 936 call get_node (); /* ... so create an ATOM node to represent it */ 937 np -> atom.type = ATOM; 938 np -> atom.string_ptr = addr (c (start)); 939 np -> atom.string_len = atom_len; 940 start = line_len + 1; /* ... and force the scanning loop to terminate */ 941 end; 942 943 else do; /* have found a character with special meaning ... */ 944 if atom_len > 0 then do; /* ... some ordinary characters in front of it ... */ 945 call get_node (); /* ... ... so create a node to hold onto them */ 946 np -> atom.type = ATOM; 947 np -> atom.string_ptr = addr (c (start)); 948 np -> atom.string_len = atom_len; 949 start = start + atom_len; /* ... and position to the interesting character */ 950 end; 951 952 af_is_atom = "0"b; /* turn off any active string modifiers */ 953 af_is_tokens = "0"b; 954 catenate_values = "0"b; 955 processing_type = get_type (c (start)); 956 go to PROCESS_CHARACTER (processing_type); 957 958 959 /* Determine the processing type of the given character */ 960 961 get_type: 962 procedure (p_character) returns (fixed binary); 963 964 dcl p_character character (1) unaligned parameter; 965 966 if token_breaks_sw then 967 return (token_language.character_types (rank (p_character))); 968 else return (full_language.character_types (rank (p_character))); 969 970 end get_type; 971 972 /* Whitespace: separates tokens on the line but is otherwise ignored (space, horizontal/vertical tab, form feed, newline 973* when scanning just for tokens */ 974 975 PROCESS_WHITESPACE: 976 PROCESS_CHARACTER (1): 977 last_np -> node.space = "1"b; /* separate this token from what (if anything) follows */ 978 go to CONTINUE_SCAN; 979 980 981 /* Command separator: separates multiple commands on the line but is */ 982 /* otherwise ignored (semicolon) */ 983 984 PROCESS_COMMAND_SEPARATOR: 985 PROCESS_CHARACTER (2): 986 987 /* The pipe facility is activated when the string ";|" exists within a command 988* line. Pipes are not available in limited service subsystems or subsystems 989* that do not use the standard command language. */ 990 991 if ^use_standard_language | lss_on then go to PROCESS_SEMICOLON; 992 if substr (line, start, length (PIPE_BREAK)) = PIPE_BREAK then do; 993 if p_pipe_control_ptr = null then do; 994 /* init values here to save on performance. */ 995 allocate pipe_control in (system_area) set (p_pipe_control_ptr); 996 pipe_control.Npipes_in_line = 0; 997 pipe_control.Sterminate = "0"b; 998 pipe_control.Sevaluate_pipe = "0"b; 999 pipe_control.Sbuild_return_string = "0"b; 1000 pipe_control.Sinclude_NL_in_af_ret_str = "0"b; 1001 pipe_control.pipe_input_path = ""; 1002 pipe_control.pipe_output_path = ""; 1003 pipe_control.previous_pipe_ptr = null; 1004 pipe_control.previous_pipe_len = 0; 1005 pipe_control.current_pipe_ptr = null; 1006 pipe_control.current_pipe_len = 0; 1007 pipe_control.next_pipe_ptr = null; 1008 pipe_control.next_pipe_len = 0; 1009 pipe_control.input_ptr = null; 1010 pipe_control.output_ptr = null; 1011 end; 1012 1013 pipe_control.Npipes_in_line = pipe_control.Npipes_in_line + 1; 1014 1015 /* Construct pointers to the previous and current section of the command line 1016* delimited by pipe tokens and line extents. */ 1017 1018 pipe_control.previous_pipe_ptr = pipe_control.current_pipe_ptr; 1019 pipe_control.previous_pipe_len = pipe_control.current_pipe_len; 1020 pipe_control.current_pipe_ptr = addcharno (line_ptr, pipe_line_pos); 1021 pipe_control.current_pipe_len = start - pipe_line_pos - length (";"); 1022 start = start + length (PIPE_BREAK); 1023 1024 if pp ^= null () then 1025 if pp -> node.type = ACTIVE_STRING then do; 1026 1027 /* Position the section pointer after the left bracket so that the pipe 1028* processor can figure out the type of thing being done. */ 1029 1030 after_bracket_idx = search (current_pipe, LEFT_BRACKET); 1031 pipe_control.current_pipe_ptr = 1032 addcharno (pipe_control.current_pipe_ptr, after_bracket_idx); 1033 pipe_control.current_pipe_len = pipe_control.current_pipe_len - after_bracket_idx; 1034 1035 /* Look for the next character. It will be a vertical bar or a right */ 1036 /* bracket. If it isn't, an error will be reported when the end of the */ 1037 /* active function is processed in PROCESS_END_ACTIVE_FUNCTION below. */ 1038 1039 pipe_control.Sevaluate_pipe = "1"b; 1040 if substr (line, start, length (VERTICAL_BAR)) = VERTICAL_BAR then do; 1041 pipe_control.Sinclude_NL_in_af_ret_str = "1"b; 1042 start = start + length (VERTICAL_BAR); 1043 end; 1044 end; 1045 1046 1047 /* Construct pointers to the next section of the command line delimited by 1048* pipe tokens and line extents. The value of next_pipe may or may not be 1049* the entire contents of the next command or attach description 1050* processed. The value will be the entire contents when there are no 1051* special characters within it. It is not required for the string to be 1052* complete. Using this strategy, the value will contain the first special 1053* character. The value is checked a by subroutine of process_pipe below. 1054* Whenever a the string contains special characters, a temporary pipe 1055* file will be used for output. When the string does not contain special 1056* characters and is a valid attach description, then and only then, it is 1057* used as the output of the pipe. */ 1058 1059 pipe_control.next_pipe_len = search (substr (line, start), COMMAND_BREAKS); 1060 1061 if pipe_control.next_pipe_len > 0 then do; 1062 pipe_control.next_pipe_ptr = addcharno (line_ptr, start - 1); 1063 pipe_control.next_pipe_len = pipe_control.next_pipe_len - 1; 1064 end; 1065 else do; 1066 pipe_control.next_pipe_ptr = addcharno (line_ptr, start - 1); 1067 if line_len >= start then 1068 pipe_control.next_pipe_len = line_len - (start - 1); 1069 else pipe_control.next_pipe_len = 0; 1070 end; 1071 1072 /* If the pipe is to run as an active function, determine if this is the 1073* last section of the active string. If so, setup for the active function 1074* return string to be built. If there is an include new line token in the 1075* middle of the pipe, report an error. Otherwise, call the active function 1076* processor. */ 1077 1078 if pipe_control.Sevaluate_pipe then do; 1079 if substr (ltrim (next_pipe), 1, length (RIGHT_BRACKET)) = RIGHT_BRACKET then 1080 pipe_control.Sbuild_return_string = "1"b; 1081 else do; 1082 if pipe_control.Sinclude_NL_in_af_ret_str then do; 1083 code = error_table_$bad_pipe_syntax; 1084 error_message = 1085 "The string "";||"" may only appear at the end of pipe active strings."; 1086 go to RETURN_FROM_CP; 1087 end; 1088 end; 1089 1090 start = start - 1; /* make_list adds 1 */ 1091 pipe_line_pos = start; 1092 semicolon_in_af = "1"b; 1093 call process_active_function (p_pipe_control_ptr); 1094 end; 1095 end; 1096 1097 /* A regular semicolon was found. If the pipe facility is "on", turn it off */ 1098 1099 else do; 1100 if p_pipe_control_ptr ^= null then do; 1101 pipe_control.Sterminate = "1"b; 1102 pipe_control.previous_pipe_ptr = pipe_control.current_pipe_ptr; 1103 pipe_control.previous_pipe_len = pipe_control.current_pipe_len; 1104 pipe_control.current_pipe_ptr = addcharno (line_ptr, pipe_line_pos); 1105 pipe_control.current_pipe_len = start - pipe_line_pos - 1; 1106 pipe_control.next_pipe_ptr = null; 1107 pipe_control.next_pipe_len = 0; 1108 end; 1109 PROCESS_SEMICOLON: 1110 start = start + 1; /* next command follows the ; */ 1111 if (start > 0) & (pp ^= null ()) then 1112 if pp -> node.type = ACTIVE_STRING then do; 1113 1114 /* Because the return string from a pipe is built at the end of the bracket 1115* pair, it is not possible to process active functions after pipe active 1116* functions. If this were done, the return string would not be builr in the 1117* same sequence as the command line issued them. If this is done, report 1118* an error message. */ 1119 1120 if p_pipe_control_ptr ^= null then 1121 if pipe_control.Sevaluate_pipe then do; 1122 code = error_table_$bad_pipe_syntax; 1123 error_message = 1124 "Nonpipe semicolons cannot appear after pipe breaks in pipe active strings." 1125 ; 1126 go to RETURN_FROM_CP; 1127 end; 1128 1129 start = start - 1; /* ... make_list will add 1 */ 1130 pipe_line_pos = start; 1131 semicolon_in_af = "1"b; 1132 call process_active_function (p_pipe_control_ptr); 1133 end; /* ... above procedure doesn't return (sigh) */ 1134 end; 1135 1136 go to RETURN_FROM_MAKE_LIST; 1137 1138 1139 /* Command separator or whitespace: separates multiple commands on the line when using the full language but is also 1140* recognized when scanning active function return values for tokens as being equivalent to whitespace (new-line) */ 1141 1142 PROCESS_CHARACTER (3): 1143 if token_breaks_sw then 1144 go to PROCESS_WHITESPACE; /* nice and easy ... */ 1145 else go to PROCESS_COMMAND_SEPARATOR; 1146 1147 /* Single character token: appears as a one character argument to the command even if not surrounded by whitespace */ 1148 1149 PROCESS_CHARACTER (4): 1150 last_np -> node.space = "1"b; /* forced separation */ 1151 1152 call get_node (); /* create an atom node for this character */ 1153 np -> atom.type = ATOM; 1154 np -> atom.string_ptr = addr (c (start)); 1155 np -> atom.string_len = 1; 1156 np -> atom.space = "1"b; /* ... and separate it from whatever follows */ 1157 go to CONTINUE_SCAN; 1158 1159 1160 /* Compound token: appears as an argument to the command even if not surrounded by whitespace; if several of this type of 1161* character appear on the line without any intervening characters, they are merged into a single argument (eg: ^=) */ 1162 1163 PROCESS_CHARACTER (5): 1164 last_np -> node.space = "1"b; /* forced separation */ 1165 1166 call get_node (); /* create an atom for this and following compounded chars */ 1167 np -> atom.type = ATOM; 1168 np -> atom.string_ptr = addr (c (start)); 1169 np -> atom.string_len = 0; 1170 np -> atom.space = "1"b; /* ... and separate them from whatever follows */ 1171 1172 do while (start <= line_len); /* scan until we hit end of compound token characters */ 1173 processing_type = get_type (c (start)); 1174 if processing_type = COMPOUND_TOKEN then 1175 np -> atom.string_len = np -> atom.string_len + 1; 1176 else do; /* found a non-compound character */ 1177 start = start - 1; /* ... CONTINUE_SCAN label bumps this value */ 1178 go to CONTINUE_SCAN; 1179 end; 1180 start = start + 1; /* move right along */ 1181 end; 1182 1183 go to RETURN_FROM_MAKE_LIST; /* here iff rest of line was compound tokens */ 1184 1185 /* Quote character -- begins and ends a quoted string: only the same character ends the quoted string (ie: "' isn't a 1186* completed string if both are quoting characters); within the string, any occurence of this character must be doubled */ 1187 1188 PROCESS_CHARACTER (6): 1189 the_character = c (start); /* this is the only character that will stop us */ 1190 1191 continue_scan = "1"b; /* until we find the closing quote character */ 1192 do while (continue_scan); 1193 idx = index (substr (line, (start + 1)), the_character); 1194 if idx = 0 then do; /* unbalanced quoting characters ... */ 1195 code = error_table_$unbalanced_quotes; 1196 go to RETURN_FROM_CP; 1197 end; 1198 call get_node (); /* make an atom for next piece of quoted string */ 1199 np -> atom.type = ATOM; 1200 np -> atom.string_ptr = addr (c (start + 1)); 1201 np -> atom.string_len = idx - 1; 1202 start = start + idx; /* skip to next quoting character */ 1203 if start < line_len then /* check for literal quoted character within the string */ 1204 if substr (line, (start + 1), 1) = the_character then do; 1205 np -> atom.string_len = np -> atom.string_len + 1; 1206 start = start + 1; /* ... yes: add one to the string and keep scanning */ 1207 end; 1208 else continue_scan = "0"b; 1209 else continue_scan = "0"b; /* ... no: have completed the string */ 1210 end; 1211 1212 go to CONTINUE_SCAN; /* here iff we have a completed quoted string */ 1213 1214 1215 /* Active string modifier: modifies the interpretation of active strings; otherwise, treat as normal character (|) */ 1216 1217 PROCESS_CHARACTER (7): 1218 the_character = c (start); /* pick up the modifier */ 1219 1220 if start < line_len then /* and the following character (if present) */ 1221 next_character = substr (line, (start + 1), 1); 1222 else next_character = low (1); 1223 1224 if start < (line_len - 1) then /* and the character after that ... */ 1225 next_next_character = substr (line, (start + 2), 1); 1226 else next_next_character = low (1); 1227 1228 if (start < (line_len - 1)) & (next_character = the_character) 1229 & (get_type (next_next_character) >= BEGIN_ACTIVE_STRING_1) 1230 & (get_type (next_next_character) <= BEGIN_ACTIVE_STRING_8) then do; 1231 af_is_atom = "1"b; /* ||[ -- do not scan active string result */ 1232 start = start + 2; 1233 processing_type = get_type (next_next_character); 1234 go to PROCESS_BEGIN_ACTIVE_STRING; 1235 end; 1236 1237 else if (start < line_len) & (get_type (next_character) >= BEGIN_ACTIVE_STRING_1) 1238 & (get_type (next_character) <= BEGIN_ACTIVE_STRING_8) then do; 1239 af_is_tokens = "1"b; /* |[ -- rescan only for whitespace and quoted strings */ 1240 start = start + 1; 1241 processing_type = get_type (next_character); 1242 go to PROCESS_BEGIN_ACTIVE_STRING; 1243 end; 1244 1245 else if (start < line_len) & (get_type (next_character) >= END_ACTIVE_STRING_1) 1246 & (get_type (next_character) <= END_ACTIVE_STRING_8) then do; 1247 catenate_values = "1"b; /* |] -- catenate iterated results */ 1248 start = start + 1; 1249 processing_type = get_type (next_character); 1250 go to PROCESS_END_ACTIVE_STRING; 1251 end; 1252 1253 else do; /* nothing special about this occurence ... */ 1254 call get_node (); /* ... create a node to hold onto the character */ 1255 np -> atom.type = ATOM; 1256 np -> atom.string_ptr = addr (c (start)); 1257 np -> atom.string_len = 1; 1258 go to CONTINUE_SCAN; 1259 end; 1260 1261 /* Begin an iteration set: there may be up to eight different groups of iteration set delimiters (left parenthesis) */ 1262 1263 /* format: off */ 1264 PROCESS_CHARACTER (17): PROCESS_CHARACTER (18): PROCESS_CHARACTER (19): PROCESS_CHARACTER (20): 1265 PROCESS_CHARACTER (21): PROCESS_CHARACTER (22): PROCESS_CHARACTER (23): PROCESS_CHARACTER (24): ; 1266 /* format: on */ 1267 call get_node (); /* add an iteration node */ 1268 np -> iter_begin.type = BEGIN_ITERATION; 1269 np -> iter_begin.parent = pp; 1270 np -> iter_begin.delimiter_class = processing_type; 1271 1272 pp = np; /* push parent */ 1273 iter_level = iter_level + 1; 1274 1275 go to CONTINUE_SCAN; 1276 1277 1278 /* End an iteration set (right parenthesis) */ 1279 1280 /* format: off */ 1281 PROCESS_CHARACTER (25): PROCESS_CHARACTER (26): PROCESS_CHARACTER (27): PROCESS_CHARACTER (28): 1282 PROCESS_CHARACTER (29): PROCESS_CHARACTER (30): PROCESS_CHARACTER (31): PROCESS_CHARACTER (32): ; 1283 /* format: on */ 1284 if pp = null () then do; /* no matching begin iteration set delimiter */ 1285 code = error_table_$unbalanced_parentheses; 1286 go to RETURN_FROM_CP; 1287 end; 1288 1289 else if pp -> node.type ^= BEGIN_ITERATION then do; 1290 code = error_table_$unbalanced_brackets; 1291 go to RETURN_FROM_CP; /* [) situation */ 1292 end; 1293 1294 else if pp -> iter_begin.delimiter_class ^= (processing_type - 8) then do; 1295 code = error_table_$unbalanced_parentheses; 1296 go to RETURN_FROM_CP; /* previous begin iteration is of the wrong class */ 1297 end; 1298 1299 if last_np -> node.type = END_ITERATION then 1300 last_np -> node.space = "0"b; /* multiple end iterations: ignore intervening whitespace */ 1301 1302 else do; /* first end iteration so far */ 1303 if last_np -> node.type = ATOM then last_np -> node.space = "1"b; 1304 call get_node (); /* ... create an end iteration node */ 1305 np -> node.type = END_ITERATION; 1306 np -> iter_end.begin = pp; 1307 end; 1308 1309 iter_level = iter_level - 1; /* one less unclosed iteration set */ 1310 last_np -> iter_end.level = iter_level; 1311 last_np -> iter_end.parent = pp; 1312 pp -> iter_begin.end = last_np; /* let begin iteration node know where we are */ 1313 pp = pp -> iter_begin.parent; /* pop parent */ 1314 1315 go to CONTINUE_SCAN; 1316 1317 /* Begin an active string: there may be up to eight different groups of active string delimiters (left bracket) */ 1318 1319 /* format: off */ 1320 PROCESS_BEGIN_ACTIVE_STRING: 1321 PROCESS_CHARACTER (33): PROCESS_CHARACTER (34): PROCESS_CHARACTER (35): PROCESS_CHARACTER (36): 1322 PROCESS_CHARACTER (37): PROCESS_CHARACTER (38): PROCESS_CHARACTER (39): PROCESS_CHARACTER (40): ; 1323 /* format: on */ 1324 call get_node (); /* add an active string node */ 1325 np -> af.type = ACTIVE_STRING; 1326 np -> af.parent = pp; 1327 np -> af.delimiter_class = processing_type; 1328 1329 np -> af.atom_sw = af_is_atom; /* record options known so far */ 1330 np -> af.tokens_sw = af_is_tokens; 1331 np -> af.catenate_sw = "0"b; 1332 1333 if evaluate_string & (afp = top_level_pp) then top_level_pp = np; 1334 /* new top level of evaluate_active_string */ 1335 pp = np; /* push parent */ 1336 1337 np -> af.level = iter_level; /* save iteration level */ 1338 iter_level = 0; /* iteration sets in an active string are independent */ 1339 1340 /* This case label is entered when a left bracket is found and after a 1341* semicolon or pipe token pair is found within an active string. The value 1342* must be checked. If this is a new active function and if there is a pipe 1343* active for the current level, the processing of the string as a pipe must 1344* be suspended. Once done, this new active string can be evaluated on its 1345* own. Processing of the new active function is ended and the previous 1346* pipe is restored when the right bracket is found. */ 1347 1348 if p_pipe_control_ptr ^= null then 1349 if substr (line, start, length (LEFT_BRACKET)) = LEFT_BRACKET then do; 1350 sv_pipe_control_ptr = p_pipe_control_ptr; 1351 1352 on condition (cleanup) 1353 begin; 1354 1355 if p_pipe_control_ptr ^= null then do; 1356 call pipe_$terminate (addr (pipe_control.pipe_input_path), 1357 addr (pipe_control.pipe_output_path), ignore_code); 1358 free pipe_control in (system_area); 1359 end; 1360 1361 /* Put back the command level pipe info if there is any */ 1362 p_pipe_control_ptr = sv_pipe_control_ptr; 1363 sv_pipe_control_ptr = null; 1364 end; 1365 p_pipe_control_ptr = null; 1366 end; 1367 1368 go to CONTINUE_SCAN; 1369 1370 1371 /* End an active string (right bracket) */ 1372 1373 /* format: off */ 1374 PROCESS_END_ACTIVE_STRING: 1375 PROCESS_CHARACTER (41): PROCESS_CHARACTER (42): PROCESS_CHARACTER (43): PROCESS_CHARACTER (44): 1376 PROCESS_CHARACTER (45): PROCESS_CHARACTER (46): PROCESS_CHARACTER (47): PROCESS_CHARACTER (48): ; 1377 /* format: on */ 1378 if pp = null () then do; /* no begin active string */ 1379 code = error_table_$unbalanced_brackets; 1380 go to RETURN_FROM_CP; 1381 end; 1382 1383 else if (make_list_depth = 1) & evaluate_string & (pp = top_level_pp) then do; 1384 code = error_table_$unbalanced_brackets; 1385 go to RETURN_FROM_CP; /* evaluate_active_string: caller should've stripped this */ 1386 end; 1387 1388 else if pp -> node.type ^= ACTIVE_STRING then do; 1389 code = error_table_$unbalanced_parentheses; 1390 go to RETURN_FROM_CP; /* (] situation */ 1391 end; 1392 1393 else if pp -> af.delimiter_class ^= (processing_type - 8) then do; 1394 code = error_table_$unbalanced_brackets; 1395 go to RETURN_FROM_CP; /* previous begin active string is of the wrong class */ 1396 end; 1397 1398 if p_pipe_control_ptr ^= null then do; 1399 1400 /* If the pipe facility is in use as an active function, check for proper 1401* termination of the string. Then, terminate the pipe facility for this 1402* active string. */ 1403 1404 if return_ptr = null | ^pipe_control.Sbuild_return_string then do; 1405 if current_pipe = "" then do; 1406 code = error_table_$null_brackets; 1407 go to RETURN_FROM_CP; 1408 end; 1409 else do; 1410 code = error_table_$bad_pipe_syntax; 1411 error_message = "Pipe active strings must end with "";|]"" or "";||]"""; 1412 go to RETURN_FROM_CP; 1413 end; 1414 end; 1415 1416 call pipe_$terminate (addr (pipe_control.pipe_input_path), 1417 addr (pipe_control.pipe_output_path), ignore_code); 1418 free pipe_control in (system_area); 1419 p_pipe_control_ptr = sv_pipe_control_ptr; 1420 sv_pipe_control_ptr = null; 1421 if p_pipe_control_ptr ^= null then revert cleanup; 1422 end; 1423 1424 else if return_ptr = null then 1425 if pp -> af.next = null () then do; 1426 code = error_table_$null_brackets; 1427 go to RETURN_FROM_CP; 1428 end; 1429 1430 if p_pipe_control_ptr = null then do; 1431 p_pipe_control_ptr = sv_pipe_control_ptr; 1432 sv_pipe_control_ptr = null; 1433 end; 1434 1435 semicolon_in_af = "0"b; 1436 1437 call process_active_function (p_pipe_control_ptr); 1438 1439 /* doesn't return */ 1440 1441 CONTINUE_SCAN: /* finished processing of special character ... */ 1442 start = start + 1; /* ... so move on to the rest of the line (if any) */ 1443 1444 end; 1445 end; 1446 1447 1448 /* End of line */ 1449 if p_pipe_control_ptr ^= null then do; 1450 pipe_control.Sterminate = "1"b; 1451 pipe_control.previous_pipe_ptr = pipe_control.current_pipe_ptr; 1452 pipe_control.previous_pipe_len = pipe_control.current_pipe_len; 1453 pipe_control.current_pipe_ptr = addcharno (line_ptr, pipe_line_pos); 1454 pipe_control.current_pipe_len = start - pipe_line_pos - 1; 1455 pipe_control.next_pipe_ptr = null; 1456 pipe_control.next_pipe_len = 0; 1457 end; 1458 1459 start = 0; /* remember no more commands left on this line */ 1460 1461 RETURN_FROM_MAKE_LIST: 1462 if pp ^= null () then do; /* possibly unbalanced line */ 1463 if (make_list_depth = 1) & evaluate_string & (pp = top_level_pp) then 1464 call process_active_function (p_pipe_control_ptr); 1465 /* end of evaluate_active_string: do it */ 1466 if pp -> node.type = BEGIN_ITERATION then 1467 code = error_table_$unbalanced_parentheses; 1468 else code = error_table_$unbalanced_brackets; 1469 go to RETURN_FROM_CP; 1470 end; 1471 1472 p_start = start; /* set result */ 1473 1474 make_list_depth = make_list_depth - 1; 1475 return; 1476 1477 /* Evaluates part of an active string: Processes a single active function's portion of the active string. The active 1478* function may be invoked several times as parentheses may have been used in this portion of the active string */ 1479 1480 process_active_function: 1481 procedure (pipe_control_ptr); 1482 1483 dcl pipe_control_ptr ptr; 1484 dcl 1 pipe_control aligned like command_pipe_control based (pipe_control_ptr); 1485 1486 dcl nonvarying_return_string character (length (return_string)) unaligned based (addrel (addr (return_string), 1)); 1487 1488 1489 last_np -> node.space = "1"b; /* finish last argument to the active function */ 1490 afp = pp; /* save pointer to beginning of active function sublist */ 1491 pp = afp -> af.parent; /* pop parent */ 1492 last_np = afp -> af.prev; /* unthread from list */ 1493 last_np -> node.next = null (); 1494 1495 afp -> af.catenate_sw = catenate_values;/* ON if |] */ 1496 1497 1498 do first_node = afp -> node.next /* process the active function */ 1499 repeat (new_first_node) /* ... and any returned command delimiters */ 1500 while (first_node ^= null ()); 1501 1502 call match_iters (first_node, active_function, arg_count, iter_count, new_first_node); 1503 1504 /* pipes as active functions do not use the last argument as the return string 1505* so arg_count is reduced by 1. */ 1506 1507 if pipe_control_ptr ^= null then 1508 if pipe_control.Sevaluate_pipe then 1509 if arg_count > 0 then arg_count = arg_count - 1; 1510 1511 do iter_index = 1 to iter_count; 1512 if pipe_control_ptr = null then 1513 call read_list (first_node, active_function, arg_count, null); 1514 else if pipe_control.Sevaluate_pipe then do; 1515 /* calling a pipe. set the call up as a command */ 1516 pipe_control.Niters = iter_count; 1517 pipe_control.niters = iter_index; 1518 call read_list (first_node, command, arg_count, pipe_control_ptr); 1519 end; 1520 else /* regular af mixed with pipe af */ 1521 call read_list (first_node, active_function, arg_count, null); 1522 if return_ptr ^= null then 1523 if ((length (return_string) = 0) & ^afp -> af.atom_sw) 1524 | (return_string = "" & p_pipe_control_ptr ^= null) then 1525 ; /* ignore null return value unless ||[ */ 1526 1527 else do; /* may have to process return value */ 1528 if ^afp -> af.atom_sw & ^afp -> af.tokens_sw then 1529 if use_standard_language then 1530 if search (return_string, BREAKS) ^= 0 then 1531 call evaluate_af_result (); 1532 else call treat_af_result_as_atom (); 1533 else if 1534 find_char_$first_in_table (nonvarying_return_string, 1535 cp_subsys_info.full_tct_table) ^= 0 then 1536 call evaluate_af_result (); 1537 else call treat_af_result_as_atom (); 1538 1539 else if afp -> af.atom_sw then call treat_af_result_as_atom (); 1540 1541 else do; /* don't recognize iteration, active strings, etc */ 1542 if use_standard_language then 1543 if search (return_string, TOKEN_BREAKS) ^= 0 then 1544 call evaluate_af_result (); 1545 else call treat_af_result_as_atom (); 1546 else if 1547 find_char_$first_in_table (nonvarying_return_string, 1548 cp_subsys_info.tokens_only_tct_table) ^= 0 then 1549 call evaluate_af_result (); 1550 else call treat_af_result_as_atom (); 1551 end; 1552 1553 if (iter_index = iter_count) & (new_first_node = null ()) then 1554 last_np -> node.space = "0"b; 1555 /* last value from active function */ 1556 else last_np -> node.space = ^(afp -> af.catenate_sw); 1557 /* intermediate value: normally space */ 1558 end; 1559 end; 1560 end; 1561 1562 1563 iter_level = afp -> af.level; 1564 1565 if semicolon_in_af then do; /* if active string has more sub-parts */ 1566 semicolon_in_af = "0"b; 1567 af_is_atom = afp -> af.atom_sw; /* "quoting" result applies to all parts */ 1568 af_is_tokens = afp -> af.tokens_sw; 1569 if pipe_control_ptr = null then last_np -> node.space = "1"b; 1570 else if ^pipe_control.Sevaluate_pipe then last_np -> node.space = "1"b; 1571 1572 /* always separate sub-parts */ 1573 processing_type = afp -> af.delimiter_class; 1574 go to PROCESS_BEGIN_ACTIVE_STRING; 1575 end; 1576 1577 if (make_list_depth = 1) & evaluate_string & (afp = top_level_pp) then go to RETURN_FROM_MAKE_LIST; 1578 /* end of an evaluate_string entry */ 1579 go to CONTINUE_SCAN; 1580 1581 /* Internal to process_active_function: rescans and re-evaluates the active function's return string */ 1582 1583 evaluate_af_result: 1584 procedure (); 1585 1586 dcl pipe_control_ptr ptr; 1587 dcl 1 pipe_control aligned like command_pipe_control based (pipe_control_ptr); 1588 1589 af_line_ptr = addrel (return_ptr, 1); 1590 af_line_len = length (return_string); 1591 call return_string_advance (); 1592 1593 af_start = 1; 1594 pipe_control_ptr = null; 1595 1596 on condition (cleanup) 1597 begin; 1598 1599 if pipe_control_ptr ^= null then do; 1600 call pipe_$terminate (addr (pipe_control.pipe_input_path), 1601 addr (pipe_control.pipe_output_path), ignore_code); 1602 free pipe_control in (system_area); 1603 p_pipe_control_ptr = null; 1604 end; 1605 end; 1606 1607 call make_list (af_line_ptr, af_line_len, afp -> af.tokens_sw, af_start, pipe_control_ptr); 1608 1609 do while (af_start > 0); /* see if af value had semicolon */ 1610 call get_node (); /* sets af_prev of new node */ 1611 np -> node.type = END_OF_COMMAND; 1612 np -> node.af_prev -> atom.space = "1"b; 1613 /* previous node ends list */ 1614 call make_list (af_line_ptr, af_line_len, afp -> af.tokens_sw, af_start, pipe_control_ptr); 1615 if pipe_control_ptr ^= null then do; 1616 call pipe_$terminate (addr (pipe_control.pipe_input_path), 1617 addr (pipe_control.pipe_output_path), ignore_code); 1618 free pipe_control in (system_area); 1619 pipe_control_ptr = null; 1620 end; 1621 end; 1622 1623 return; 1624 1625 end evaluate_af_result; 1626 1627 1628 1629 /* Internal to process_active_function: makes the active function's return string appear as a single token in the expanded 1630* command line */ 1631 1632 treat_af_result_as_atom: 1633 procedure (); 1634 1635 call get_node (); 1636 np -> atom.type = ATOM; 1637 np -> atom.string_ptr = addrel (return_ptr, 1); 1638 np -> atom.string_len = length (return_string); 1639 1640 call return_string_advance (); 1641 1642 return; 1643 1644 end treat_af_result_as_atom; 1645 1646 end process_active_function; 1647 1648 /* Internal to make_list: "Allocate" a node, obtaining a new node_block if necessary */ 1649 1650 get_node: 1651 procedure (); 1652 1653 null_cl = "0"b; /* has to be something there or we wouldn't be here */ 1654 1655 node_index = node_index + 1; 1656 if node_index > hbound (node_block.array, 1) then do; 1657 /* allocate a new block */ 1658 1659 last_block_ptr = block_ptr; 1660 1661 allocate node_block in (system_area) set (block_ptr); 1662 1663 unspec (node_block) = "0"b; 1664 node_block.next = null (); 1665 last_block_ptr -> node_block.next = block_ptr; 1666 node_index = 1; 1667 end; 1668 1669 np = addr (node_block.array (node_index)); 1670 /* the node starts out as all zeroes */ 1671 np -> node.next = null (); 1672 np -> node.af_prev = last_np; /* in case node is af node */ 1673 np -> node.af_iter_parent = null (); 1674 1675 last_np -> node.next = np; 1676 last_np = np; 1677 1678 end get_node; 1679 1680 1681 1682 /* Internal to make_list: Move return_ptr past the string just returned from the current active string invocation so that 1683* the result will not be lost */ 1684 1685 return_string_advance: 1686 procedure (); 1687 1688 return_len = return_len - 4 * divide (length (return_string) + 3, 4, 21, 0) - 1; 1689 1690 if return_len >= MIN_AF_RETURN_LTH then /* always give AF a certain minimum amount of space */ 1691 return_ptr = addrel (return_ptr, divide (length (return_string) + 7, 4, 17, 0)); 1692 else return_ptr = null (); /* not enough space left in this segment */ 1693 1694 end return_string_advance; 1695 1696 end make_list; 1697 1698 /* Compute number of iteration and arguments for the command and validate that matching iteration sets contain matching 1699* numbers of elements: Two iteration sets are matching if either (1) they are connected (ie: the right parenthesis 1700* ending the first is not separated from the left parenthesis of the second by white space) or (2) they are top level 1701* iteration sets */ 1702 1703 match_iters: 1704 procedure (p_first_node, p_command_type, p_arg_count, p_iter_count, p_new_first_node); 1705 1706 dcl (p_first_node, p_new_first_node) pointer parameter; 1707 dcl p_command_type bit (1) aligned parameter; 1708 dcl (p_arg_count, p_iter_count) fixed binary parameter; 1709 1710 dcl (p, pp) pointer; 1711 dcl first_iter bit (1) aligned; 1712 1713 1714 first_iter = "1"b; 1715 p_arg_count, p_iter_count = 0; 1716 p_new_first_node = null (); /* assume no semicolon left by AF */ 1717 1718 p = p_first_node; 1719 if p = null () then return; /* empty list */ 1720 pp = null (); /* pointer to last outer iteration set to be processed */ 1721 do while (p ^= null ()); /* to end of list */ 1722 1723 if p -> node.type = BEGIN_ITERATION then do; 1724 /* outer iteration set */ 1725 pp = p; /* record pointer to iter node of iteration set */ 1726 1727 call count_iteration ((p), count, 0, iter_level); 1728 /* iter_level should equal 0 */ 1729 1730 if first_iter then do; 1731 first_iter = "0"b; 1732 p_iter_count = count; /* save for later comparison */ 1733 end; 1734 else if count ^= p_iter_count then do; 1735 MISMATCH: 1736 code = error_table_$mismatched_iter; 1737 go to RETURN_FROM_CP; 1738 end; 1739 1740 p_arg_count = p_arg_count + 1; /* each outer iteration set is an argument */ 1741 if p ^= null () then /* if iteration set does not end node list */ 1742 if p -> node.next = null () then 1743 /* but node after it does */ 1744 p -> atom.space = "1"b; /* list ends with atom */ 1745 else ; 1746 end; 1747 else if p -> node.type = END_OF_COMMAND then do; 1748 /* semicolon embedded by an AF */ 1749 p_new_first_node = p -> node.next; /* remember where next piece is */ 1750 p -> node.af_prev -> node.next = null (); 1751 /* remove from chain */ 1752 p = null (); /* do not look at rest */ 1753 end; 1754 else do; /* not ( or ; */ 1755 if p -> atom.next = null () then p -> atom.space = "1"b; 1756 /* last node in list */ 1757 if p -> node.space then p_arg_count = p_arg_count + 1; 1758 p = p -> atom.next; 1759 end; 1760 end; 1761 1762 if p_arg_count = 0 then 1763 p_iter_count = 0; /* no arguments: this is an empty list */ 1764 1765 else do; 1766 if p_command_type ^= active_function then p_arg_count = p_arg_count - 1; 1767 /* first argument is actually the command/AF name and should 1768* not be included in the argument count: however, as AFs have 1769* an extra argument (the return value), it isn't necessary to 1770* change this value for AFs */ 1771 if first_iter then p_iter_count = 1; /* no iterations: read the list once */ 1772 end; 1773 1774 return; 1775 1776 /* Internal to match_iters: processes a single iteration set (and any interation connected to it). For example, (1 2) is 1777* a simple iteration set containing two (2) members; while (1 2)x(3 4) is a more complication expression involving two 1778* (2) connected iteration sets, but again only containing 2 members (1x3 and 2x4). The iteration set (a (1 2)x(3 4) 5)x 1779* is an iteration set which contains four (4) members, namely ax, 1x3x, 2x4x, and 5x. 1780* 1781* Count_iteration returns the number of members in iteration_count and updates final_level to include all parentheses 1782* encountered in any of the nodes processed. The node pointer variable 'p' is alsoupdated to point to the node following 1783* the node which ends the iteration set. This is the first node unconnected to the iteration set */ 1784 1785 count_iteration: 1786 procedure (p_initial_p, p_iteration_count, p_parent_level, p_final_level); 1787 1788 dcl p_initial_p pointer parameter; 1789 dcl (p_iteration_count, p_parent_level, p_final_level) fixed binary parameter; 1790 dcl (sub_count, temp_count) fixed binary; 1791 dcl (need_space, first_count) bit (1) aligned; 1792 1793 p_iteration_count = 0; 1794 p_final_level = p_parent_level + 1; /* count left paren */ 1795 p = p_initial_p; /* actually a no-op */ 1796 1797 p = p -> node.next; 1798 do while (p_final_level > p_parent_level); 1799 if p = null () then go to MISMATCH;/* not enough )'s */ 1800 need_space = "1"b; /* need to find a node which separates this 1801* iteration set from rest of command line */ 1802 first_count = "1"b; /* next iteration node begins an imbedded 1803* iteration set which is not connected to previous one */ 1804 1805 sub_count = 0; 1806 do while (need_space); 1807 if p -> node.type = END_ITERATION then do; 1808 if p -> node.next = null () then p -> node.space = "1"b; 1809 pp = p -> iter_end.parent -> iter_begin.parent; 1810 p_final_level = p -> iter_end.level; 1811 if p_final_level < p_parent_level then do; 1812 /* multiple closure, pop one level */ 1813 p_final_level = p_parent_level; 1814 need_space = "0"b; /* do not advance to next node */ 1815 end; 1816 else do; /* closing one level */ 1817 need_space = ^p -> iter_end.space; 1818 p = p -> iter_end.next; 1819 end; 1820 end; 1821 else if p -> node.type = ATOM then do; 1822 if p -> atom.space & (p_final_level = (p_parent_level + 1)) then 1823 sub_count = sub_count + 1; 1824 if p -> node.next = null () then 1825 /* if last node in list */ 1826 p -> node.space = "1"b; 1827 need_space = ^p -> node.space; 1828 p = p -> node.next; 1829 end; 1830 else if p -> node.type = BEGIN_ITERATION then do; 1831 /* another iteration set */ 1832 if p_final_level = p_parent_level then do; 1833 /* this iteration is connected to */ 1834 first_count = "0"b; /* initial iteration at p_parent_level+1 */ 1835 sub_count = sub_count + p_iteration_count; 1836 /* save for later comparison */ 1837 p_iteration_count = 0; 1838 /* compute iter count for connected iter */ 1839 end; /* count the sub iteration */ 1840 call count_iteration ((p), temp_count, (p_final_level), p_final_level); 1841 if first_count then do; 1842 sub_count = temp_count; 1843 /* save count of first iteration */ 1844 first_count = "0"b; 1845 end; 1846 else if sub_count ^= temp_count then go to MISMATCH; 1847 /* this is count of an iter set connected to the first iter */ 1848 need_space = "0"b; 1849 end; 1850 else do; /* semicolon in AF result embedded in parentheses ... */ 1851 code = error_table_$unbalanced_parentheses; 1852 go to RETURN_FROM_CP; /* ... is an error */ 1853 end; 1854 end; 1855 p_iteration_count = p_iteration_count + sub_count; 1856 /* add to sum for parent iter set */ 1857 end; 1858 1859 end count_iteration; 1860 1861 end match_iters; 1862 1863 /* Create a command's argument list and either invoke it or produce a character string representation of the arguments: 1864* An argument list is generated (with descriptors) for the node list beginning at p_first_node */ 1865 1866 produce_argument_list: 1867 procedure (p_first_node, p_command_type, p_arg_count); 1868 1869 dcl p_first_node pointer parameter; 1870 dcl p_command_type bit (1) aligned parameter; 1871 dcl p_arg_count fixed binary parameter; 1872 dcl p_pipe_control_ptr ptr; 1873 1874 dcl read_list_entry bit (1) aligned; 1875 1876 dcl (p, pp) pointer; 1877 1878 dcl start_arg bit (1) aligned; 1879 dcl null_iter bit (1) aligned; /* ON means a null nested iter was found */ 1880 dcl rethreaded bit (1) aligned; /* ON if list already rethreaded */ 1881 dcl (saved_level, argument_idx) fixed binary; 1882 1883 dcl command_name character (arg_len (0)) unaligned based (command_name_ptr); 1884 dcl command_name_ptr pointer; 1885 dcl command_entry_ptr pointer; /* command to call */ 1886 1887 dcl (extension_size, needed_space) fixed binary (21); 1888 dcl (arg_ptr, stack_ptr, space_ptr) pointer; 1889 dcl arg_space fixed binary (21); /* number of chars left in space acquired */ 1890 1891 dcl object character (object_lth) unaligned based (object_ptr); 1892 dcl object_ptr pointer; 1893 dcl object_lth fixed binary (21); 1894 dcl suffix character (1) varying; 1895 1896 dcl current_arg_len fixed binary (21); /* number of chars in (non-simple) arg being developed */ 1897 dcl current_arg character (current_arg_len) unaligned based (arg_ptr); 1898 1899 dcl arg character (arg_space) unaligned based (arg_ptr); 1900 dcl arg_len (0:p_arg_count + 1) fixed binary automatic; 1901 1902 dcl 1 arg_list aligned automatic, 1903 2 twice_no_of_args fixed binary (18) unaligned unsigned, 1904 2 tag bit (18) unaligned initial ("000004"b3), 1905 2 twice_no_of_descriptors fixed binary (18) unaligned unsigned, 1906 2 has_command_name bit (1) unal, 1907 2 pad bit (17) unaligned initial ("0"b), 1908 2 arg_ptr (p_arg_count) pointer, 1909 2 descriptor_ptr (p_arg_count) pointer, 1910 2 name, 1911 3 command_name_ptr pointer, 1912 3 command_name_length fixed bin (21); 1913 1914 dcl 1 descriptor (p_arg_count) aligned automatic, 1915 2 bits bit (12) unaligned, /* flag(1), type(6), packed(1), and ndims(4) */ 1916 2 size fixed binary (24) unaligned unsigned; 1917 1918 /* Construct the argument list and then invoke the command */ 1919 1920 read_list: 1921 entry (p_first_node, p_command_type, p_arg_count, p_pipe_control_ptr); 1922 1923 read_list_entry = "1"b; 1924 go to RL_COMMON; 1925 1926 1927 1928 /* Construct the argument list and then produce a character string representation of the command invocation */ 1929 1930 write_list: 1931 entry (p_first_node, p_command_type, p_arg_count, p_pipe_control_ptr); 1932 1933 read_list_entry = "0"b; 1934 1935 1936 RL_COMMON: 1937 count, current_arg_len, arg_space, extension_size = 0; 1938 space_ptr = null (); 1939 start_arg = "1"b; /* need to get space for arg */ 1940 arg_ptr = null (); /* just to catch programming errors */ 1941 1942 p = p_first_node; 1943 1944 do while (p ^= null ()); /* to end of list */ 1945 1946 if p -> node.type = ATOM then do; /* atom */ 1947 atom_ptr = p -> atom.string_ptr; 1948 atom_len = p -> atom.string_len; 1949 if start_arg & p -> atom.space then do; 1950 /* single command line token as arg */ 1951 arg_len (count) = atom_len; 1952 if count = 0 then 1953 command_name_ptr = atom_ptr; 1954 else arg_list.arg_ptr (count) = atom_ptr; 1955 current_arg_len = 0; 1956 count = count + 1; 1957 start_arg = "1"b; 1958 end; 1959 else do; 1960 call non_simple_arg (); 1961 if p -> atom.space then call end_arg (); 1962 end; 1963 p = p -> atom.next; 1964 end; 1965 1966 else do; /* iteration set */ 1967 rethreaded = "0"b; 1968 iter_level = 1; 1969 pp = p; /* go inside; set parent pointer */ 1970 1971 do p = p -> node.next repeat (p -> node.next) while (iter_level > 0); 1972 /* to end of outer iteration set */ 1973 1974 if p -> node.type = BEGIN_ITERATION then do; 1975 /* nested iteration */ 1976 if ^start_arg & rethreaded then rethreaded = "0"b; 1977 /* if connected iteration must rethread each iteration set */ 1978 iter_level = iter_level + 1; 1979 pp = p; 1980 if p -> iter_begin.next = p -> iter_begin.end then do; 1981 /* null iteration set */ 1982 current_arg_len = 0;/* have to begin arg over */ 1983 start_arg = "1"b; 1984 null_iter = "1"b; 1985 rethreaded = "0"b; 1986 go to skip_iter; 1987 end; 1988 end; 1989 else do; 1990 null_iter = "0"b; 1991 atom_ptr = p -> atom.string_ptr; 1992 atom_len = p -> atom.string_len; 1993 if start_arg & (p -> atom.space) & (pp -> iter_begin.end -> iter_end.space) 1994 & (iter_level = 1) then do; 1995 /* single command line token as arg */ 1996 /* depends upon whether right paren is followed by space */ 1997 /* only simple tokens in the outermost iteration set 1998* are not copied, to detect simple tokens when additional 1999* levels of nesting are involved is quite complicated and not 2000* deemed worth the effort for a very unlikely construct */ 2001 arg_len (count) = atom_len; 2002 if count = 0 then 2003 command_name_ptr = atom_ptr; 2004 else arg_list.arg_ptr (count) = atom_ptr; 2005 current_arg_len = 0; 2006 count = count + 1; 2007 start_arg = "1"b; 2008 end; 2009 else call non_simple_arg (); 2010 2011 if p -> atom.space then do; 2012 /* this atom ends an element of the iteration set */ 2013 if ^rethreaded then do; 2014 /* rethread next iteration element */ 2015 rethreaded = "1"b; 2016 /* assume we can do the rethreading */ 2017 if p -> atom.next -> node.type ^= END_ITERATION then 2018 pp -> iter_begin.next = p -> atom.next; 2019 /* if not last element of iteration set */ 2020 else if p -> atom.next -> iter_end.space then do; 2021 /* if last element of iteration set followed by space */ 2022 if iter_level = 1 then 2023 p -> atom.next -> iter_end.parent -> iter_begin.next = 2024 p -> atom.next; 2025 /* and top level */ 2026 else pp -> iter_begin.parent -> iter_begin.next = 2027 p -> atom.next -> iter_end.next; 2028 /* not top level, its done */ 2029 end; 2030 else rethreaded = "0"b; 2031 /* last element of iteration set not followed by space */ 2032 /* have to perform rethreading later */ 2033 end; 2034 2035 /* Skip to the end of this iteration set */ 2036 2037 skip_iter: 2038 saved_level = iter_level; 2039 p = pp -> iter_begin.end; 2040 /* move p to ) node */ 2041 2042 do while (iter_level > 0); 2043 if p -> node.type = BEGIN_ITERATION then do; 2044 /* left paren, jump to right paren which matches */ 2045 iter_level = iter_level + 1; 2046 pp = p; 2047 p = pp -> iter_begin.end; 2048 end; 2049 2050 /* Node must be either an atom or iter_end node */ 2051 if p -> node.type = END_ITERATION then do; 2052 iter_level = p -> iter_end.level; 2053 pp = p -> iter_end.parent -> iter_begin.parent; 2054 if iter_level = 0 then 2055 if p -> iter_end.space then 2056 if ^start_arg then 2057 call end_arg (); 2058 else ; 2059 /* no arg needs to be ended */ 2060 else ; 2061 /* reached outermost ), but it is connected to something */ 2062 else do; /* reached end of nested iteration */ 2063 if iter_level >= saved_level then ; 2064 /* some other iter set */ 2065 else if p -> iter_end.space then 2066 if null_iter then 2067 go to more_arg; 2068 /* finished with stuff connected to null iteration */ 2069 else ; 2070 /* nested iter, nothing connected to it */ 2071 else if null_iter then ; 2072 /* end of iter connected to null iter */ 2073 else go to more_arg; 2074 /* nested iter with something attached */ 2075 p = p -> node.next; 2076 end; 2077 end; 2078 else if null_iter & p -> atom.space then go to more_arg; 2079 /* reached last node connected to null iteration */ 2080 else p = p -> node.next; 2081 /* an atom node */ 2082 end; 2083 end; 2084 end; 2085 more_arg: 2086 end; /* p can be null at this point */ 2087 end; 2088 end; 2089 2090 if read_list_entry then do; 2091 2092 /* All arguments have been completed and the command or active function should be called */ 2093 2094 if p_command_type = active_function then 2095 twice_no_of_args, twice_no_of_descriptors = 2 * count; 2096 else twice_no_of_args, twice_no_of_descriptors = 2 * (count - 1); 2097 2098 do argument_idx = 1 to count - 1; 2099 descriptor_ptr (argument_idx) = addr (descriptor (argument_idx)); 2100 descriptor (argument_idx).bits = "5260"b3; 2101 descriptor (argument_idx).size = arg_len (argument_idx); 2102 end; /* unaligned nonvarying strings */ 2103 2104 if p_command_type = active_function then do; 2105 call setup_return_string (); /* prepare the return string */ 2106 arg_list.arg_ptr (p_arg_count) = addrel (addr (return_string), 1); 2107 descriptor_ptr (p_arg_count) = addr (descriptor (p_arg_count)); 2108 descriptor (p_arg_count).bits = "5320"b3; 2109 /* aligned, varying string */ 2110 descriptor (p_arg_count).size = return_len; 2111 end; 2112 2113 2114 /* save the name on the current argument list NOTE this is a new structure 2115**/ 2116 2117 arg_list.has_command_name = "1"b; 2118 arg_list.name.command_name_length = length (command_name); 2119 arg_list.name.command_name_ptr = command_name_ptr; 2120 command_entry_ptr = null; 2121 2122 if multics_cp then on condition (command_abort_) go to ABORT_EXECUTION; 2123 else if p_command_type = command then on condition (request_abort_) go to ABORT_EXECUTION; 2124 2125 2126 if p_command_type = active_function | p_pipe_control_ptr = null then do; 2127 /* regular command call */ 2128 2129 call process_command (command_entry_ptr, code); 2130 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 2131 end; 2132 else do; /* the pipe facility is invoked */ 2133 on condition (cleanup) call process_pipe_cleanup (p_pipe_control_ptr); 2134 2135 call process_pipe (p_pipe_control_ptr, command_name, code); 2136 if code ^= 0 then go to RETURN_FROM_CP; 2137 end; 2138 2139 end; 2140 2141 else do; 2142 2143 /* All arguments have been completed and the list is to be retruned as a character string */ 2144 2145 do argument_idx = 0 to count - 1; 2146 2147 if (argument_idx ^= count - 1) then 2148 suffix = " "; /* more to come */ 2149 else suffix = ""; 2150 2151 if argument_idx = 0 then 2152 object_ptr = command_name_ptr; 2153 else object_ptr = arg_list.arg_ptr (argument_idx); 2154 object_lth = arg_len (argument_idx); 2155 2156 if length (P_return_value) + object_lth + length (suffix) > maxlength (P_return_value) then 2157 code = error_table_$command_line_overflow; 2158 2159 P_return_value = P_return_value || object; 2160 /* two statements generates better code */ 2161 P_return_value = P_return_value || suffix; 2162 2163 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 2164 /* failure to fit */ 2165 end; 2166 end; 2167 ABORT_EXECUTION: 2168 return; 2169 2170 /* Internal to produce_argument_list: moves the atom_string into the current_arg, obtaining more space if necessary */ 2171 2172 non_simple_arg: 2173 procedure () /* options (quick) */; /* MUST BE A QUICK BLOCK */ 2174 2175 if current_arg_len + atom_len > arg_space then do; 2176 needed_space = 16 * max (4, divide (currentsize (atom_string) + 15, 16, 21, 0)); 2177 extension_size = extension_size + needed_space; 2178 if using_stack & (needed_space < 1024) & (extension_size < MAX_STACK_EXTENSION) then do; 2179 /* OK to continue extending the stack */ 2180 call cu_$grow_stack_frame (needed_space, stack_ptr, ignore_code); 2181 /* grow_stack_frame always returns zero code */ 2182 if space_ptr = null () then do; 2183 space_ptr = stack_ptr; 2184 arg_ptr = space_ptr; /* first call, must initialize arg_ptr */ 2185 end; 2186 arg_space = arg_space + 4 * needed_space; 2187 end; 2188 2189 else do; /* use space in a temporary segment */ 2190 using_stack = "0"b; 2191 space_ptr = select_scratch_segment (); 2192 arg_space = 4 * sys_info$max_seg_size; 2193 if ^start_arg then do; 2194 substr (space_ptr -> arg, 1, current_arg_len) = current_arg; 2195 arg_space = arg_space - current_arg_len; 2196 end; 2197 arg_ptr = space_ptr; /* have switched spaces */ 2198 end; 2199 end; 2200 2201 substr (arg, current_arg_len + 1, atom_len) = atom_string; 2202 current_arg_len = current_arg_len + atom_len; 2203 start_arg = "0"b; /* arg has been started */ 2204 arg_space = arg_space - atom_len; 2205 2206 end non_simple_arg; 2207 2208 /* Internal to produce_argument_list: complete construction of the current argument */ 2209 2210 end_arg: 2211 procedure (); 2212 2213 if count = 0 then 2214 command_name_ptr = arg_ptr; 2215 else arg_list.arg_ptr (count) = arg_ptr; 2216 arg_len (count) = current_arg_len; 2217 2218 arg_ptr = addr (substr (arg, current_arg_len + 1, 1)); 2219 /* get pointer to char after 2220* last char of this arg */ 2221 arg_space = arg_space - current_arg_len; 2222 2223 count = count + 1; 2224 start_arg = "1"b; 2225 current_arg_len = 0; 2226 2227 end end_arg; 2228 2229 2230 2231 /* Internal to produce_argument_list: Prepares the return string for an active function invocation */ 2232 2233 setup_return_string: 2234 procedure (); 2235 2236 if return_ptr = null () then do; /* first active function or last one used too much space */ 2237 return_ptr = select_scratch_segment (); 2238 return_len = 4 * (sys_info$max_seg_size - 1); 2239 end; 2240 2241 return_string = ""; 2242 2243 return; 2244 2245 end setup_return_string; 2246 2247 process_command: 2248 proc (command_entry_ptr, code); 2249 2250 dcl command_entry_ptr ptr, 2251 code fixed bin (35); 2252 2253 if multics_cp then do; /* executing Multics command line */ 2254 if lss_on then do; /* running Limited Service System */ 2255 call transform_command_ (command_name_ptr, arg_len (0), cp_data_$command_table_ptr, code); 2256 2257 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 2258 end; 2259 2260 if command_entry_ptr = null then do; 2261 if evaluate_string then /* be silent for cp_$af */ 2262 call find_command_$fc_no_message (command_name_ptr, arg_len (0), command_entry_ptr, 2263 code); 2264 2265 else call find_command_ (command_name_ptr, arg_len (0), command_entry_ptr, code); 2266 2267 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 2268 2269 end; 2270 2271 call cu_$gen_call (command_entry_ptr, addr (arg_list)); 2272 end; 2273 2274 else if new_subsystem_call /* executing a new-style subsystem request */ 2275 then do; 2276 call execute_request (P_subsystem_info_ptr, command_name, addr (arg_list), code); 2277 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 2278 end; 2279 2280 else do; /* executing an old-style subsystem request */ 2281 call old_execute_request (command_name, addr (arg_list), code); 2282 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 2283 end; 2284 return; 2285 2286 end process_command; 2287 2288 2289 /* Internal to produce_argument_list: determines whether the entry is an io 2290* attachment or command, then processes accordingly. */ 2291 2292 process_pipe: 2293 proc (p_pipe_control_ptr, command_name, code); 2294 2295 dcl p_pipe_control_ptr ptr parameter, /* (input) - ptr 2 pipe control info */ 2296 command_name char (*) parameter, /* (input) - name of the command */ 2297 code fixed bin (35) parameter; /* (output)- error status */ 2298 2299 dcl aligned_command_name char (32) aligned; 2300 dcl pipe_control_ptr ptr; 2301 dcl 1 pipe_control aligned like command_pipe_control based (pipe_control_ptr); 2302 dcl Satds_match bit (1) aligned; 2303 dcl Sdefault_curr_to_vfile bit (1) aligned; 2304 dcl attach_description char (1024) aligned; 2305 dcl command_entry_ptr ptr; 2306 dcl current_pipe aligned char (pipe_control.current_pipe_len) based (pipe_control.current_pipe_ptr); 2307 dcl next_pipe aligned char (pipe_control.next_pipe_len) based (pipe_control.next_pipe_ptr); 2308 dcl previous_pipe aligned char (pipe_control.previous_pipe_len) based (pipe_control.previous_pipe_ptr); 2309 dcl pipeout_file_path char (168) aligned; 2310 dcl sv_pipe_path char (58); 2311 2312 dcl FALSE bit (1) aligned internal static options (constant) init ("0"b), 2313 TRUE bit (1) aligned internal static options (constant) init ("1"b), 2314 INPUT bit (1) aligned internal static options (constant) init ("1"b), 2315 OUTPUT bit (1) aligned internal static options (constant) init ("0"b); 2316 2317 dcl pipe_$initiate entry (ptr), 2318 pipe_$copy entry (ptr, ptr, fixed bin (35)), 2319 pipe_$attach_pipe entry (char (*) aligned, bit (1) aligned, bit (1) aligned, ptr, fixed bin (35)), 2320 pipe_$open_pipe entry (ptr, bit (1) aligned, fixed bin (35)), 2321 pipe_$get_return_string_nnl entry (ptr, ptr, fixed bin (21), fixed bin (35)), 2322 pipe_$get_return_string entry (ptr, ptr, fixed bin (21), fixed bin (35)); 2323 2324 pipe_control_ptr = p_pipe_control_ptr; 2325 command_entry_ptr = null; 2326 Satds_match = FALSE; 2327 2328 if pipe_control.current_pipe_len = 0 then return; 2329 2330 if substr (command_name, 1, length (VERTICAL_BAR)) = VERTICAL_BAR then 2331 code = error_table_$bad_file_name; 2332 else call check_star_name_ (command_name, 2333 CHECK_STAR_PROCESS_PATH | 2334 CHECK_STAR_REJECT_WILD | 2335 CHECK_STAR_IGNORE_ENTRYPOINT, (0), code); 2336 2337 if code ^= 0 then do; 2338 error_message = command_name; 2339 return; 2340 end; 2341 2342 if pipe_control.Sevaluate_pipe then do; 2343 if pipe_control.Sbuild_return_string then return_ptr = null; 2344 call setup_return_string (); 2345 end; 2346 2347 /* only the command name needs to be checked to see if it is an atd */ 2348 2349 aligned_command_name = command_name; 2350 if element_is_an_atd (aligned_command_name, command_entry_ptr, Sdefault_curr_to_vfile, code) then do; 2351 2352 /* This call builds a complete attach description for the current section of 2353* the command line. The usage of the value next_pipe is discussed in 2354* make_list label PROCESS_CHARACTER (2) above. Because the value may not be 2355* complete, it is necessary to build the attachment from the argument list. */ 2356 2357 attach_description = make_command_line_attach (); 2358 call process_attach_description (return_ptr, return_len, code); 2359 end; 2360 else call process_pipe_command (command_entry_ptr, command_name, return_ptr, return_len, code); 2361 2362 return; 2363 2364 /* Internal to process_pipe: processes the current section of the command 2365* line if it is an attach description. */ 2366 2367 process_attach_description: 2368 proc (af_return_str_ptr, af_return_str_len, code); 2369 2370 dcl af_return_str_ptr ptr, /* (input/output) ptr to return str */ 2371 af_return_str_len fixed bin (21), /* (input/output) len of return str */ 2372 code fixed bin (35); /* (output) error status */ 2373 2374 code = 0; 2375 2376 /* If the element before the ";|" is an attach description, copy its 2377* contents to this attach description. */ 2378 2379 if pipe_control.previous_pipe_ptr ^= null then do; 2380 call copy_thru_pipe (previous_pipe, attach_description, code); 2381 if code ^= 0 then return; 2382 2383 /* if the previous attach is the same as this one, the data was placed in a 2384* temp file. Now copy the data from the temp file to the original */ 2385 2386 if Satds_match then do; 2387 call copy_thru_pipe (pipe_control.pipe_output_path, attach_description, code); 2388 if code ^= 0 then return; 2389 end; 2390 end; 2391 2392 /* next_pipe_ptr is null when the attach description is the last element in an 2393* input command line. */ 2394 if pipe_control.next_pipe_ptr = null then return; 2395 2396 /* build the active function return string when this attach description 2397* preceeds the string ";|]" or ";||]". */ 2398 2399 if pipe_control.Sbuild_return_string then do; 2400 if (pipe_control.niters < pipe_control.Niters) then 2401 ; 2402 else call build_pipe_return_string (attach_description, af_return_str_ptr, 2403 af_return_str_len, code); 2404 end; 2405 2406 /* If this attach description is the last thing in the line except ";|", 2407* use a default output file of "[wd]>pipeout". */ 2408 2409 else if next_pipe = "" then do; 2410 pipeout_file_path = rtrim (get_wdir_ ()) || ">pipeout"; 2411 call copy_thru_pipe (attach_description, pipeout_file_path, code); 2412 end; 2413 2414 2415 /* if this element is an attach description that does not use any active 2416* functions, quotes or parens, do nothing. Otherwise, copy its contents to 2417* the next element in the line. This is because when the next pipe element 2418* is processed, this value will be the previous pipe value and because it 2419* has special characrters in it, the next element will expect a temp file. */ 2420 2421 else if element_is_an_atd (current_pipe, null, Sdefault_curr_to_vfile, ignore_code) then ; 2422 2423 else do; 2424 2425 call copy_thru_pipe (attach_description, ltrim (next_pipe), code); 2426 if code ^= 0 then return; 2427 2428 if (pipe_control.niters < pipe_control.Niters) then 2429 ; 2430 else do; 2431 2432 /* switch the pathnames of the input and output pipe work files so that 2433* the current output file will be used as input to the next element in 2434* the command line. */ 2435 sv_pipe_path = pipe_control.pipe_input_path; 2436 pipe_control.pipe_input_path = pipe_control.pipe_output_path; 2437 pipe_control.pipe_output_path = sv_pipe_path; 2438 end; 2439 end; 2440 2441 return; 2442 end process_attach_description; 2443 2444 /* Internal to process_pipe: processes the current section of the command 2445* line if it is a command. */ 2446 2447 process_pipe_command: 2448 proc (command_entry_ptr, command_name, af_return_str_ptr, af_return_str_len, code); 2449 2450 dcl command_entry_ptr ptr, /* (input) - ptr to entry to execute */ 2451 command_name char (*), /* (input) - name of command */ 2452 af_return_str_ptr ptr, /* (input/output) ptr to return str */ 2453 af_return_str_len fixed bin (21), /* (input/output) len of return str */ 2454 code fixed bin (35); /* (output)- error status */ 2455 2456 code = 0; 2457 2458 call attach_input (previous_pipe, pipe_control.input_ptr, code); 2459 if code ^= 0 then return; 2460 2461 if pipe_control.next_pipe_ptr ^= null then do; 2462 if next_pipe = "" then do; 2463 pipeout_file_path = rtrim (get_wdir_ ()) || ">pipeout"; 2464 call attach_output (previous_pipe, pipeout_file_path, 2465 pipe_control.output_ptr, Satds_match, code); 2466 end; 2467 else call attach_output (previous_pipe, next_pipe, pipe_control.output_ptr, Satds_match, 2468 code); 2469 if code ^= 0 then return; 2470 end; 2471 2472 call process_command (command_entry_ptr, code); 2473 call process_pipe_cleanup (p_pipe_control_ptr); 2474 2475 if (pipe_control.niters < pipe_control.Niters) then 2476 ; 2477 else do; 2478 if pipe_control.Sbuild_return_string then 2479 call build_pipe_return_string (pipe_control.pipe_output_path, af_return_str_ptr, 2480 af_return_str_len, code); 2481 2482 sv_pipe_path = pipe_control.pipe_input_path; 2483 pipe_control.pipe_input_path = pipe_control.pipe_output_path; 2484 pipe_control.pipe_output_path = sv_pipe_path; 2485 end; 2486 2487 return; 2488 end process_pipe_command; 2489 2490 /* Internal to process_pipe: compares two attach descriptions. */ 2491 2492 atds_match: 2493 proc (attach_description_1, attach_description_2, Sdefault2) returns (bit (1) aligned); 2494 2495 dcl attach_description_1 char (*) aligned, /* (input) attach descrip. 1. */ 2496 attach_description_2 char (*) aligned, /* (input) attach descrip. 2. */ 2497 Sdefault2 bit (1) aligned; /* (input) atd2 is a vfile_ */ 2498 2499 dcl Sdefault1 bit (1) aligned, 2500 full_path1 char (1024), 2501 full_path2 char (1024), 2502 match_word1 char (32) varying, 2503 match_word2 char (32) varying, 2504 word_cnt1 fixed bin, 2505 word_cnt2 fixed bin, 2506 uid1 bit (36) aligned, 2507 uid2 bit (36) aligned; 2508 2509 2510 word_cnt1 = 1; 2511 word_cnt2 = 1; 2512 2513 /* if one of the attach descriptions is blank, they do not match. */ 2514 2515 if attach_description_1 = SPACE | attach_description_2 = SPACE then return (FALSE); 2516 2517 /* If the first attach is defaulted to a vfile, set the match word to 2518* "vfile_". Otherwise, set the match word to the first word in the 2519* attach description. */ 2520 2521 if element_is_an_atd (attach_description_1, null, Sdefault1, ignore_code) then 2522 match_word1 = "vfile_"; 2523 else do; 2524 match_word1 = get_word (attach_description_1, word_cnt1); 2525 word_cnt1 = word_cnt1 + 1; 2526 end; 2527 2528 /* If the secord attach is defaulted to a vfile, set the match word to 2529* "vfile_". Otherwise, set the match word to the first word in the 2530* attach description. */ 2531 2532 if Sdefault2 then 2533 match_word2 = "vfile_"; 2534 else do; 2535 match_word2 = get_word (attach_description_2, word_cnt2); 2536 word_cnt2 = word_cnt2 + 1; 2537 end; 2538 2539 /* Here, the first words will always be the name of the I/O module used. 2540* If they do not match, the attach descriptions do not match. */ 2541 2542 if match_word1 ^= match_word2 then return (FALSE); 2543 2544 /* If using vfile_, get the uid of the file begin attached to. The uid 2545* is the only accurate means of determining if the two paths point to 2546* the same file. */ 2547 2548 if match_word1 = "vfile_" then do; 2549 match_word1 = get_word (attach_description_1, word_cnt1); 2550 match_word2 = get_word (attach_description_2, word_cnt2); 2551 2552 call absolute_pathname_ ((match_word1), full_path1, ignore_code); 2553 call hcs_$get_uid_file (full_path1, "", uid1, code); 2554 if code ^= 0 then do; 2555 code = 0; 2556 uid1 = TRUE; 2557 end; 2558 2559 call absolute_pathname_ ((match_word2), full_path2, ignore_code); 2560 call hcs_$get_uid_file (full_path2, "", uid2, code); 2561 if code ^= 0 then do; 2562 code = 0; 2563 uid2 = FALSE; 2564 end; 2565 2566 if uid1 = uid2 then return (TRUE); 2567 return (FALSE); 2568 end; 2569 2570 /* Here, all I/O modules that are not vfile_ are checked. If the first 2571* arguments to the I/O modules are the same, then return true. */ 2572 2573 match_word1 = get_word (attach_description_1, word_cnt1); 2574 match_word2 = get_word (attach_description_2, word_cnt2); 2575 2576 if match_word1 = match_word2 then return (TRUE); 2577 2578 /* Cases that are not handled by this routine include: 2579* 2580* 1) mtape_ attach descriptions where the volume name is placed into the 2581* default arguments value within a value segment. In this case, 2582* the attach description is incomplete. Omitting the positional 2583* argument is a violation of the standard for I/O modules and mtape_ 2584* should be changed to conform. */ 2585 2586 return (FALSE); 2587 2588 get_word: 2589 proc (word_list, word_to_return) returns (char (32) varying); 2590 2591 dcl word_list char (*) aligned; 2592 dcl word_to_return fixed bin; 2593 dcl work_list char (1024) varying; 2594 dcl word char (32) varying; 2595 dcl i fixed bin; 2596 2597 /* If the attach description has a target attach, use only the target. */ 2598 2599 work_list = ltrim (after (word_list, "-target ")); 2600 if work_list = "" then work_list = ltrim (word_list); 2601 2602 do i = 1 to word_to_return; 2603 word = before (work_list, SPACE); 2604 work_list = after (work_list, SPACE); 2605 work_list = ltrim (work_list); 2606 end; 2607 2608 return (word); 2609 end get_word; 2610 2611 end atds_match; 2612 2613 /* Internal to process_pipe: attaches and opens user_input for use by 2614* the caller using the input attachment. */ 2615 2616 attach_input: 2617 proc (input_atd, input_ptr, code); 2618 2619 dcl input_atd char (*) aligned; /* (input) - attach descipt/command */ 2620 dcl input_ptr ptr; /* (input/output) - ptr to input pipe info */ 2621 dcl code fixed bin (35); /* (output) - error status */ 2622 2623 dcl Sdefault_to_vfile bit (1) aligned; 2624 2625 /* Attach and open the input based on type */ 2626 2627 code = 0; 2628 input_ptr = null; 2629 2630 if input_atd = "" then return; 2631 2632 input_atd = ltrim (input_atd); 2633 2634 /* If the input attachment is an attach description, attach and open it. 2635* Otherwise, attach and open the pipe input file. If there is no pipe input, 2636* there is an error. */ 2637 2638 if element_is_an_atd (input_atd, null, Sdefault_to_vfile, ignore_code) then 2639 call pipe_$attach_pipe (input_atd, Sdefault_to_vfile, FALSE, input_ptr, code); 2640 2641 else do; /* previous entry is a command */ 2642 if pipe_control.pipe_input_path = "" then do; 2643 code = error_table_$no_file; 2644 return; 2645 end; 2646 2647 else call pipe_$attach_pipe (pipe_control.pipe_input_path, TRUE, FALSE, input_ptr, code); 2648 end; 2649 2650 2651 if code ^= 0 then do; 2652 error_message = "While attaching " || rtrim (input_atd) || "."; 2653 return; 2654 end; 2655 2656 call pipe_$open_pipe (input_ptr, INPUT, code); 2657 if code ^= 0 then do; 2658 if code = error_table_$noentry then 2659 error_message = "Unknown command or file " || input_atd || "."; 2660 else error_message = "While opening " || input_atd || " for input."; 2661 call process_pipe_cleanup (p_pipe_control_ptr); 2662 return; 2663 end; 2664 return; 2665 end attach_input; 2666 2667 /* Internal to process_pipe: attaches and opens user_output for use by 2668* the caller using the output attachment. */ 2669 2670 attach_output: 2671 proc (input_atd, output_atd, output_ptr, Satds_match, code); 2672 2673 dcl input_atd char (*) aligned; /* (input) - input attachment */ 2674 dcl output_atd char (*) aligned; /* (input) - output to be attached */ 2675 dcl output_ptr ptr; /* (input/output) - ptr to output pipe info */ 2676 dcl Satds_match bit (1) aligned; /* (output) - ON = input matchs output */ 2677 dcl code fixed bin (35); /* (output) - error status */ 2678 2679 dcl Sdefault_to_vfile bit (1) aligned; 2680 2681 code = 0; 2682 output_ptr = null; 2683 2684 input_atd = ltrim (input_atd); 2685 output_atd = ltrim (output_atd); 2686 2687 /* If the output attachment is an attach description and does not conflict 2688* with the input attachment, attach and open it. Otherwise, attach and 2689* open the pipe output file. */ 2690 2691 if element_is_an_atd (output_atd, null, Sdefault_to_vfile, ignore_code) then do; 2692 if atds_match (input_atd, output_atd, Sdefault_to_vfile) then 2693 Satds_match = "1"b; 2694 else do; 2695 call pipe_$attach_pipe (output_atd, Sdefault_to_vfile, TRUE, output_ptr, code); 2696 Satds_match = "0"b; 2697 end; 2698 end; 2699 2700 if output_ptr = null & code = 0 then do; 2701 if pipe_control.pipe_output_path = "" then 2702 call pipe_$initiate (addr (pipe_control.pipe_output_path)); 2703 2704 call pipe_$attach_pipe (pipe_control.pipe_output_path, TRUE, TRUE, output_ptr, code); 2705 end; 2706 2707 if code ^= 0 then do; 2708 error_message = "While attaching " || output_atd || "."; 2709 return; 2710 end; 2711 2712 call pipe_$open_pipe (output_ptr, OUTPUT, code); 2713 if code ^= 0 then do; 2714 error_message = "While opening " || output_atd || " for output."; 2715 call process_pipe_cleanup (p_pipe_control_ptr); 2716 return; 2717 end; 2718 2719 return; 2720 end attach_output; 2721 2722 /* Internal to process_pipe: adds the information from the file given in 2723* the input_atd to the active function return string. */ 2724 2725 build_pipe_return_string: 2726 proc (input_atd, pipe_return_string_ptr, pipe_return_string_len, code); 2727 2728 dcl input_atd char (*) aligned, /* (input) - return string file */ 2729 pipe_return_string_ptr ptr, /* (input) - ptr to return string */ 2730 pipe_return_string_len fixed bin (21), /* (input) - len of return string */ 2731 code fixed bin (35); /* (output) - error status */ 2732 2733 call attach_input (input_atd, pipe_control.input_ptr, code); 2734 if code ^= 0 then return; 2735 2736 if pipe_control.Sinclude_NL_in_af_ret_str then 2737 call pipe_$get_return_string (pipe_control.input_ptr, pipe_return_string_ptr, 2738 pipe_return_string_len, code); 2739 else call pipe_$get_return_string_nnl (pipe_control.input_ptr, pipe_return_string_ptr, 2740 pipe_return_string_len, code); 2741 2742 call process_pipe_cleanup (p_pipe_control_ptr); 2743 return; 2744 end build_pipe_return_string; 2745 2746 /* Internal to process_pipe: copies the information from the file given in 2747* the input atd to the file given in the output atd. */ 2748 2749 copy_thru_pipe: 2750 proc (copy_input_atd, copy_output_atd, code); 2751 2752 dcl copy_input_atd aligned char (*), /* (input) - input attach descript. */ 2753 copy_output_atd aligned char (*), /* (input) - output attach descript. */ 2754 code fixed bin (35); /* (output)- error status */ 2755 2756 call attach_input (copy_input_atd, pipe_control.input_ptr, code); 2757 2758 if code = error_table_$no_file then do; 2759 code = 0; 2760 return; 2761 end; 2762 2763 if code = 0 then do; 2764 call attach_output (copy_input_atd, copy_output_atd, pipe_control.output_ptr, Satds_match, 2765 code); 2766 if code = 0 then do; 2767 2768 call pipe_$copy (pipe_control.input_ptr, pipe_control.output_ptr, code); 2769 2770 if code ^= 0 then 2771 error_message = 2772 "While copying data from " || ltrim (copy_input_atd) || " to " 2773 || ltrim (copy_output_atd) || "."; 2774 end; 2775 end; 2776 2777 call process_pipe_cleanup (p_pipe_control_ptr); 2778 2779 return; 2780 end copy_thru_pipe; 2781 2782 /* Internal to process_pipe: determines if the input pipe element is a valid 2783* attach description or command. */ 2784 2785 element_is_an_atd: 2786 proc (pipe_element, p_command_entry_ptr, Sdefault_to_vfile, code) returns (bit (1) aligned); 2787 2788 dcl pipe_element char (*) aligned, /* (input) - element who type is to be determined */ 2789 p_command_entry_ptr ptr, /* (output)- if a command points to its entrypoint */ 2790 Sdefault_to_vfile bit (1) aligned, /* (output)- if an atd on = file name use vfile_ */ 2791 code fixed bin (35); /* (output)- error status */ 2792 2793 dcl dirname char (168), 2794 entryname char (32), 2795 io_module_attach_entry char (200); 2796 2797 dcl command_entry_ptr ptr; 2798 2799 dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); 2800 2801 Sdefault_to_vfile = FALSE; 2802 p_command_entry_ptr = null; 2803 2804 if ^multics_cp then return (FALSE); 2805 2806 pipe_element = ltrim (pipe_element); 2807 2808 if search (pipe_element, NON_SIMPLE_BREAKS) > 0 then return (FALSE); 2809 /* If entry already is an entry, it */ 2810 /* is not an atd. */ 2811 if search (pipe_element, "$") > 0 then return (FALSE); 2812 call find_command_$fc_no_message (addr (before (pipe_element, SPACE)), 2813 length (before (pipe_element, SPACE)), command_entry_ptr, code); 2814 if code = 0 then do; 2815 p_command_entry_ptr = command_entry_ptr; 2816 return (FALSE); 2817 end; 2818 2819 call expand_pathname_ (before (pipe_element, SPACE), dirname, entryname, code); 2820 2821 /* set the io module name to the entryname portion of the pipe element. If 2822* there is a pathname in the line, it is possible that a personal version 2823* of an i/o module is being used. */ 2824 2825 io_module_attach_entry = 2826 before (ltrim (pipe_element), rtrim (entryname)) || rtrim (entryname) || "$" 2827 || rtrim (entryname) || "attach"; 2828 2829 call find_command_$fc_no_message (addr (io_module_attach_entry), length (io_module_attach_entry), 2830 command_entry_ptr, code); 2831 2832 if code = 0 then return (TRUE); 2833 2834 2835 Sdefault_to_vfile = TRUE; 2836 code = 0; 2837 return (TRUE); 2838 2839 end element_is_an_atd; 2840 2841 /* Internal to process_pipe: builds and returns an attach description and 2842* arguments using the argument list. */ 2843 2844 make_command_line_attach: 2845 proc () returns (char (1024) varying); 2846 2847 dcl command_line_attach char (1024) varying; 2848 2849 command_line_attach = ""; 2850 do argument_idx = 0 to count - 1; 2851 2852 if (argument_idx ^= count - 1) then 2853 suffix = " "; /* more to come */ 2854 else suffix = ""; 2855 2856 if argument_idx = 0 then 2857 object_ptr = command_name_ptr; 2858 else object_ptr = arg_list.arg_ptr (argument_idx); 2859 object_lth = arg_len (argument_idx); 2860 2861 if length (command_line_attach) + object_lth + length (suffix) 2862 > maxlength (command_line_attach) then 2863 code = error_table_$command_line_overflow; 2864 2865 command_line_attach = command_line_attach || object; 2866 /* two statements generates better code */ 2867 command_line_attach = command_line_attach || suffix; 2868 2869 if code ^= 0 then go to SILENTLY_RETURN_FROM_CP; 2870 /* failure to fit */ 2871 end; 2872 return (command_line_attach); 2873 end make_command_line_attach; 2874 2875 end process_pipe; 2876 2877 2878 2879 /* Internal to process_pipe: closes and detaches user_input and user_output. */ 2880 2881 process_pipe_cleanup: 2882 proc (p_pipe_control_ptr); 2883 2884 dcl p_pipe_control_ptr ptr; /* (input) - ptr 2 pipe control info */ 2885 2886 dcl 1 pipe_control aligned like command_pipe_control based (p_pipe_control_ptr); 2887 dcl pipe_$close_pipe entry (ptr, bit (1) aligned, fixed bin (35)), 2888 pipe_$detach_pipe entry (ptr, fixed bin (35)); 2889 2890 if pipe_control.input_ptr ^= null then do; 2891 call pipe_$close_pipe (pipe_control.input_ptr, pipe_control.niters = pipe_control.Niters, 2892 ignore_code); 2893 call pipe_$detach_pipe (pipe_control.input_ptr, ignore_code); 2894 end; 2895 2896 if pipe_control.output_ptr ^= null then do; 2897 call pipe_$close_pipe (pipe_control.output_ptr, "0"b, ignore_code); 2898 call pipe_$detach_pipe (pipe_control.output_ptr, ignore_code); 2899 end; 2900 return; 2901 end process_pipe_cleanup; 2902 2903 end produce_argument_list; 2904 2905 /* Initialize scratch segment management */ 2906 2907 initialize_scratch_segments: 2908 procedure (p_first_call); 2909 2910 dcl p_first_call bit (1) aligned parameter; 2911 2912 if p_first_call then do; /* only do the following stuff once per invocation ... */ 2913 permanent_scratch_segment_list_ptr = addr (cp_data_$permanent_scratch_segment_list); 2914 cp_data_$scratch_lock_id = cp_data_$scratch_lock_id + 1; 2915 scratch_lock_id = bit (fixed (cp_data_$scratch_lock_id, 36, 0), 36); 2916 end; 2917 2918 temporary_scratch_segment_list_ptr = addr (local_temporary_scratch_segment_list); 2919 temporary_scratch_segment_list.n_allocated = 2920 dimension (local_temporary_scratch_segment_list.segment_ptrs, 1); 2921 temporary_scratch_segment_list.n_used = 0; /* not using any temporary scratch segments just yet */ 2922 temporary_scratch_segment_list.segment_ptrs (*) = null (); 2923 2924 return; 2925 2926 end initialize_scratch_segments; 2927 2928 2929 2930 /* Select the next available scratch segment giving preference to the "permanent" segments */ 2931 2932 select_scratch_segment: 2933 procedure () returns (pointer); 2934 2935 dcl 1 permanent_scratch_segment like permanent_scratch_segment_list.scratch_segments aligned 2936 based (permanent_scratch_segment_ptr); 2937 dcl (permanent_scratch_segment_ptr, old_temporary_scratch_segment_list_ptr, new_temporary_scratch_segment_list_ptr, 2938 segment_ptr) pointer; 2939 dcl idx fixed binary; 2940 2941 segment_ptr = null (); /* haven't found one yet */ 2942 2943 do idx = 1 to permanent_scratch_segment_list.n_scratch_segments while (segment_ptr = null ()); 2944 permanent_scratch_segment_ptr = addr (permanent_scratch_segment_list.scratch_segments (idx)); 2945 if stacq (permanent_scratch_segment.lock, scratch_lock_id, (36)"0"b) then do; 2946 if permanent_scratch_segment.segment_ptr = null () then do; 2947 call get_temp_segment_ (COMMAND_PROCESSOR_, permanent_scratch_segment.segment_ptr, code); 2948 if code ^= 0 then go to RETURN_FROM_CP; 2949 end; 2950 permanent_scratch_segment.usage_count = permanent_scratch_segment.usage_count + 1; 2951 segment_ptr = permanent_scratch_segment.segment_ptr; 2952 end; 2953 end; 2954 2955 if segment_ptr = null () then do; /* no permanent segments available */ 2956 if temporary_scratch_segment_list.n_used = temporary_scratch_segment_list.n_allocated then do; 2957 temporary_scratch_segment_list_n_allocated = 2 * temporary_scratch_segment_list.n_allocated; 2958 old_temporary_scratch_segment_list_ptr = temporary_scratch_segment_list_ptr; 2959 allocate temporary_scratch_segment_list in (system_area) 2960 set (new_temporary_scratch_segment_list_ptr); 2961 new_temporary_scratch_segment_list_ptr -> temporary_scratch_segment_list.n_used = 2962 old_temporary_scratch_segment_list_ptr -> temporary_scratch_segment_list.n_used; 2963 new_temporary_scratch_segment_list_ptr -> temporary_scratch_segment_list.segment_ptrs (*) = 2964 null (); 2965 do idx = 1 to old_temporary_scratch_segment_list_ptr -> temporary_scratch_segment_list.n_used; 2966 new_temporary_scratch_segment_list_ptr 2967 -> temporary_scratch_segment_list.segment_ptrs (idx) = 2968 old_temporary_scratch_segment_list_ptr 2969 -> temporary_scratch_segment_list.segment_ptrs (idx); 2970 end; 2971 temporary_scratch_segment_list_ptr = new_temporary_scratch_segment_list_ptr; 2972 if old_temporary_scratch_segment_list_ptr ^= addr (local_temporary_scratch_segment_list) then 2973 free old_temporary_scratch_segment_list_ptr 2974 -> temporary_scratch_segment_list in (system_area); 2975 end; 2976 temporary_scratch_segment_list.n_used, idx = temporary_scratch_segment_list.n_used + 1; 2977 call get_temp_segment_ (COMMAND_PROCESSOR_, temporary_scratch_segment_list.segment_ptrs (idx), code); 2978 if code ^= 0 then go to RETURN_FROM_CP; 2979 segment_ptr = temporary_scratch_segment_list.segment_ptrs (idx); 2980 end; 2981 2982 return (segment_ptr); 2983 2984 end select_scratch_segment; 2985 2986 2987 2988 /* Release any temporary scratch segments and mark all "permanent" segments selected by this invocation as available */ 2989 2990 release_scratch_segments: 2991 procedure (p_last_call); 2992 2993 dcl p_last_call bit (1) aligned parameter; 2994 2995 dcl 1 permanent_scratch_segment like permanent_scratch_segment_list.scratch_segments aligned 2996 based (permanent_scratch_segment_ptr); 2997 dcl permanent_scratch_segment_ptr pointer; 2998 dcl idx fixed binary; 2999 3000 do idx = 1 to permanent_scratch_segment_list.n_scratch_segments; 3001 permanent_scratch_segment_ptr = addr (permanent_scratch_segment_list.scratch_segments (idx)); 3002 if permanent_scratch_segment.lock = scratch_lock_id then do; 3003 if mod (permanent_scratch_segment.usage_count, cp_data_$scratch_release_factor) = 0 then do; 3004 call release_temp_segment_ (COMMAND_PROCESSOR_, permanent_scratch_segment.segment_ptr, 3005 ignore_code); 3006 permanent_scratch_segment.usage_count = 0; 3007 end; 3008 if stacq (permanent_scratch_segment.lock, (36)"0"b, scratch_lock_id) then ; 3009 end; /* mark it as available */ 3010 end; 3011 3012 if temporary_scratch_segment_list_ptr ^= null () then 3013 if temporary_scratch_segment_list.n_used > 0 then do; 3014 call release_temp_segments_ (COMMAND_PROCESSOR_, temporary_scratch_segment_list.segment_ptrs (*), 3015 ignore_code); 3016 temporary_scratch_segment_list.n_used = 0; 3017 if temporary_scratch_segment_list_ptr ^= addr (local_temporary_scratch_segment_list) then do; 3018 free temporary_scratch_segment_list in (system_area); 3019 temporary_scratch_segment_list_ptr = null (); 3020 end; 3021 end; 3022 3023 if ^p_last_call then /* setup for the next top-level command/request */ 3024 call initialize_scratch_segments ("0"b); 3025 3026 return; 3027 3028 end release_scratch_segments; 3029 3030 /* Free all allocated node_blocks */ 3031 3032 free_nodes: 3033 procedure (p_last_call); 3034 3035 dcl p_last_call bit (1) aligned parameter; 3036 3037 last_block_ptr = addr (stack_space) -> node_block.next; 3038 if last_block_ptr ^= null () then do; 3039 do block_ptr = last_block_ptr -> node_block.next repeat (block_ptr -> node_block.next) 3040 while (block_ptr ^= null ()); 3041 free last_block_ptr -> node_block in (system_area); 3042 last_block_ptr = block_ptr; 3043 end; 3044 free last_block_ptr -> node_block in (system_area); 3045 end; 3046 3047 if p_last_call then /* prevent attempts to free when nothing to free */ 3048 addr (stack_space) -> node_block.next = null (); 3049 else do; /* still have work to do */ 3050 block_ptr = addr (stack_space); 3051 unspec (node_block) = "0"b; 3052 node_block.next = null (); 3053 node_index = 0; 3054 addr (dummy_node) -> node.next = null (); 3055 end; 3056 3057 end free_nodes; 3058 3059 end complex_command_processor; 3060 3061 /* Validates a subsystem's request language definition and builds the necessary TCT tables used in make_list above */ 3062 3063 validate_cp_subsys_info: 3064 entry (P_cp_subsys_info_ptr, P_code); 3065 3066 call validate_request_language (P_cp_subsys_info_ptr, P_code); 3067 /* use an internal procedure to avoid wasting stack space */ 3068 return; 3069 3070 3071 /* Internal procedure that does the actual work */ 3072 3073 validate_request_language: 3074 procedure (p_cp_subsys_info_ptr, p_code) options (non_quick); 3075 3076 dcl p_cp_subsys_info_ptr pointer parameter; 3077 dcl p_code fixed binary (35) parameter; 3078 3079 dcl 1 full_language like cp_data_$standard_language aligned based (addr (cp_subsys_info.full_tct_table)); 3080 dcl 1 token_language like cp_data_$standard_language aligned based (addr (cp_subsys_info.tokens_only_tct_table)); 3081 3082 dcl (begin_iterations, end_iterations, begin_active_strings, end_active_strings) bit (8); 3083 dcl (processing_type, idx) fixed binary; 3084 3085 cp_subsys_info_ptr = p_cp_subsys_info_ptr; 3086 3087 if cp_subsys_info.version ^= CP_SUBSYS_INFO_VERSION_1 then do; 3088 p_code = error_table_$unimplemented_version; 3089 return; 3090 end; 3091 3092 if ^cp_subsys_info.non_standard_language then do; 3093 p_code = 0; /* subsystem uses the standard language which is always OK */ 3094 return; 3095 end; 3096 3097 if unspec (cp_subsys_info.full_tct_table) = unspec (cp_data_$standard_language) then do; 3098 cp_subsys_info.non_standard_language = "0"b; 3099 p_code = 0; /* it is the standard language after all */ 3100 return; 3101 end; 3102 3103 begin_iterations, end_iterations, begin_active_strings, end_active_strings = ""b; 3104 3105 do idx = lbound (full_language.character_types, 1) to hbound (full_language.character_types, 1); 3106 processing_type = full_language.character_types (idx); 3107 3108 if (processing_type < NORMAL_CHARACTER) 3109 | ((processing_type > ACTIVE_STRING_MODIFIER) & (processing_type < BEGIN_ITERATION_1)) 3110 | (processing_type > END_ACTIVE_STRING_8) then do; 3111 p_code = error_table_$bad_subr_arg; 3112 return; /* unknown processing type specified */ 3113 end; 3114 3115 if (processing_type = WHITESPACE) | (processing_type = QUOTE_CHARACTER) then 3116 token_language.character_types (idx) = processing_type; 3117 else if (processing_type = COMMAND_SEPARATOR_OR_WHITESPACE) then 3118 token_language.character_types (idx) = WHITESPACE; 3119 else token_language.character_types (idx) = NORMAL_CHARACTER; 3120 3121 if (processing_type >= BEGIN_ITERATION_1) & (processing_type <= BEGIN_ITERATION_8) then 3122 substr (begin_iterations, (processing_type - BEGIN_ITERATION_1 + 1), 1) = "1"b; 3123 if (processing_type >= END_ITERATION_1) & (processing_type <= END_ITERATION_8) then 3124 substr (end_iterations, (processing_type - END_ITERATION_1 + 1), 1) = "1"b; 3125 3126 if (processing_type >= BEGIN_ACTIVE_STRING_1) & (processing_type <= BEGIN_ACTIVE_STRING_8) then 3127 substr (begin_active_strings, (processing_type - BEGIN_ACTIVE_STRING_1 + 1), 1) = "1"b; 3128 if (processing_type >= END_ACTIVE_STRING_1) & (processing_type <= END_ACTIVE_STRING_8) then 3129 substr (end_active_strings, (processing_type - END_ACTIVE_STRING_1 + 1), 1) = "1"b; 3130 end; 3131 3132 if begin_iterations ^= end_iterations then p_code = error_table_$unbalanced_parentheses; 3133 3134 else if begin_active_strings ^= end_active_strings then p_code = error_table_$unbalanced_brackets; 3135 3136 else p_code = 0; /* every begin/end iteration/active string has a match */ 3137 3138 return; 3139 3140 end validate_request_language; 3141 3142 /* Enable the Limited Service Subsystem */ 3143 3144 setup_lss: 3145 entry (P_table_ptr); 3146 3147 dcl P_table_ptr pointer parameter; 3148 3149 cp_data_$under_lss = "1"b; 3150 cp_data_$command_table_ptr = P_table_ptr; 3151 return; 3152 3153 3154 3155 /* Disable the Limited Service Subsystem */ 3156 3157 reset_lss: 3158 entry (); 3159 3160 cp_data_$under_lss = "0"b; 3161 return; 3162 3163 3164 3165 /* Obsolete entry points */ 3166 3167 set_line: 3168 entry (P_newsize); 3169 3170 dcl P_newsize fixed binary (21) parameter; 3171 3172 call com_err_ (0, "command_processor_$set_line", 3173 "There is no restriction on command line expansion. Call ignored."); 3174 3175 return; 3176 3177 3178 get_line: 3179 entry (P_newsize); 3180 3181 call com_err_ (0, "command_processor_$get_line", "There is no restriction on command line expansion."); 3182 3183 P_newsize = MIN_AF_RETURN_LTH; 3184 3185 return; 3186 1 1 /* BEGIN: check_star_name.incl.pl1 * * * * * */ 1 2 1 3 /****^ HISTORY COMMENTS: 1 4* 1) change(86-08-14,JSLove), approve(86-08-14,MCR7518), 1 5* audit(86-08-14,FCSmith), install(86-10-02,MR12.0-1174): 1 6* Created, to support check_star_name_ entrypoint. 1 7* 2) change(87-06-01,GDixon), approve(87-07-13,MCR7740), 1 8* audit(87-06-24,Hartogs), install(87-08-04,MR12.1-1056): 1 9* Change structures and bit structures to be unaligned, to match the 1 10* check_star_name_ parameters to which such strings are passed. 1 11* END HISTORY COMMENTS */ 1 12 1 13 /* format: style3,comcol71,ifthenstmt,indcomtxt,indproc,idind30 */ 1 14 1 15 declare 1 check_star aligned based, 1 16 2 reject_wild bit (1) unaligned, 1 17 2 ignore_archive bit (1) unaligned, 1 18 2 process_archive bit (1) unaligned, 1 19 2 ignore_entrypoint bit (1) unaligned, 1 20 2 process_entrypoint bit (1) unaligned, 1 21 2 ignore_path bit (1) unaligned, 1 22 2 process_path bit (1) unaligned, 1 23 2 ignore_equal bit (1) unaligned, 1 24 2 ignore_length bit (1) unaligned, 1 25 2 ignore_nonascii bit (1) unaligned, 1 26 2 ignore_null bit (1) unaligned, 1 27 2 unimplemented bit (25) unaligned; 1 28 1 29 declare ( 1 30 CHECK_STAR_ENTRY_DEFAULT initial ("00010001000"b), /* Behavior of check_star_name_$entry (obsolete). */ 1 31 CHECK_STAR_IGNORE_ALL initial ("01010101111"b), /* Check for *** and classify only. */ 1 32 CHECK_STAR_IGNORE_ARCHIVE initial ("01000000000"b), /* Do not reject archive convention "::". */ 1 33 CHECK_STAR_IGNORE_ENTRYPOINT initial ("00010000000"b), /* Do not reject "$" or "|" characters. */ 1 34 CHECK_STAR_IGNORE_EQUAL initial ("00000001000"b), /* Do not reject "=" or "%" characters. */ 1 35 CHECK_STAR_IGNORE_LENGTH initial ("00000000100"b), /* Do not reject star names longer than 32 chars. */ 1 36 CHECK_STAR_IGNORE_NONASCII initial ("00000000010"b), /* No not reject star names with nonASCII chars. */ 1 37 CHECK_STAR_IGNORE_NULL initial ("00000000001"b), /* Do not reject names with null components. */ 1 38 CHECK_STAR_IGNORE_PATH initial ("00000100000"b), /* Do not reject "<" or ">" characters. */ 1 39 CHECK_STAR_PATH_DEFAULT initial ("00110011100"b), /* Behavior of check_star_name_$path (obsolete). */ 1 40 CHECK_STAR_PROCESS_ARCHIVE initial ("00100000000"b), /* Process "::" as archive delimiter. */ 1 41 CHECK_STAR_PROCESS_ENTRYPOINT initial ("00001000000"b), /* Ignore trailing entrypoint if present. */ 1 42 CHECK_STAR_PROCESS_PATH initial ("00000010000"b), /* Ignore leading directory path if present. */ 1 43 CHECK_STAR_REJECT_WILD initial ("10000000000"b), /* Return error_table_$nostars if type not zero. */ 1 44 CHECK_STAR_UNIMPLEMENTED initial ("001FFFFFF"b4) /* Nonexistent test flags. Reject them. */ 1 45 ) bit (36) static options (constant); 1 46 1 47 declare ( 1 48 STAR_TYPE_MATCHES_EVERYTHING initial (2), 1 49 STAR_TYPE_USE_MATCH_PROCEDURE initial (1), 1 50 STAR_TYPE_USE_PL1_COMPARE initial (0) 1 51 ) fixed bin (2) static options (constant); 1 52 1 53 /* END OF: check_star_name.incl.pl1 * * * * * */ 3187 3188 2 1 /* BEGIN INCLUDE FILE ... cp_data_.incl.pl1 */ 2 2 /* Created: July 1984 by G. Palter */ 2 3 2 4 /* Constants defined by the Multics Command Processor */ 2 5 2 6 dcl 1 cp_data_$standard_language aligned external, /* standard Multics command language definition */ 2 7 2 character_types (0:511) fixed binary (9) unaligned unsigned; 2 8 2 9 dcl cp_data_$scratch_release_factor fixed binary external; /* "permanent" scratch segments are released every N uses */ 2 10 2 11 2 12 /* Static data defined by the Multics Command Processor */ 2 13 2 14 dcl cp_data_$under_lss bit (1) aligned external; /* ON => restrict valid command names */ 2 15 dcl cp_data_$command_table_ptr pointer external; /* -> the command table if in an LSS */ 2 16 2 17 dcl cp_data_$scratch_lock_id fixed binary (35) external; /* last unique ID assigned for scratch segment management */ 2 18 2 19 /*** List of scratch segments held "permanently" by the command processor */ 2 20 dcl 1 permanent_scratch_segment_list aligned based (permanent_scratch_segment_list_ptr), 2 21 2 n_scratch_segments fixed binary, /* # of possible segments */ 2 22 2 scratch_segments (0 refer (permanent_scratch_segment_list.n_scratch_segments)), 2 23 3 segment_ptr pointer, /* ... -> an actual scratch segment */ 2 24 3 lock bit (36) aligned, /* ... unique ID of the CP instance using this segment */ 2 25 3 usage_count fixed binary; /* ... total # of times this segment has been used */ 2 26 2 27 dcl cp_data_$permanent_scratch_segment_list bit (36) aligned external; 2 28 dcl permanent_scratch_segment_list_ptr pointer; /* set to addr (cp_data_$permanent_scratch_segment_list) to 2 29* allow different list sizes in BCE and Multics */ 2 30 2 31 /* END INCLUDE FILE ... cp_data_.incl.pl1 */ 3189 3190 3 1 /* BEGIN INCLUDE FILE ... cp_character_types.incl.pl1 */ 3 2 /* Created: June 1982 by G. Palter */ 3 3 3 4 /* Character types used to define Multics command language and subsystem request languages */ 3 5 3 6 dcl (NORMAL_CHARACTER initial ( 0), /* normal everyday character */ 3 7 3 8 WHITESPACE initial ( 1), /* separates tokens but is otherwise ignored (ie: does not 3 9* appear in the command/request name or any arguments */ 3 10 3 11 COMMAND_SEPARATOR initial ( 2), /* separate multiple commands/requests on the line but is 3 12* otherwise ignored (as above) (semi-colon) */ 3 13 COMMAND_SEPARATOR_OR_WHITESPACE initial ( 3), /* separate multiple commands/requests on the line and is also 3 14* treated as whitespace when rescanning |[...] return values 3 15* (newline) */ 3 16 3 17 SINGLE_TOKEN initial ( 4), /* appears as a one character argument to the command/request 3 18* even if not surrounded by whitespace (causes a break) */ 3 19 3 20 COMPOUND_TOKEN initial ( 5), /* appears as an argument to the command/request even if not 3 21* surrounded by whitespace; if several of this type character 3 22* appear on the line without any intervening characters, they 3 23* are merged into a single argument (eg: ^=) */ 3 24 3 25 QUOTE_CHARACTER initial ( 6), /* begin and end a quoted string ("): only the same character 3 26* ends the quoted string (ie: "' isn't a completed string); 3 27* within the string, any occurence of this character must be 3 28* doubled */ 3 29 3 30 ACTIVE_STRING_MODIFIER initial ( 7), /* modifies interpretation of an active string (|) */ 3 31 3 32 BEGIN_ITERATION_1 initial (17), /* starts an iteration set; only matches END_ITERATION_1 */ 3 33 BEGIN_ITERATION_2 initial (18), /* starts an iteration set; only matches END_ITERATION_2 */ 3 34 BEGIN_ITERATION_3 initial (19), /* ... */ 3 35 BEGIN_ITERATION_4 initial (20), /* ... */ 3 36 BEGIN_ITERATION_5 initial (21), /* ... */ 3 37 BEGIN_ITERATION_6 initial (22), /* ... */ 3 38 BEGIN_ITERATION_7 initial (23), /* ... */ 3 39 BEGIN_ITERATION_8 initial (24), /* ... */ 3 40 3 41 END_ITERATION_1 initial (25), /* ends an iteration set; only matches BEGIN_ITERATION_1 */ 3 42 END_ITERATION_2 initial (26), /* ends an iteration set; only matches BEGIN_ITERATION_2 */ 3 43 END_ITERATION_3 initial (27), /* ... */ 3 44 END_ITERATION_4 initial (28), /* ... */ 3 45 END_ITERATION_5 initial (29), /* ... */ 3 46 END_ITERATION_6 initial (30), /* ... */ 3 47 END_ITERATION_7 initial (31), /* ... */ 3 48 END_ITERATION_8 initial (32), /* ... */ 3 49 3 50 BEGIN_ACTIVE_STRING_1 initial (33), /* starts active string; only matches END_ACTIVE_STRING_1 */ 3 51 BEGIN_ACTIVE_STRING_2 initial (34), /* starts active string; only matches END_ACTIVE_STRING_2 */ 3 52 BEGIN_ACTIVE_STRING_3 initial (35), /* ... */ 3 53 BEGIN_ACTIVE_STRING_4 initial (36), /* ... */ 3 54 BEGIN_ACTIVE_STRING_5 initial (37), /* ... */ 3 55 BEGIN_ACTIVE_STRING_6 initial (38), /* ... */ 3 56 BEGIN_ACTIVE_STRING_7 initial (39), /* ... */ 3 57 BEGIN_ACTIVE_STRING_8 initial (40), /* ... */ 3 58 3 59 END_ACTIVE_STRING_1 initial (41), /* ends active string; only matches BEGIN_ACTIVE_STRING_1 */ 3 60 END_ACTIVE_STRING_2 initial (42), /* ends active string; only matches BEGIN_ACTIVE_STRING_2 */ 3 61 END_ACTIVE_STRING_3 initial (43), /* ... */ 3 62 END_ACTIVE_STRING_4 initial (44), /* ... */ 3 63 END_ACTIVE_STRING_5 initial (45), /* ... */ 3 64 END_ACTIVE_STRING_6 initial (46), /* ... */ 3 65 END_ACTIVE_STRING_7 initial (47), /* ... */ 3 66 END_ACTIVE_STRING_8 initial (48)) /* ... */ 3 67 fixed binary (9) unsigned static options (constant); 3 68 3 69 /* END INCLUDE FILE ... cp_character_types.incl.pl1 */ 3191 3192 4 1 /* BEGIN INCLUDE FILE ... cp_active_string_types.incl.pl1 */ 4 2 /* Created: 5 May 1980 by G. Palter */ 4 3 4 4 /* Types of active strings recognized by active string evaluation entries of the Multics command processor */ 4 5 4 6 dcl (DEFAULT_ACTIVE_STRING initial (0), /* default type: same as NORMAL_ACTIVE_STRING */ 4 7 NORMAL_ACTIVE_STRING initial (1), /* normal active string: [...] */ 4 8 TOKENS_ONLY_ACTIVE_STRING initial (2), /* rescan active string for whitespace and quotes: |[...] */ 4 9 ATOMIC_ACTIVE_STRING initial (3)) /* do not rescan anything in value: ||[...] */ 4 10 fixed binary static options (constant); 4 11 4 12 /* END INCLUDE FILE ... cp_active_string_types.incl.pl1 */ 3193 3194 5 1 /* BEGIN INCLUDE FILE ... _cp_subsys_info.incl.pl1 */ 5 2 5 3 5 4 /****^ HISTORY COMMENTS: 5 5* 1) change(82-06-01,Palter), approve(), audit(), install(): 5 6* Created include file. 5 7* 2) change(86-05-18,GDixon), approve(86-05-18,MCR7357), 5 8* audit(86-06-16,Farley), install(86-07-18,MR12.0-1098): 5 9* Modify cp_subsys_info to make TCT table entries aligned. Calling sequence 5 10* of tct_ changed when the routine was renamed to find_char_. 5 11* END HISTORY COMMENTS */ 5 12 5 13 5 14 /* Data structure passed by subsystem utilities to the command processor to convey request processor options to the 5 15* command processor */ 5 16 5 17 dcl 1 cp_subsys_info aligned based (cp_subsys_info_ptr), 5 18 2 version character (8), 5 19 2 language_info, 5 20 3 non_standard_language bit (1) aligned, /* ON => a non-standard language definition is to be used */ 5 21 3 full_tct_table character (512), /* PL/I search table for scanning the request line */ 5 22 3 tokens_only_tct_table character (512); /* PL/I search table for scanning |[...] return strings */ 5 23 5 24 5 25 dcl cp_subsys_info_ptr pointer; 5 26 5 27 dcl CP_SUBSYS_INFO_VERSION_1 character (8) static options (constant) initial ("csi_0001"); 5 28 5 29 /* END INCLUDE FILE ... _cp_subsys_info.incl.pl1 */ 3195 3196 6 1 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 6 2 /* format: style3 */ 6 3 6 4 /* These constants are to be used for the flags argument of sub_err_ */ 6 5 /* They are just "string (condition_info_header.action_flags)" */ 6 6 6 7 declare ( 6 8 ACTION_CAN_RESTART init (""b), 6 9 ACTION_CANT_RESTART init ("1"b), 6 10 ACTION_DEFAULT_RESTART 6 11 init ("01"b), 6 12 ACTION_QUIET_RESTART 6 13 init ("001"b), 6 14 ACTION_SUPPORT_SIGNAL 6 15 init ("0001"b) 6 16 ) bit (36) aligned internal static options (constant); 6 17 6 18 /* End include file */ 3197 3198 end command_processor_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0803.5 command_processor_.pl1 >spec>install>1111>command_processor_.pl1 3187 1 08/06/87 0913.4 check_star_name.incl.pl1 >ldd>include>check_star_name.incl.pl1 3189 2 09/14/84 0926.8 cp_data_.incl.pl1 >ldd>include>cp_data_.incl.pl1 3191 3 09/09/82 1418.0 cp_character_types.incl.pl1 >ldd>include>cp_character_types.incl.pl1 3193 4 09/22/80 1256.7 cp_active_string_types.incl.pl1 >ldd>include>cp_active_string_types.incl.pl1 3195 5 07/24/86 2051.7 _cp_subsys_info.incl.pl1 >ldd>include>_cp_subsys_info.incl.pl1 3197 6 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 000150 constant bit(36) initial dcl 6-7 set ref 331* ACTIVE_STRING constant fixed bin(17,0) initial dcl 654 ref 813 1024 1111 1325 1388 ACTIVE_STRING_MODIFIER constant fixed bin(9,0) initial unsigned dcl 3-6 ref 3108 ATOM constant fixed bin(17,0) initial dcl 654 ref 808 937 946 1153 1167 1199 1255 1303 1636 1821 1946 ATOMIC_ACTIVE_STRING constant fixed bin(17,0) initial dcl 4-6 ref 270 310 818 BEGIN_ACTIVE_STRING_1 constant fixed bin(9,0) initial unsigned dcl 3-6 ref 1228 1237 3126 3126 BEGIN_ACTIVE_STRING_8 constant fixed bin(9,0) initial unsigned dcl 3-6 ref 1228 1237 3126 BEGIN_ITERATION constant fixed bin(17,0) initial dcl 654 ref 1268 1289 1466 1723 1830 1974 2043 BEGIN_ITERATION_1 constant fixed bin(9,0) initial unsigned dcl 3-6 ref 3108 3121 3121 BEGIN_ITERATION_8 constant fixed bin(9,0) initial unsigned dcl 3-6 ref 3121 BREAKS 000070 constant char(12) initial packed unaligned dcl 225 ref 928 1528 CHECK_STAR_IGNORE_ENTRYPOINT constant bit(36) initial packed unaligned dcl 1-29 ref 2332 CHECK_STAR_PROCESS_PATH constant bit(36) initial packed unaligned dcl 1-29 ref 2332 CHECK_STAR_REJECT_WILD constant bit(36) initial packed unaligned dcl 1-29 ref 2332 COMMAND_BREAKS constant char(2) initial packed unaligned dcl 245 ref 519 1059 COMMAND_PROCESSOR_ 000103 constant char(32) initial packed unaligned dcl 174 set ref 331* 393* 2947* 2977* 3004* 3014* COMMAND_SEPARATOR_OR_WHITESPACE constant fixed bin(9,0) initial unsigned dcl 3-6 ref 3117 COMPOUND_TOKEN constant fixed bin(9,0) initial unsigned dcl 3-6 ref 1174 CP_SUBSYS_INFO_VERSION_1 000060 constant char(8) initial packed unaligned dcl 5-27 ref 330 3087 END_ACTIVE_STRING_1 constant fixed bin(9,0) initial unsigned dcl 3-6 ref 1245 3128 3128 END_ACTIVE_STRING_8 constant fixed bin(9,0) initial unsigned dcl 3-6 ref 1245 3108 3128 END_ITERATION constant fixed bin(17,0) initial dcl 654 ref 1299 1305 1807 2017 2051 END_ITERATION_1 constant fixed bin(9,0) initial unsigned dcl 3-6 ref 3123 3123 END_ITERATION_8 constant fixed bin(9,0) initial unsigned dcl 3-6 ref 3123 END_OF_COMMAND constant fixed bin(17,0) initial dcl 654 ref 1611 1747 EXECUTE_COMMAND_LINE_ 000073 constant char(32) initial packed unaligned dcl 175 set ref 398* FALSE 000147 constant bit(1) initial dcl 2312 set ref 2326 2515 2542 2563 2567 2586 2638* 2647* 2801 2804 2808 2811 2816 INPUT 000150 constant bit(1) initial dcl 2312 set ref 2656* LEFT_BRACKET 020073 constant char(1) initial packed unaligned dcl 239 ref 1030 1348 1348 MAX_STACK_EXTENSION constant fixed bin(21,0) initial dcl 177 ref 2178 MIN_AF_RETURN_LTH constant fixed bin(21,0) initial dcl 179 ref 1690 3183 NON_SIMPLE_BREAKS 000062 constant char(6) initial packed unaligned dcl 234 ref 366 2808 NORMAL_ACTIVE_STRING constant fixed bin(17,0) initial dcl 4-6 ref 269 309 NORMAL_CHARACTER constant fixed bin(9,0) initial unsigned dcl 3-6 ref 3108 3119 Niters 1 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 2886 in procedure "process_pipe_cleanup" ref 2891 Niters 1 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2400 2428 2475 Niters 1 based fixed bin(17,0) level 2 in structure "command_pipe_control" dcl 737 in procedure "complex_command_processor" set ref 831* Niters 1 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 1484 in procedure "process_active_function" set ref 1516* Npipes_in_line based fixed bin(17,0) level 2 dcl 894 set ref 996* 1013* 1013 OUTPUT 000147 constant bit(1) initial dcl 2312 set ref 2712* PIPE_BREAK 020074 constant char(2) initial packed unaligned dcl 237 ref 992 992 1022 P_active_string_type parameter fixed bin(17,0) dcl 122 ref 263 269 301 309 P_code parameter fixed bin(35,0) dcl 135 set ref 106 263 277 289 301 403* 3063 3066* P_cp_subsys_info_ptr parameter pointer dcl 124 set ref 277 301 326 329 3063 3066* P_eval_string_options_ptr parameter pointer dcl 119 ref 263 P_execute_request parameter entry variable dcl 129 ref 277 301 359 P_line parameter char packed unaligned dcl 115 set ref 263 277 289 301 316 318 P_line_len parameter fixed bin(21,0) dcl 113 ref 106 257 P_line_ptr parameter pointer dcl 112 ref 106 256 P_newsize parameter fixed bin(21,0) dcl 3170 set ref 3167 3178 3183* P_old_execute_request parameter entry variable dcl 132 ref 289 361 P_return_value parameter varying char dcl 117 set ref 263 301 340* 839* 839 2156 2156 2159* 2159 2161* 2161 P_subsystem_info_ptr parameter pointer dcl 128 set ref 277 301 556* 2276* P_subsystem_name parameter char packed unaligned dcl 127 set ref 277 301 331* 397* P_table_ptr parameter pointer dcl 3147 ref 3144 3150 QUOTE_CHARACTER constant fixed bin(9,0) initial unsigned dcl 3-6 ref 3115 RIGHT_BRACKET 020072 constant char(1) initial packed unaligned dcl 241 ref 1079 1079 SIMPLE_BREAKS 000064 constant char(6) initial packed unaligned dcl 231 ref 343 344 483 514 SPACE 020070 constant char(1) initial packed unaligned dcl 247 ref 2515 2515 2603 2604 2812 2812 2812 2812 2819 2819 Satds_match parameter bit(1) dcl 2676 in procedure "attach_output" set ref 2670 2692* 2696* Satds_match 000252 automatic bit(1) dcl 2302 in procedure "process_pipe" set ref 2326* 2386 2464* 2467* 2764* Sbuild_return_string 4 based bit(1) level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 999* 1079* 1404 Sbuild_return_string 4 based bit(1) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2343 2399 2478 Sdefault1 000106 automatic bit(1) dcl 2499 set ref 2521* Sdefault2 parameter bit(1) dcl 2495 ref 2492 2532 Sdefault_curr_to_vfile 000253 automatic bit(1) dcl 2303 set ref 2350* 2421* Sdefault_to_vfile 001560 automatic bit(1) dcl 2679 in procedure "attach_output" set ref 2691* 2692* 2695* Sdefault_to_vfile parameter bit(1) dcl 2788 in procedure "element_is_an_atd" set ref 2785 2801* 2835* Sdefault_to_vfile 000100 automatic bit(1) dcl 2623 in procedure "attach_input" set ref 2638* 2638* Sevaluate_pipe 3 based bit(1) level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 998* 1039* 1078 1120 Sevaluate_pipe 3 based bit(1) level 2 in structure "pipe_control" dcl 1484 in procedure "process_active_function" ref 1507 1514 1570 Sevaluate_pipe 3 based bit(1) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2342 Sinclude_NL_in_af_ret_str 5 based bit(1) level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1000* 1041* 1082 Sinclude_NL_in_af_ret_str 5 based bit(1) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2736 Sterminate 6 based bit(1) level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 997* 1101* 1450* Sterminate 6 based bit(1) level 2 in structure "command_pipe_control" dcl 737 in procedure "complex_command_processor" ref 848 TOKENS_ONLY_ACTIVE_STRING constant fixed bin(17,0) initial dcl 4-6 ref 816 TOKEN_BREAKS 000066 constant char(6) initial packed unaligned dcl 228 ref 921 1542 TRUE 000150 constant bit(1) initial dcl 2312 set ref 2556 2566 2576 2647* 2695* 2704* 2704* 2832 2835 2837 VERTICAL_BAR 020071 constant char(1) initial packed unaligned dcl 243 ref 1040 1040 1042 2330 2330 WHITESPACE constant fixed bin(9,0) initial unsigned dcl 3-6 ref 3115 3117 abort_command_execution 000126 automatic label variable dcl 166 set ref 375* 379 383 471* absolute_pathname_ 000042 constant entry external dcl 200 ref 2552 2559 active_function 000150 constant bit(1) initial dcl 728 set ref 1502* 1512* 1520* 1766 2094 2104 2126 addcharno builtin function dcl 220 ref 1020 1031 1062 1066 1104 1453 addr builtin function dcl 220 ref 316 489 500 501 535 535 537 537 537 550 550 556 556 562 562 763 773 773 773 773 784 787 788 806 812 814 850 850 850 850 907 938 947 1154 1168 1200 1256 1356 1356 1356 1356 1416 1416 1416 1416 1533 1546 1600 1600 1600 1600 1616 1616 1616 1616 1669 2099 2106 2107 2218 2271 2271 2276 2276 2281 2281 2701 2701 2812 2812 2829 2829 2913 2918 2944 2972 3001 3017 3037 3047 3050 3054 3105 3105 3106 3115 3117 3119 addrel builtin function dcl 220 ref 1533 1546 1589 1637 1690 2106 af based structure level 1 dcl 626 af_is_atom 000106 automatic bit(1) dcl 879 set ref 952* 1231* 1329 1567* af_is_tokens 000107 automatic bit(1) dcl 880 set ref 953* 1239* 1330 1568* af_iter_parent 2 based pointer level 2 packed packed unaligned dcl 639 set ref 1673* af_line_len 000141 automatic fixed bin(21,0) dcl 891 set ref 1590* 1607* 1614* af_line_ptr 000130 automatic pointer dcl 887 set ref 1589* 1607* 1614* af_prev 1 based pointer level 2 packed packed unaligned dcl 639 set ref 1612 1672* 1750 af_return_str_len parameter fixed bin(21,0) dcl 2450 in procedure "process_pipe_command" set ref 2447 2478* af_return_str_len parameter fixed bin(21,0) dcl 2370 in procedure "process_attach_description" set ref 2367 2402* af_return_str_ptr parameter pointer dcl 2450 in procedure "process_pipe_command" set ref 2447 2478* af_return_str_ptr parameter pointer dcl 2370 in procedure "process_attach_description" set ref 2367 2402* af_start 000142 automatic fixed bin(21,0) dcl 891 set ref 1593* 1607* 1609 1614* afp 000122 automatic pointer dcl 887 set ref 909* 1333 1490* 1491 1492 1495 1498 1522 1528 1528 1539 1556 1563 1567 1568 1573 1577 1607 1614 after builtin function dcl 220 ref 2599 2604 after_bracket_idx 000146 automatic fixed bin(21,0) dcl 897 set ref 1030* 1031 1033 aligned_command_name 000240 automatic char(32) dcl 2299 set ref 2349* 2350* arg based char packed unaligned dcl 1899 set ref 2194* 2201* 2218 arg_count 000672 automatic fixed bin(17,0) dcl 724 in procedure "complex_command_processor" set ref 828* 835* 838* arg_count 000136 automatic fixed bin(17,0) dcl 890 in procedure "make_list" set ref 1502* 1507 1507* 1507 1512* 1518* 1520* arg_len 000141 automatic fixed bin(17,0) array dcl 1900 set ref 1951* 2001* 2101 2118 2135 2135 2154 2216* 2255* 2261* 2265* 2276 2276 2281 2281 2859 arg_list 000142 automatic structure level 1 dcl 1902 in procedure "produce_argument_list" set ref 2271 2271 2276 2276 2281 2281 arg_list 000306 automatic structure level 1 dcl 433 in procedure "simple_command_processor" set ref 550 550 556 556 562 562 arg_list_overlay based bit(72) array packed unaligned dcl 452 set ref 537 arg_ptr 2 000142 automatic pointer array level 2 in structure "arg_list" dcl 1902 in procedure "produce_argument_list" set ref 1954* 2004* 2106* 2153 2215* 2858 arg_ptr 000122 automatic pointer dcl 1888 in procedure "produce_argument_list" set ref 1940* 2184* 2194 2197* 2201 2213 2215 2218* 2218 arg_ptrs 2 000306 automatic pointer array level 2 dcl 433 set ref 495 500* 533 535 537 arg_space 000130 automatic fixed bin(21,0) dcl 1889 set ref 1936* 2175 2186* 2186 2192* 2194 2195* 2195 2201 2204* 2204 2218 2221* 2221 argument_idx 000112 automatic fixed bin(17,0) dcl 1881 set ref 2098* 2099 2099 2100 2101 2101* 2145* 2147 2151 2153 2154* 2850* 2852 2856 2858 2859* array based structure array level 2 dcl 692 set ref 1656 1669 atom based structure level 1 dcl 596 atom_len 000646 automatic fixed bin(21,0) dcl 706 set ref 921* 924* 928* 930* 934 935* 939 944 948 949 1948* 1951 1992* 2001 2175 2176 2176 2201 2201 2202 2204 atom_ptr 000650 automatic pointer dcl 707 set ref 1947* 1952 1954 1991* 2002 2004 2176 2201 atom_string based char packed unaligned dcl 705 ref 2176 2201 atom_sw 7 000145 automatic bit(1) level 3 in structure "dummy_af_node" dcl 690 in procedure "complex_command_processor" set ref 818* atom_sw 7 based bit(1) level 3 in structure "af" dcl 626 in procedure "complex_command_processor" set ref 1329* 1522 1528 1539 1567 attach_description 000254 automatic char(1024) dcl 2304 set ref 2357* 2380* 2387* 2402* 2411* 2425* attach_description_1 parameter char dcl 2495 set ref 2492 2515 2521* 2524* 2549* 2573* attach_description_2 parameter char dcl 2495 set ref 2492 2515 2535* 2550* 2574* before builtin function dcl 220 ref 2603 2812 2812 2812 2812 2819 2819 2825 begin 1 based pointer level 2 packed packed unaligned dcl 616 set ref 1306* begin_active_strings 000102 automatic bit(8) packed unaligned dcl 3082 set ref 3103* 3126* 3134 begin_iterations 000100 automatic bit(8) packed unaligned dcl 3082 set ref 3103* 3121* 3132 bit builtin function dcl 220 ref 2915 bits 000513 automatic bit(12) array level 2 in structure "descriptors" packed packed unaligned dcl 445 in procedure "simple_command_processor" set ref 502* bits 000142 automatic bit(12) array level 2 in structure "descriptor" packed packed unaligned dcl 1914 in procedure "produce_argument_list" set ref 2100* 2108* block_ptr 000160 automatic pointer dcl 695 set ref 763* 764 765 1656 1659 1661* 1663 1664 1665 1669 3039* 3039* 3042* 3043 3050* 3051 3052 c based char(1) array packed unaligned dcl 877 set ref 938 947 955* 1154 1168 1173* 1188 1200 1217 1256 catenate_sw 11 based bit(1) level 3 dcl 626 set ref 1331* 1495* 1556 catenate_values 000110 automatic bit(1) dcl 881 set ref 954* 1247* 1495 character_types based fixed bin(9,0) array level 2 in structure "token_language" packed packed unsigned unaligned dcl 716 in procedure "complex_command_processor" ref 966 character_types based fixed bin(9,0) array level 2 in structure "token_language" packed packed unsigned unaligned dcl 3080 in procedure "validate_request_language" set ref 3115* 3117* 3119* character_types based fixed bin(9,0) array level 2 in structure "full_language" packed packed unsigned unaligned dcl 3079 in procedure "validate_request_language" ref 3105 3105 3106 character_types based fixed bin(9,0) array level 2 in structure "full_language" packed packed unsigned unaligned dcl 713 in procedure "complex_command_processor" ref 968 check_star_name_ 000044 constant entry external dcl 201 ref 2332 cleanup 000000 stack reference condition dcl 218 ref 770 1352 1421 1596 2133 code parameter fixed bin(35,0) dcl 2450 in procedure "process_pipe_command" set ref 2447 2456* 2458* 2459 2464* 2467* 2469 2472* 2478* code parameter fixed bin(35,0) dcl 2250 in procedure "process_command" set ref 2247 2255* 2257 2261* 2265* 2267 2276* 2277 2281* 2282 code 000114 automatic fixed bin(35,0) dcl 147 in procedure "command_processor_" set ref 322* 393 393* 397* 398* 400 400* 403 544* 545 547* 548 556* 557 562* 563 1083* 1122* 1195* 1285* 1290* 1295* 1379* 1384* 1389* 1394* 1406* 1410* 1426* 1466* 1468* 1735* 1851* 2129* 2130 2135* 2136 2156* 2163 2947* 2948 2977* 2978 code parameter fixed bin(35,0) dcl 2728 in procedure "build_pipe_return_string" set ref 2725 2733* 2734 2736* 2739* code parameter fixed bin(35,0) dcl 2295 in procedure "process_pipe" set ref 2292 2330* 2332* 2337 2350* 2358* 2360* 2553* 2554 2555* 2560* 2561 2562* 2861* 2869 code parameter fixed bin(35,0) dcl 2370 in procedure "process_attach_description" set ref 2367 2374* 2380* 2381 2387* 2388 2402* 2411* 2425* 2426 code parameter fixed bin(35,0) dcl 2752 in procedure "copy_thru_pipe" set ref 2749 2756* 2758 2759* 2763 2764* 2766 2768* 2770 code parameter fixed bin(35,0) dcl 2621 in procedure "attach_input" set ref 2616 2627* 2638* 2643* 2647* 2651 2656* 2657 2658 code parameter fixed bin(35,0) dcl 2677 in procedure "attach_output" set ref 2670 2681* 2695* 2700 2704* 2707 2712* 2713 code parameter fixed bin(35,0) dcl 2788 in procedure "element_is_an_atd" set ref 2785 2812* 2814 2819* 2829* 2832 2836* com_err_ 000046 constant entry external dcl 202 ref 393 397 398 3172 3181 command 000147 constant bit(1) initial dcl 728 set ref 1518* 2123 command_abort_ 000236 stack reference condition dcl 218 ref 376 386 2122 command_entry_ptr 000654 automatic pointer dcl 2305 in procedure "process_pipe" set ref 2325* 2350* 2360* command_entry_ptr parameter pointer dcl 2250 in procedure "process_command" set ref 2247 2260 2261* 2265* 2271* command_entry_ptr 000116 automatic pointer dcl 1885 in procedure "produce_argument_list" set ref 2120* 2129* command_entry_ptr 000566 automatic pointer dcl 465 in procedure "simple_command_processor" set ref 547* 550* command_entry_ptr parameter pointer dcl 2450 in procedure "process_pipe_command" set ref 2447 2472* command_entry_ptr 000244 automatic pointer dcl 2797 in procedure "element_is_an_atd" set ref 2812* 2815 2829* command_line_attach 001000 automatic varying char(1024) dcl 2847 set ref 2849* 2861 2861 2865* 2865 2867* 2867 2872 command_name based char packed unaligned dcl 462 in procedure "simple_command_processor" set ref 556* 562* command_name parameter char packed unaligned dcl 2450 in procedure "process_pipe_command" ref 2447 command_name based char packed unaligned dcl 1883 in procedure "produce_argument_list" set ref 2118 2135* 2276* 2281* command_name parameter char packed unaligned dcl 2295 in procedure "process_pipe" set ref 2292 2330 2332* 2338 2349 2360* command_name_for_move based bit(144) dcl 451 set ref 537* 537 command_name_length 000142 automatic fixed bin(21,0) level 3 in structure "arg_list" dcl 1902 in procedure "produce_argument_list" set ref 2118* command_name_length 204 000306 automatic fixed bin(21,0) level 3 in structure "arg_list" dcl 433 in procedure "simple_command_processor" set ref 529* command_name_lth 000564 automatic fixed bin(17,0) dcl 464 set ref 490* 529 544* 547* 556 556 562 562 command_name_ptr 000114 automatic pointer dcl 1884 in procedure "produce_argument_list" set ref 1952* 2002* 2118 2119 2135 2151 2213* 2255* 2261* 2265* 2276 2281 2856 command_name_ptr 000142 automatic pointer level 3 in structure "arg_list" dcl 1902 in procedure "produce_argument_list" set ref 2119* command_name_ptr 202 000306 automatic pointer level 3 in structure "arg_list" dcl 433 in procedure "simple_command_processor" set ref 530* command_name_ptr 000562 automatic pointer dcl 463 in procedure "simple_command_processor" set ref 489* 530 544* 547* 556 562 command_pipe_control based structure level 1 dcl 737 set ref 776 853 command_pipe_control_ptr 000700 automatic pointer dcl 736 set ref 756* 772 773 773 773 773 776 777* 822* 830 831 832 835* 838* 848 848 850 850 850 850 853 854* complex_line 000122 automatic bit(1) dcl 158 set ref 347* 364* 366* 371* 373 385* 391 continue_scan 000135 automatic bit(1) dcl 889 set ref 1191* 1192 1208* 1209* copy_input_atd parameter char dcl 2752 set ref 2749 2756* 2764* 2770 copy_output_atd parameter char dcl 2752 set ref 2749 2764* 2770 count 000673 automatic fixed bin(17,0) dcl 725 set ref 1727* 1732 1734 1936* 1951 1952 1954 1956* 1956 2001 2002 2004 2006* 2006 2094 2096 2098 2145 2147 2213 2215 2216 2223* 2223 2850 2852 cp_data_$command_table_ptr 000112 external static pointer dcl 2-15 set ref 544* 2255* 3150* cp_data_$permanent_scratch_segment_list 000116 external static bit(36) dcl 2-27 set ref 2913 cp_data_$scratch_lock_id 000114 external static fixed bin(35,0) dcl 2-17 set ref 2914* 2914 2915 cp_data_$scratch_release_factor 000106 external static fixed bin(17,0) dcl 2-9 ref 3003 cp_data_$standard_language 000104 external static structure level 1 dcl 2-6 set ref 784 3097 cp_data_$under_lss 000110 external static bit(1) dcl 2-14 set ref 356 3149* 3160* cp_subsys_info based structure level 1 dcl 5-17 cp_subsys_info_ptr 000254 automatic pointer dcl 5-25 set ref 329* 330 331 331 337 787 788 924 930 1533 1546 3085* 3087 3092 3097 3098 3105 3105 3106 3115 3117 3119 cu_$gen_call 000050 constant entry external dcl 203 ref 550 2271 cu_$grow_stack_frame 000052 constant entry external dcl 204 ref 2180 current_arg based char packed unaligned dcl 1897 ref 2194 current_arg_len 000140 automatic fixed bin(21,0) dcl 1896 set ref 1936* 1955* 1982* 2005* 2175 2194 2194 2195 2201 2202* 2202 2216 2218 2221 2225* current_pipe based char dcl 895 in procedure "make_list" ref 1030 1405 current_pipe based char dcl 2306 in procedure "process_pipe" set ref 2421* current_pipe_len 54 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2328 2421 2421 current_pipe_len 54 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1006* 1019 1021* 1030 1033* 1033 1103 1105* 1405 1452 1454* current_pipe_ptr 52 based pointer level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1005* 1018 1020* 1030 1031* 1031 1102 1104* 1405 1451 1453* current_pipe_ptr 52 based pointer level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2421 currentsize builtin function dcl 220 ref 2176 delimiter_class 4 based fixed bin(17,0) level 2 in structure "af" dcl 626 in procedure "complex_command_processor" set ref 1327* 1393 1573 delimiter_class 4 based fixed bin(17,0) level 2 in structure "iter_begin" dcl 606 in procedure "complex_command_processor" set ref 1270* 1294 descriptor 000142 automatic structure array level 1 dcl 1914 set ref 2099 2107 descriptor_ptr 000142 automatic pointer array level 2 dcl 1902 set ref 2099* 2107* descriptor_ptrs 102 000306 automatic pointer array level 2 dcl 433 set ref 501* 535 descriptor_ptrs_for_move based bit dcl 449 set ref 535* 535 descriptors 000513 automatic structure array level 1 dcl 445 set ref 501 dimension builtin function dcl 220 ref 2919 dirname 000100 automatic char(168) packed unaligned dcl 2793 set ref 2819* divide builtin function dcl 220 ref 1688 1690 2176 dummy_af_node 000145 automatic structure level 1 dcl 690 set ref 811* 812 907 dummy_node 000133 automatic structure level 1 dcl 689 set ref 805* 806 814 3054 end 1 based pointer level 2 packed packed unaligned dcl 606 set ref 1312* 1980 1993 2039 2047 end_active_strings 000103 automatic bit(8) packed unaligned dcl 3082 set ref 3103* 3128* 3134 end_iterations 000101 automatic bit(8) packed unaligned dcl 3082 set ref 3103* 3123* 3132 end_of_command 000555 automatic bit(1) dcl 456 set ref 478* 481 509* 517* 519* entryname 000152 automatic char(32) packed unaligned dcl 2793 set ref 2819* 2825 2825 2825 error_message 000134 automatic varying char(256) dcl 172 set ref 320* 393 393* 397* 398* 1084* 1123* 1411* 2338* 2652* 2658* 2660* 2708* 2714* 2770* error_table_$bad_file_name 000010 external static fixed bin(35,0) dcl 183 ref 2330 error_table_$bad_pipe_syntax 000012 external static fixed bin(35,0) dcl 183 ref 1083 1122 1410 error_table_$bad_subr_arg 000014 external static fixed bin(35,0) dcl 183 ref 3111 error_table_$command_line_overflow 000016 external static fixed bin(35,0) dcl 183 ref 2156 2861 error_table_$mismatched_iter 000020 external static fixed bin(35,0) dcl 183 ref 1735 error_table_$no_file 000024 external static fixed bin(35,0) dcl 183 ref 2643 2758 error_table_$noentry 000026 external static fixed bin(35,0) dcl 183 ref 2658 error_table_$null_brackets 000022 external static fixed bin(35,0) dcl 183 ref 1406 1426 error_table_$unbalanced_brackets 000030 external static fixed bin(35,0) dcl 183 ref 1290 1379 1384 1394 1468 3134 error_table_$unbalanced_parentheses 000032 external static fixed bin(35,0) dcl 183 ref 1285 1295 1389 1466 1851 3132 error_table_$unbalanced_quotes 000034 external static fixed bin(35,0) dcl 183 ref 1195 error_table_$unimplemented_version 000036 external static fixed bin(35,0) dcl 183 set ref 331* 3088 evaluate_string 000117 automatic bit(1) dcl 153 set ref 255* 268* 282* 294* 307* 340 364 393 810 828* 835 835* 838* 906 1333 1383 1463 1577 2261 execute_request 000104 automatic entry variable dcl 144 set ref 359* 556 2276 executing 000125 automatic bit(1) dcl 165 set ref 374* 379 383 549* 555* 561* 566* expand_pathname_ 000134 constant entry external dcl 2799 ref 2819 extension_size 000120 automatic fixed bin(21,0) dcl 1887 set ref 1936* 2177* 2177 2178 find_char_$first_in_table 000054 constant entry external dcl 205 ref 924 930 1533 1546 find_command_ 000056 constant entry external dcl 206 ref 547 2265 find_command_$fc_no_message 000060 constant entry external dcl 207 ref 2261 2812 2829 first_count 000103 automatic bit(1) dcl 1791 set ref 1802* 1834* 1841 1844* first_iter 000104 automatic bit(1) dcl 1711 set ref 1714* 1730 1731* 1771 first_node 000666 automatic pointer dcl 723 in procedure "complex_command_processor" set ref 825* 825* 828* 835* 838* first_node 000124 automatic pointer dcl 887 in procedure "make_list" set ref 1498* 1498* 1502* 1512* 1518* 1520* fixed builtin function dcl 220 ref 2915 flags 6 based structure level 2 in structure "atom" dcl 596 in procedure "complex_command_processor" flags 6 000145 automatic structure level 2 in structure "dummy_af_node" dcl 690 in procedure "complex_command_processor" flags 6 based structure level 2 in structure "iter_end" dcl 616 in procedure "complex_command_processor" flags 6 based structure level 2 in structure "node" dcl 639 in procedure "complex_command_processor" flags 6 based structure level 2 in structure "af" dcl 626 in procedure "complex_command_processor" full_language based structure level 1 dcl 3079 in procedure "validate_request_language" full_language based structure level 1 dcl 713 in procedure "complex_command_processor" full_language_ptr 000656 automatic pointer dcl 714 set ref 784* 787* 968 full_path1 000107 automatic char(1024) packed unaligned dcl 2499 set ref 2552* 2553* full_path2 000507 automatic char(1024) packed unaligned dcl 2499 set ref 2559* 2560* full_tct_table 3 based char(512) level 3 dcl 5-17 set ref 787 930* 1533* 3097 3105 3105 3106 get_system_free_area_ 000062 constant entry external dcl 208 ref 761 get_temp_segment_ 000064 constant entry external dcl 209 ref 2947 2977 get_wdir_ 000066 constant entry external dcl 210 ref 2410 2463 has_command_name 1(18) 000142 automatic bit(1) level 2 in structure "arg_list" packed packed unaligned dcl 1902 in procedure "produce_argument_list" set ref 2117* has_command_name 1(18) 000306 automatic bit(1) level 2 in structure "arg_list" packed packed unaligned dcl 433 in procedure "simple_command_processor" set ref 528* hbound builtin function dcl 220 ref 495 533 1656 3105 hcs_$get_uid_file 000070 constant entry external dcl 211 ref 2553 2560 header based structure level 2 dcl 672 i 001556 automatic fixed bin(17,0) dcl 2595 set ref 2602* idx 001420 automatic fixed bin(17,0) dcl 2939 in procedure "select_scratch_segment" set ref 2943* 2944* 2965* 2966 2966* 2976* 2977 2979 idx 000102 automatic fixed bin(17,0) dcl 2998 in procedure "release_scratch_segments" set ref 3000* 3001* idx 000105 automatic fixed bin(17,0) dcl 3083 in procedure "validate_request_language" set ref 3105* 3106 3115 3117 3119* idx 000143 automatic fixed bin(21,0) dcl 891 in procedure "make_list" set ref 1193* 1194 1201 1202 ignore_code 000115 automatic fixed bin(35,0) dcl 148 set ref 773* 850* 1356* 1416* 1600* 1616* 2180* 2421* 2521* 2552* 2559* 2638* 2691* 2891* 2893* 2897* 2898* 3004* 3014* index builtin function dcl 220 ref 1193 input_atd parameter char dcl 2673 in procedure "attach_output" set ref 2670 2684* 2684 2692* input_atd parameter char dcl 2619 in procedure "attach_input" set ref 2616 2630 2632* 2632 2638* 2638* 2652 2658 2660 input_atd parameter char dcl 2728 in procedure "build_pipe_return_string" set ref 2725 2733* input_ptr parameter pointer dcl 2620 in procedure "attach_input" set ref 2616 2628* 2638* 2647* 2656* input_ptr 62 based pointer level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" set ref 2458* 2733* 2736* 2739* 2756* 2768* input_ptr 62 based pointer level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1009* input_ptr 62 based pointer level 2 in structure "pipe_control" dcl 2886 in procedure "process_pipe_cleanup" set ref 2890 2891* 2893* io_module_attach_entry 000162 automatic char(200) packed unaligned dcl 2793 set ref 2825* 2829 2829 2829 2829 iter_begin based structure level 1 dcl 606 iter_count 000674 automatic fixed bin(17,0) dcl 725 in procedure "complex_command_processor" set ref 798* 828* 829 831 839 iter_count 000137 automatic fixed bin(17,0) dcl 890 in procedure "make_list" set ref 1502* 1511 1516 1553 iter_end based structure level 1 dcl 616 iter_index 000140 automatic fixed bin(17,0) dcl 890 in procedure "make_list" set ref 1511* 1517 1553* iter_index 000675 automatic fixed bin(17,0) dcl 725 in procedure "complex_command_processor" set ref 799* 829* 832 839* iter_level 000677 automatic fixed bin(17,0) dcl 734 set ref 797* 1273* 1273 1309* 1309 1310 1337 1338* 1563* 1727* 1968* 1971 1978* 1978 1993 2022 2037 2042 2045* 2045 2052* 2054 2063 language_info 2 based structure level 2 dcl 5-17 last_block_ptr 000162 automatic pointer dcl 696 set ref 1659* 1665 3037* 3038 3039 3041 3042* 3044 last_np 000664 automatic pointer dcl 722 set ref 806* 812* 975 1149 1163 1299 1299 1303 1303 1310 1311 1312 1489 1492* 1493 1553 1556 1569 1570 1672 1675 1676* lbound builtin function dcl 220 ref 3105 length builtin function dcl 220 ref 318 343 992 1021 1022 1040 1042 1079 1348 1522 1533 1533 1546 1546 1590 1638 1688 1690 2118 2156 2156 2330 2812 2812 2829 2829 2861 2861 level 5 based fixed bin(21,0) level 2 in structure "af" dcl 626 in procedure "complex_command_processor" set ref 1337* 1563 level 5 based fixed bin(21,0) level 2 in structure "iter_end" dcl 616 in procedure "complex_command_processor" set ref 1310* 1810 2052 line based char packed unaligned dcl 426 in procedure "simple_command_processor" set ref 483 489 500 514 519 line based char packed unaligned dcl 140 in procedure "command_processor_" ref 343 344 366 line based char packed unaligned dcl 876 in procedure "make_list" ref 921 924 924 928 930 930 992 1040 1059 1193 1203 1220 1224 1348 line_len 000100 automatic fixed bin(21,0) dcl 590 in procedure "complex_command_processor" set ref 758* 822* line_len 000102 automatic fixed bin(21,0) dcl 873 in procedure "make_list" set ref 901* 919 921 924 924 928 930 930 935 940 992 1040 1059 1067 1067 1172 1193 1203 1203 1220 1220 1224 1224 1228 1237 1245 1348 line_len 000102 automatic fixed bin(21,0) dcl 142 in procedure "command_processor_" set ref 257* 318* 343* 343 344 366 385* 391* line_lth 000302 automatic fixed bin(21,0) dcl 427 set ref 468* 473 483 485 489 500 509 514 516 519 line_ptr 000102 automatic pointer dcl 591 in procedure "complex_command_processor" set ref 757* 822* line_ptr 000100 automatic pointer dcl 872 in procedure "make_list" set ref 900* 921 924 924 928 930 930 938 947 955 992 1020 1040 1059 1062 1066 1104 1154 1168 1173 1188 1193 1200 1203 1217 1220 1224 1256 1348 1453 line_ptr 000100 automatic pointer dcl 141 in procedure "command_processor_" set ref 256* 316* 343 344 366 385* 391* line_ptr 000304 automatic pointer dcl 428 in procedure "simple_command_processor" set ref 467* 483 489 500 514 519 local_temporary_scratch_segment_list 000106 automatic structure level 1 dcl 679 set ref 2918 2972 3017 lock 2 based bit(36) level 2 in structure "permanent_scratch_segment" dcl 2995 in procedure "release_scratch_segments" ref 3002 3008 lock 2 based bit(36) level 2 in structure "permanent_scratch_segment" dcl 2935 in procedure "select_scratch_segment" ref 2945 low builtin function dcl 220 ref 1222 1226 lss_on 000123 automatic bit(1) dcl 161 set ref 283* 295* 308* 356* 543 984 2254 ltrim builtin function dcl 220 ref 1079 2425 2425 2599 2600 2605 2632 2684 2685 2770 2770 2806 2825 make_list_depth 000676 automatic fixed bin(17,0) dcl 733 set ref 800* 899* 899 906 1383 1463 1474* 1474 1577 match_word1 001107 automatic varying char(32) dcl 2499 set ref 2521* 2524* 2542 2548 2549* 2552 2573* 2576 match_word2 001120 automatic varying char(32) dcl 2499 set ref 2532* 2535* 2542 2550* 2559 2574* 2576 max builtin function dcl 220 ref 269 309 2176 maxlength builtin function dcl 220 ref 2156 2861 min builtin function dcl 220 ref 270 310 mod builtin function dcl 220 ref 3003 multics_cp 000116 automatic bit(1) dcl 152 set ref 253* 266* 280* 292* 305* 326 356 376 386 393 542 2122 2253 2804 n_allocated based fixed bin(17,0) level 3 dcl 672 set ref 2919* 2922 2956 2957 2959* 2963 2972 3014 3018 n_arguments 000556 automatic fixed bin(17,0) dcl 458 set ref 479* 494* 494 495 500 501 501 502 504 524 533 535 535 535 537 n_scratch_segments based fixed bin(17,0) level 2 dcl 2-20 ref 2943 3000 n_used 1 based fixed bin(17,0) level 3 dcl 672 set ref 2921* 2956 2961* 2961 2965 2976 2976* 3012 3016* name 000142 automatic structure level 2 in structure "arg_list" dcl 1902 in procedure "produce_argument_list" name 202 000306 automatic structure level 2 in structure "arg_list" dcl 433 in procedure "simple_command_processor" set ref 537 need_space 000102 automatic bit(1) dcl 1791 set ref 1800* 1806 1814* 1817* 1827* 1848* needed_space 000121 automatic fixed bin(21,0) dcl 1887 set ref 2176* 2177 2178 2180* 2186 new_first_node 000126 automatic pointer dcl 887 in procedure "make_list" set ref 1502* 1553 1560 new_first_node 000670 automatic pointer dcl 723 in procedure "complex_command_processor" set ref 828* 839 843 new_subsystem_call 000120 automatic bit(1) dcl 154 set ref 254* 267* 281* 293* 306* 326 359 397 553 2274 new_temporary_scratch_segment_list_ptr 001414 automatic pointer dcl 2937 set ref 2959* 2961 2963 2966 2971 next 454 based pointer level 2 in structure "node_block" dcl 692 in procedure "complex_command_processor" set ref 765* 1664* 1665* 3037 3039 3043 3047* 3052* next based pointer level 2 in structure "af" packed packed unaligned dcl 626 in procedure "complex_command_processor" ref 1424 next based pointer level 2 in structure "iter_end" packed packed unaligned dcl 616 in procedure "complex_command_processor" ref 1818 2026 next based pointer level 2 in structure "atom" packed packed unaligned dcl 596 in procedure "complex_command_processor" ref 1755 1758 1963 2017 2017 2020 2022 2022 2026 next based pointer level 2 in structure "node" packed packed unaligned dcl 639 in procedure "complex_command_processor" set ref 1493* 1498 1671* 1675* 1741 1749 1750* 1797 1808 1824 1828 1971 2075 2080 2085 3054* next based pointer level 2 in structure "iter_begin" packed packed unaligned dcl 606 in procedure "complex_command_processor" set ref 1980 2017* 2022* 2026* next 000133 automatic pointer level 2 in structure "dummy_node" packed packed unaligned dcl 689 in procedure "complex_command_processor" set ref 807* 825 next_character 000133 automatic char(1) packed unaligned dcl 888 set ref 1220* 1222* 1228 1237* 1237* 1241* 1245* 1245* 1249* next_next_character 000134 automatic char(1) packed unaligned dcl 888 set ref 1224* 1226* 1228* 1228* 1233* next_pipe based char dcl 896 in procedure "make_list" ref 1079 next_pipe based char dcl 2307 in procedure "process_pipe" set ref 2409 2425 2425 2462 2467* next_pipe_len 60 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1008* 1059* 1061 1063* 1063 1067* 1069* 1079 1107* 1456* next_pipe_len 60 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2409 2425 2425 2462 2467 2467 next_pipe_ptr 56 based pointer level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1007* 1062* 1066* 1079 1106* 1455* next_pipe_ptr 56 based pointer level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2394 2409 2425 2425 2461 2462 2467 next_start 000560 automatic fixed bin(21,0) dcl 460 set ref 514* 515 516* 519 520 niters 2 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 1484 in procedure "process_active_function" set ref 1517* niters 2 based fixed bin(17,0) level 2 in structure "command_pipe_control" dcl 737 in procedure "complex_command_processor" set ref 832* niters 2 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2400 2428 2475 niters 2 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 2886 in procedure "process_pipe_cleanup" ref 2891 node based structure level 1 dcl 639 node_block based structure level 1 dcl 692 set ref 764* 1661 1663* 3041 3044 3051* node_index 000164 automatic fixed bin(5,0) dcl 698 set ref 766* 1655* 1655 1656 1666* 1669 3053* non_standard_language 2 based bit(1) level 3 dcl 5-17 set ref 337 3092 3098* nonvarying_return_string based char packed unaligned dcl 1486 set ref 1533* 1546* np 000114 automatic pointer dcl 884 set ref 937 938 939 946 947 948 1153 1154 1155 1156 1167 1168 1169 1170 1174 1174 1199 1200 1201 1205 1205 1255 1256 1257 1268 1269 1270 1272 1305 1306 1325 1326 1327 1329 1330 1331 1333 1335 1337 1611 1612 1636 1637 1638 1669* 1671 1672 1673 1675 1676 null builtin function dcl 220 ref 326 331 331 756 765 772 777 802 807 815 825 830 839 848 854 904 909 911 993 1003 1005 1007 1009 1010 1024 1100 1106 1111 1120 1284 1348 1355 1363 1365 1378 1398 1404 1420 1421 1424 1424 1430 1432 1449 1455 1461 1493 1498 1507 1512 1512 1512 1520 1520 1522 1522 1553 1569 1594 1599 1603 1615 1619 1664 1671 1673 1692 1716 1719 1720 1721 1741 1741 1750 1752 1755 1799 1808 1824 1938 1940 1944 2120 2126 2182 2236 2260 2325 2343 2379 2394 2421 2421 2461 2521 2521 2628 2638 2638 2682 2691 2691 2700 2802 2890 2896 2922 2941 2943 2946 2955 2963 3012 3019 3038 3039 3047 3052 3054 null_cl 000121 automatic bit(1) dcl 156 set ref 345* 346 353* 400 1653* null_iter 000107 automatic bit(1) dcl 1879 set ref 1984* 1990* 2065 2071 2078 object based char packed unaligned dcl 1891 ref 2159 2865 object_lth 000134 automatic fixed bin(21,0) dcl 1893 set ref 2154* 2156 2159 2859* 2861 2865 object_ptr 000132 automatic pointer dcl 1892 set ref 2151* 2153* 2159 2856* 2858* 2865 old_execute_request 000110 automatic entry variable dcl 145 set ref 361* 562 2281 old_temporary_scratch_segment_list_ptr 001412 automatic pointer dcl 2937 set ref 2958* 2961 2965 2966 2972 2972 output_atd parameter char dcl 2674 set ref 2670 2685* 2685 2691* 2692* 2695* 2708 2714 output_ptr 64 based pointer level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1010* output_ptr 64 based pointer level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" set ref 2464* 2467* 2764* 2768* output_ptr parameter pointer dcl 2675 in procedure "attach_output" set ref 2670 2682* 2695* 2700 2704* 2712* output_ptr 64 based pointer level 2 in structure "pipe_control" dcl 2886 in procedure "process_pipe_cleanup" set ref 2896 2897* 2898* p 000100 automatic pointer dcl 1710 in procedure "match_iters" set ref 1718* 1719 1721 1723 1725 1727 1741 1741 1741 1747 1749 1750 1752* 1755 1755 1757 1758* 1758 1795* 1797* 1797 1799 1807 1808 1808 1809 1810 1817 1818* 1818 1821 1822 1824 1824 1827 1828* 1828 1830 1840 p 000102 automatic pointer dcl 1876 in procedure "produce_argument_list" set ref 1942* 1944 1946 1947 1948 1949 1961 1963* 1963 1969 1971* 1971 1974 1979 1980 1980 1991 1992 1993 2011 2017 2017 2020 2022 2022 2026 2039* 2043 2046 2047* 2051 2052 2053 2054 2065 2075* 2075 2078 2080* 2080* 2085* p_arg_count parameter fixed bin(17,0) dcl 1871 in procedure "produce_argument_list" ref 1866 1900 1902 1902 1914 1920 1930 2106 2107 2107 2108 2110 p_arg_count parameter fixed bin(17,0) dcl 1708 in procedure "match_iters" set ref 1703 1715* 1740* 1740 1757* 1757 1762 1766* 1766 p_character parameter char(1) packed unaligned dcl 964 ref 961 966 968 p_code parameter fixed bin(35,0) dcl 3077 set ref 3073 3088* 3093* 3099* 3111* 3132* 3134* 3136* p_command_entry_ptr parameter pointer dcl 2788 set ref 2785 2802* 2815* p_command_type parameter bit(1) dcl 1707 in procedure "match_iters" ref 1703 1766 p_command_type parameter bit(1) dcl 1870 in procedure "produce_argument_list" ref 1866 1920 1930 2094 2104 2123 2126 p_complex_line parameter bit(1) dcl 420 set ref 411 497* p_cp_subsys_info_ptr parameter pointer dcl 3076 ref 3073 3085 p_final_level parameter fixed bin(17,0) dcl 1789 set ref 1785 1794* 1798 1810* 1811 1813* 1822 1832 1840 1840* p_first_call parameter bit(1) dcl 2910 ref 2907 2912 p_first_node parameter pointer dcl 1706 in procedure "match_iters" ref 1703 1718 p_first_node parameter pointer dcl 1869 in procedure "produce_argument_list" ref 1866 1920 1930 1942 p_initial_p parameter pointer dcl 1788 ref 1785 1795 p_iter_count parameter fixed bin(17,0) dcl 1708 set ref 1703 1715* 1732* 1734 1762* 1771* p_iteration_count parameter fixed bin(17,0) dcl 1789 set ref 1785 1793* 1835 1837* 1855* 1855 p_last_call parameter bit(1) dcl 2993 in procedure "release_scratch_segments" ref 2990 3023 p_last_call parameter bit(1) dcl 3035 in procedure "free_nodes" ref 3032 3047 p_line_len parameter fixed bin(21,0) dcl 868 in procedure "make_list" ref 864 901 p_line_len parameter fixed bin(21,0) dcl 584 in procedure "complex_command_processor" ref 577 758 p_line_lth parameter fixed bin(21,0) dcl 418 ref 411 468 p_line_ptr parameter pointer dcl 417 in procedure "simple_command_processor" ref 411 467 p_line_ptr parameter pointer dcl 867 in procedure "make_list" ref 864 900 p_line_ptr parameter pointer dcl 583 in procedure "complex_command_processor" ref 577 757 p_new_first_node parameter pointer dcl 1706 set ref 1703 1716* 1749* p_parent_level parameter fixed bin(17,0) dcl 1789 ref 1785 1794 1798 1811 1813 1822 1832 p_pipe_control_ptr parameter pointer dcl 2884 in procedure "process_pipe_cleanup" ref 2881 2890 2891 2891 2891 2893 2896 2897 2898 p_pipe_control_ptr parameter pointer dcl 2295 in procedure "process_pipe" set ref 2292 2324 2473* 2661* 2715* 2742* 2777* p_pipe_control_ptr parameter pointer dcl 870 in procedure "make_list" set ref 864 993 995* 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1013 1013 1018 1018 1019 1019 1020 1021 1030 1030 1031 1031 1033 1033 1039 1041 1059 1061 1062 1063 1063 1066 1067 1069 1078 1079 1079 1079 1082 1093* 1100 1101 1102 1102 1103 1103 1104 1105 1106 1107 1120 1120 1132* 1348 1350 1355 1356 1356 1356 1356 1358 1362* 1365* 1398 1404 1405 1405 1416 1416 1416 1416 1418 1419* 1421 1430 1431* 1437* 1449 1450 1451 1451 1452 1452 1453 1454 1455 1456 1463* 1522 1603* p_pipe_control_ptr parameter pointer dcl 1872 in procedure "produce_argument_list" set ref 1920 1930 2126 2133* 2135* p_start parameter fixed bin(21,0) dcl 868 in procedure "make_list" set ref 864 903 1472* p_start parameter fixed bin(21,0) dcl 585 in procedure "complex_command_processor" ref 577 759 p_start parameter fixed bin(21,0) dcl 419 in procedure "simple_command_processor" set ref 411 469 496* p_token_breaks_sw parameter bit(1) dcl 869 ref 864 902 pad 1(19) 000142 automatic bit(17) initial level 2 packed packed unaligned dcl 1902 set ref 1902* parent 2 based pointer level 2 in structure "iter_begin" packed packed unaligned dcl 606 in procedure "complex_command_processor" set ref 1269* 1313 1809 2026 2053 parent 2 000145 automatic pointer level 2 in structure "dummy_af_node" packed packed unaligned dcl 690 in procedure "complex_command_processor" set ref 815* parent 2 based pointer level 2 in structure "iter_end" packed packed unaligned dcl 616 in procedure "complex_command_processor" set ref 1311* 1809 2022 2053 parent 2 based pointer level 2 in structure "af" packed packed unaligned dcl 626 in procedure "complex_command_processor" set ref 1326* 1491 permanent_scratch_segment based structure level 1 dcl 2935 in procedure "select_scratch_segment" permanent_scratch_segment based structure level 1 dcl 2995 in procedure "release_scratch_segments" permanent_scratch_segment_list based structure level 1 dcl 2-20 permanent_scratch_segment_list_ptr 000252 automatic pointer dcl 2-28 set ref 2913* 2943 2944 3000 3001 permanent_scratch_segment_ptr 000100 automatic pointer dcl 2997 in procedure "release_scratch_segments" set ref 3001* 3002 3003 3004 3006 3008 permanent_scratch_segment_ptr 001410 automatic pointer dcl 2937 in procedure "select_scratch_segment" set ref 2944* 2945 2946 2947 2950 2950 2951 pipe_$attach_pipe 000124 constant entry external dcl 2317 ref 2638 2647 2695 2704 pipe_$close_pipe 000136 constant entry external dcl 2887 ref 2891 2897 pipe_$copy 000122 constant entry external dcl 2317 ref 2768 pipe_$detach_pipe 000140 constant entry external dcl 2887 ref 2893 2898 pipe_$get_return_string 000132 constant entry external dcl 2317 ref 2736 pipe_$get_return_string_nnl 000130 constant entry external dcl 2317 ref 2739 pipe_$initiate 000120 constant entry external dcl 2317 ref 2701 pipe_$open_pipe 000126 constant entry external dcl 2317 ref 2656 2712 pipe_$terminate 000072 constant entry external dcl 212 ref 773 850 1356 1416 1600 1616 pipe_control based structure level 1 dcl 894 in procedure "make_list" set ref 995 1358 1418 pipe_control based structure level 1 dcl 2301 in procedure "process_pipe" pipe_control based structure level 1 dcl 1484 in procedure "process_active_function" pipe_control based structure level 1 dcl 2886 in procedure "process_pipe_cleanup" pipe_control based structure level 1 dcl 1587 in procedure "evaluate_af_result" set ref 1602 1618 pipe_control_ptr parameter pointer dcl 1483 in procedure "process_active_function" set ref 1480 1507 1507 1512 1514 1516 1517 1518* 1569 1570 pipe_control_ptr 000100 automatic pointer dcl 1586 in procedure "evaluate_af_result" set ref 1594* 1599 1600 1600 1600 1600 1602 1607* 1614* 1615 1616 1616 1616 1616 1618 1619* pipe_control_ptr 000250 automatic pointer dcl 2300 in procedure "process_pipe" set ref 2324* 2328 2342 2343 2379 2380 2380 2380 2387 2394 2399 2400 2400 2409 2409 2421 2421 2421 2425 2425 2425 2425 2428 2428 2435 2436 2436 2437 2458 2458 2458 2458 2461 2462 2462 2464 2464 2464 2464 2467 2467 2467 2467 2467 2467 2467 2475 2475 2478 2478 2482 2483 2483 2484 2642 2647 2701 2701 2701 2704 2733 2736 2736 2739 2756 2764 2768 2768 pipe_element parameter char dcl 2788 set ref 2785 2806* 2806 2808 2811 2812 2812 2812 2812 2819 2819 2825 pipe_input_path 7 based char(58) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" set ref 2435 2436* 2482 2483* 2642 2647* pipe_input_path 7 based char(58) level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1001* 1356 1356 1416 1416 pipe_input_path 7 based char(58) level 2 in structure "pipe_control" dcl 1587 in procedure "evaluate_af_result" set ref 1600 1600 1616 1616 pipe_input_path 7 based char(58) level 2 in structure "command_pipe_control" dcl 737 in procedure "complex_command_processor" set ref 773 773 850 850 pipe_line_pos 000104 automatic fixed bin(21,0) dcl 873 set ref 917* 1020 1021 1091* 1104 1105 1130* 1453 1454 pipe_output_path 26 based char(58) level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1002* 1356 1356 1416 1416 pipe_output_path 26 based char(58) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" set ref 2387* 2436 2437* 2478* 2483 2484* 2701 2701 2701 2704* pipe_output_path 26 based char(58) level 2 in structure "pipe_control" dcl 1587 in procedure "evaluate_af_result" set ref 1600 1600 1616 1616 pipe_output_path 26 based char(58) level 2 in structure "command_pipe_control" dcl 737 in procedure "complex_command_processor" set ref 773 773 850 850 pipe_return_string_len parameter fixed bin(21,0) dcl 2728 set ref 2725 2736* 2739* pipe_return_string_ptr parameter pointer dcl 2728 set ref 2725 2736* 2739* pipeout_file_path 000656 automatic char(168) dcl 2309 set ref 2410* 2411* 2463* 2464* pp 000112 automatic pointer dcl 884 in procedure "make_list" set ref 907* 911* 1024 1024 1111 1111 1269 1272* 1284 1289 1294 1306 1311 1312 1313* 1313 1326 1335* 1378 1383 1388 1393 1424 1461 1463 1466 1490 1491* pp 000104 automatic pointer dcl 1876 in procedure "produce_argument_list" set ref 1969* 1979* 1993 2017 2026 2039 2046* 2047 2053* pp 000102 automatic pointer dcl 1710 in procedure "match_iters" set ref 1720* 1725* 1809* prev 1 000145 automatic pointer level 2 in structure "dummy_af_node" packed packed unaligned dcl 690 in procedure "complex_command_processor" set ref 814* prev 1 based pointer level 2 in structure "af" packed packed unaligned dcl 626 in procedure "complex_command_processor" ref 1492 previous_pipe based char dcl 2308 set ref 2380* 2458* 2464* 2467* previous_pipe_len 50 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1004* 1019* 1103* 1452* previous_pipe_len 50 based fixed bin(17,0) level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2380 2380 2458 2458 2464 2464 2467 2467 previous_pipe_ptr 46 based pointer level 2 in structure "pipe_control" dcl 2301 in procedure "process_pipe" ref 2379 2380 2458 2464 2467 previous_pipe_ptr 46 based pointer level 2 in structure "pipe_control" dcl 894 in procedure "make_list" set ref 1003* 1018* 1102* 1451* processing_type 000104 automatic fixed bin(17,0) dcl 3083 in procedure "validate_request_language" set ref 3106* 3108 3108 3108 3108 3115 3115 3115 3117 3121 3121 3121 3123 3123 3123 3126 3126 3126 3128 3128 3128 processing_type 000120 automatic fixed bin(9,0) dcl 885 in procedure "make_list" set ref 955* 956 1173* 1174 1233* 1241* 1249* 1270 1294 1327 1393 1573* rank builtin function dcl 220 ref 966 968 read_list_entry 000100 automatic bit(1) dcl 1874 set ref 1923* 1933* 2090 reading_command_name 000554 automatic bit(1) dcl 455 set ref 477* 488 491* release_temp_segment_ 000074 constant entry external dcl 213 ref 3004 release_temp_segments_ 000076 constant entry external dcl 214 ref 3014 request_abort_ 000244 stack reference condition dcl 218 ref 381 388 2123 rethreaded 000110 automatic bit(1) dcl 1880 set ref 1967* 1976 1976* 1985* 2013 2015* 2030* return_len 000654 automatic fixed bin(21,0) dcl 711 set ref 1688* 1688 1690 2110 2238* 2241 2358* 2360* return_ptr 000652 automatic pointer dcl 710 set ref 802* 1404 1424 1522 1522 1522 1528 1533 1533 1533 1542 1546 1546 1546 1589 1590 1637 1638 1688 1690* 1690 1690 1692* 2106 2236 2237* 2241 2343* 2358* 2360* return_string based varying char dcl 709 set ref 1522 1522 1528 1533 1533 1533 1542 1546 1546 1546 1590 1638 1688 1690 2106 2241* rtrim builtin function dcl 220 ref 343 2410 2463 2652 2825 2825 2825 saved_level 000111 automatic fixed bin(17,0) dcl 1881 set ref 2037* 2063 saved_start 000553 automatic fixed bin(21,0) dcl 453 set ref 475* 496 scratch_lock_id 000104 automatic bit(36) dcl 670 set ref 2915* 2945 3002 3008 scratch_segments 2 based structure array level 2 dcl 2-20 set ref 2944 3001 search builtin function dcl 220 ref 366 483 519 921 928 1030 1059 1528 1542 2808 2811 segment_ptr 001416 automatic pointer dcl 2937 in procedure "select_scratch_segment" set ref 2941* 2943 2951* 2955 2979* 2982 segment_ptr based pointer level 2 in structure "permanent_scratch_segment" dcl 2935 in procedure "select_scratch_segment" set ref 2946 2947* 2951 segment_ptr based pointer level 2 in structure "permanent_scratch_segment" dcl 2995 in procedure "release_scratch_segments" set ref 3004* segment_ptrs 2 based pointer array level 2 in structure "temporary_scratch_segment_list" dcl 672 in procedure "complex_command_processor" set ref 2922* 2963* 2966* 2966 2977* 2979 3014* segment_ptrs 2 000106 automatic pointer array level 2 in structure "local_temporary_scratch_segment_list" dcl 679 in procedure "complex_command_processor" set ref 2919 semicolon_in_af 000111 automatic bit(1) dcl 882 set ref 908* 1092* 1131* 1435* 1565 1566* size 0(12) 000513 automatic fixed bin(24,0) array level 2 in structure "descriptors" packed packed unsigned unaligned dcl 445 in procedure "simple_command_processor" set ref 504* size 0(12) 000142 automatic fixed bin(24,0) array level 2 in structure "descriptor" packed packed unsigned unaligned dcl 1914 in procedure "produce_argument_list" set ref 2101* 2110* space 6 based bit(1) level 3 in structure "node" dcl 639 in procedure "complex_command_processor" set ref 975* 1149* 1163* 1299* 1303* 1489* 1553* 1556* 1569* 1570* 1757 1808* 1824* 1827 space 6 based bit(1) level 3 in structure "atom" dcl 596 in procedure "complex_command_processor" set ref 1156* 1170* 1612* 1741* 1755* 1822 1949 1961 1993 2011 2078 space 6 based bit(1) level 3 in structure "iter_end" dcl 616 in procedure "complex_command_processor" ref 1817 1993 2020 2054 2065 space_ptr 000126 automatic pointer dcl 1888 set ref 1938* 2182 2183* 2184 2191* 2194 2197 stack_ptr 000124 automatic pointer dcl 1888 set ref 2180* 2183 stack_space 000166 automatic structure level 1 dcl 700 set ref 763 3037 3047 3050 stacq builtin function dcl 220 ref 2945 3008 start 000303 automatic fixed bin(21,0) dcl 427 in procedure "simple_command_processor" set ref 469* 473 475 483 485 489 500 507* 507 509 514 516 519 520* 520 start 000133 automatic fixed bin(21,0) dcl 170 in procedure "command_processor_" set ref 344* 345 352* 366 385* 391* start 000103 automatic fixed bin(21,0) dcl 873 in procedure "make_list" set ref 903* 917 919 921 924 924 928 930 930 935 938 940* 947 949* 949 955 992 1021 1022* 1022 1040 1042* 1042 1059 1062 1066 1067 1067 1090* 1090 1091 1105 1109* 1109 1111 1129* 1129 1130 1154 1168 1172 1173 1177* 1177 1180* 1180 1188 1193 1200 1202* 1202 1203 1203 1206* 1206 1217 1220 1220 1224 1224 1228 1232* 1232 1237 1240* 1240 1245 1248* 1248 1256 1348 1441* 1441 1454 1459* 1472 start 000101 automatic fixed bin(21,0) dcl 590 in procedure "complex_command_processor" set ref 759* 795 822* 845 846 start_arg 000106 automatic bit(1) dcl 1878 set ref 1939* 1949 1957* 1976 1983* 1993 2007* 2054 2193 2203* 2224* string_len 5 based fixed bin(21,0) level 2 dcl 596 set ref 939* 948* 1155* 1169* 1174* 1174 1201* 1205* 1205 1257* 1638* 1948 1992 string_ptr 2 based pointer level 2 packed packed unaligned dcl 596 set ref 938* 947* 1154* 1168* 1200* 1256* 1637* 1947 1991 sub_count 000100 automatic fixed bin(17,0) dcl 1790 set ref 1805* 1822* 1822 1835* 1835 1842* 1846 1855 sub_err_ 000100 constant entry external dcl 215 ref 331 substr builtin function dcl 220 set ref 366 483 489 500 514 519 921 924 924 928 930 930 992 1040 1059 1079 1193 1203 1220 1224 1348 2194* 2201* 2218 2330 3121* 3123* 3126* 3128* suffix 000136 automatic varying char(1) dcl 1894 set ref 2147* 2149* 2156 2161 2852* 2854* 2861 2867 sv_pipe_control_ptr 000144 automatic pointer dcl 893 set ref 904* 1350* 1362 1363* 1419 1420* 1431 1432* sv_pipe_path 000730 automatic char(58) packed unaligned dcl 2310 set ref 2435* 2437 2482* 2484 sys_info$max_seg_size 000040 external static fixed bin(19,0) dcl 198 ref 2192 2238 system_area based area(1024) dcl 702 ref 776 853 995 1358 1418 1602 1618 1661 2959 2972 3018 3041 3044 system_area_ptr 000644 automatic pointer dcl 703 set ref 761* 776 853 995 1358 1418 1602 1618 1661 2959 2972 3018 3041 3044 tag 0(18) 000306 automatic bit(18) initial level 2 in structure "arg_list" packed packed unaligned dcl 433 in procedure "simple_command_processor" set ref 433* tag 0(18) 000142 automatic bit(18) initial level 2 in structure "arg_list" packed packed unaligned dcl 1902 in procedure "produce_argument_list" set ref 1902* temp_count 000101 automatic fixed bin(17,0) dcl 1790 set ref 1840* 1842 1846 temporary_scratch_segment_list based structure level 1 dcl 672 set ref 2959 2972 3018 temporary_scratch_segment_list_n_allocated 000132 automatic fixed bin(17,0) dcl 684 set ref 2957* 2959 2959 temporary_scratch_segment_list_ptr 000130 automatic pointer dcl 683 set ref 2918* 2919 2921 2922 2956 2956 2957 2958 2971* 2976 2976 2977 2979 3012 3012 3014 3016 3017 3018 3019* the_character 000132 automatic char(1) packed unaligned dcl 888 set ref 1188* 1193 1203 1217* 1228 token_breaks_sw 000105 automatic bit(1) dcl 874 set ref 902* 921 966 1142 token_language based structure level 1 dcl 716 in procedure "complex_command_processor" token_language based structure level 1 dcl 3080 in procedure "validate_request_language" token_language_ptr 000660 automatic pointer dcl 717 set ref 784* 788* 966 token_lth 000557 automatic fixed bin(21,0) dcl 460 set ref 483* 485 485* 490 504 507 tokens_only_tct_table 203 based char(512) level 3 dcl 5-17 set ref 788 924* 1546* 3115 3117 3119 tokens_sw 10 000145 automatic bit(1) level 3 in structure "dummy_af_node" dcl 690 in procedure "complex_command_processor" set ref 816* tokens_sw 10 based bit(1) level 3 in structure "af" dcl 626 in procedure "complex_command_processor" set ref 1330* 1528 1568 1607* 1614* top_level_pp 000116 automatic pointer dcl 884 set ref 907* 1333 1333* 1383 1463 1577 top_level_string_type 000132 automatic fixed bin(17,0) dcl 168 set ref 269* 270* 270 309* 310* 310 816 818 transform_command_ 000102 constant entry external dcl 216 ref 544 2255 twice_n_arguments 000306 automatic fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 433 set ref 524* twice_n_descriptors 1 000306 automatic fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 433 set ref 524* twice_no_of_args 000142 automatic fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1902 set ref 2094* 2096* twice_no_of_descriptors 1 000142 automatic fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1902 set ref 2094* 2096* type 3 based fixed bin(17,0) level 2 in structure "iter_begin" dcl 606 in procedure "complex_command_processor" set ref 1268* type 3 000145 automatic fixed bin(17,0) level 2 in structure "dummy_af_node" dcl 690 in procedure "complex_command_processor" set ref 813* type 3 000133 automatic fixed bin(17,0) level 2 in structure "dummy_node" dcl 689 in procedure "complex_command_processor" set ref 808* type 3 based fixed bin(17,0) level 2 in structure "atom" dcl 596 in procedure "complex_command_processor" set ref 937* 946* 1153* 1167* 1199* 1255* 1636* type 3 based fixed bin(17,0) level 2 in structure "af" dcl 626 in procedure "complex_command_processor" set ref 1325* type 3 based fixed bin(17,0) level 2 in structure "node" dcl 639 in procedure "complex_command_processor" set ref 1024 1111 1289 1299 1303 1305* 1388 1466 1611* 1723 1747 1807 1821 1830 1946 1974 2017 2043 2051 uid1 001133 automatic bit(36) dcl 2499 set ref 2553* 2556* 2566 uid2 001134 automatic bit(36) dcl 2499 set ref 2560* 2563* 2566 unspec builtin function dcl 220 set ref 331 331 764* 805* 811* 1663* 3051* 3097 3097 usage_count 3 based fixed bin(17,0) level 2 in structure "permanent_scratch_segment" dcl 2935 in procedure "select_scratch_segment" set ref 2950* 2950 usage_count 3 based fixed bin(17,0) level 2 in structure "permanent_scratch_segment" dcl 2995 in procedure "release_scratch_segments" set ref 3003 3006* use_standard_language 000124 automatic bit(1) dcl 163 set ref 324* 337* 342 366 784 921 928 984 1528 1542 using_stack 000662 automatic bit(1) dcl 720 set ref 803* 2178 2190* verify builtin function dcl 220 ref 344 514 version based char(8) level 2 dcl 5-17 ref 330 331 331 3087 word 001545 automatic varying char(32) dcl 2594 set ref 2603* 2608 word_cnt1 001131 automatic fixed bin(17,0) dcl 2499 set ref 2510* 2524* 2525* 2525 2549* 2573* word_cnt2 001132 automatic fixed bin(17,0) dcl 2499 set ref 2511* 2535* 2536* 2536 2550* 2574* word_list parameter char dcl 2591 ref 2588 2599 2600 word_to_return parameter fixed bin(17,0) dcl 2592 ref 2588 2602 work_list 001144 automatic varying char(1024) dcl 2593 set ref 2599* 2600 2600* 2603 2604* 2604 2605* 2605 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACTION_CAN_RESTART internal static bit(36) initial dcl 6-7 ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 6-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 6-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 6-7 BEGIN_ACTIVE_STRING_2 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ACTIVE_STRING_3 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ACTIVE_STRING_4 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ACTIVE_STRING_5 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ACTIVE_STRING_6 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ACTIVE_STRING_7 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ITERATION_2 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ITERATION_3 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ITERATION_4 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ITERATION_5 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ITERATION_6 internal static fixed bin(9,0) initial unsigned dcl 3-6 BEGIN_ITERATION_7 internal static fixed bin(9,0) initial unsigned dcl 3-6 CHECK_STAR_ENTRY_DEFAULT internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_ALL internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_ARCHIVE internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_EQUAL internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_LENGTH internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_NONASCII internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_NULL internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_PATH internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_PATH_DEFAULT internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_PROCESS_ARCHIVE internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_PROCESS_ENTRYPOINT internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_UNIMPLEMENTED internal static bit(36) initial packed unaligned dcl 1-29 COMMAND_SEPARATOR internal static fixed bin(9,0) initial unsigned dcl 3-6 DEFAULT_ACTIVE_STRING internal static fixed bin(17,0) initial dcl 4-6 END_ACTIVE_STRING_2 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ACTIVE_STRING_3 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ACTIVE_STRING_4 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ACTIVE_STRING_5 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ACTIVE_STRING_6 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ACTIVE_STRING_7 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ITERATION_2 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ITERATION_3 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ITERATION_4 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ITERATION_5 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ITERATION_6 internal static fixed bin(9,0) initial unsigned dcl 3-6 END_ITERATION_7 internal static fixed bin(9,0) initial unsigned dcl 3-6 SINGLE_TOKEN internal static fixed bin(9,0) initial unsigned dcl 3-6 STAR_TYPE_MATCHES_EVERYTHING internal static fixed bin(2,0) initial dcl 1-47 STAR_TYPE_USE_MATCH_PROCEDURE internal static fixed bin(2,0) initial dcl 1-47 STAR_TYPE_USE_PL1_COMPARE internal static fixed bin(2,0) initial dcl 1-47 check_star based structure level 1 dcl 1-15 NAMES DECLARED BY EXPLICIT CONTEXT. ABORT_COMMAND_EXECUTION 002174 constant label dcl 566 ref 471 ABORT_EXECUTION 007774 constant label dcl 2167 ref 2122 2123 CONTINUE_SCAN 005023 constant label dcl 1441 ref 978 1157 1178 1212 1258 1275 1315 1368 1579 CONTINUE_SETUP 000661 constant label dcl 320 ref 258 MISMATCH 006377 constant label dcl 1735 ref 1799 1846 PROCESS_BEGIN_ACTIVE_STRING 004427 constant label dcl 1320 ref 1234 1242 1574 PROCESS_CHARACTER 000000 constant label array(48) dcl 975 ref 956 PROCESS_COMMAND_SEPARATOR 003243 constant label dcl 984 ref 1145 PROCESS_END_ACTIVE_STRING 004572 constant label dcl 1374 ref 1250 PROCESS_SEMICOLON 003613 constant label dcl 1109 ref 984 PROCESS_WHITESPACE 003236 constant label dcl 975 ref 1142 RESIGNAL_INCOMPATIBLE_SUBSYSTEM_INFO 000704 constant label dcl 331 ref 335 RETURN_FROM_CP 001230 constant label dcl 393 ref 1086 1126 1196 1286 1291 1296 1380 1385 1390 1395 1407 1412 1427 1469 1737 1852 2136 2948 2978 RETURN_FROM_MAKE_LIST 005064 constant label dcl 1461 ref 1136 1183 1577 RL_COMMON 006776 constant label dcl 1936 ref 1924 SETUP 000652 constant label dcl 316 ref 272 284 296 311 SILENTLY_RETURN_FROM_CP 001364 constant label dcl 400 ref 348 375 545 548 557 563 2130 2163 2257 2267 2277 2282 2869 atds_match 011526 constant entry internal dcl 2492 ref 2692 attach_input 012462 constant entry internal dcl 2616 ref 2458 2733 2756 attach_output 013102 constant entry internal dcl 2670 ref 2464 2467 2764 build_pipe_return_string 013542 constant entry internal dcl 2725 ref 2402 2478 command_processor_ 000412 constant entry external dcl 106 complex_command_processor 002200 constant entry internal dcl 577 ref 391 copy_thru_pipe 013651 constant entry internal dcl 2749 ref 2380 2387 2411 2425 count_iteration 006473 constant entry internal dcl 1785 ref 1727 1840 element_is_an_atd 014133 constant entry internal dcl 2785 ref 2350 2421 2521 2638 2691 end_arg 010115 constant entry internal dcl 2210 ref 1961 2054 eval_string 000441 constant entry external dcl 263 evaluate_af_result 005715 constant entry internal dcl 1583 ref 1528 1533 1542 1546 execute_command_line_ 000547 constant entry external dcl 289 free_nodes 015477 constant entry internal dcl 3032 ref 780 845 get_line 001517 constant entry external dcl 3178 get_node 006164 constant entry internal dcl 1650 ref 936 945 1152 1166 1198 1254 1267 1304 1324 1610 1635 get_type 005144 constant entry internal dcl 961 ref 955 1173 1228 1228 1233 1237 1237 1241 1245 1245 1249 get_word 012254 constant entry internal dcl 2588 ref 2524 2535 2549 2550 2573 2574 initialize_scratch_segments 014747 constant entry internal dcl 2907 ref 768 3023 make_command_line_attach 014502 constant entry internal dcl 2844 ref 2357 make_list 002673 constant entry internal dcl 864 ref 822 1607 1614 match_iters 006306 constant entry internal dcl 1703 ref 828 1502 more_arg 007312 constant label dcl 2085 ref 2065 2071 2078 non_simple_arg 007775 constant entry internal dcl 2172 ref 1960 2009 process_active_function 005206 constant entry internal dcl 1480 ref 1093 1132 1437 1463 process_attach_description 010651 constant entry internal dcl 2367 ref 2358 process_command 010170 constant entry internal dcl 2247 ref 2129 2472 process_pipe 010414 constant entry internal dcl 2292 ref 2135 process_pipe_cleanup 014623 constant entry internal dcl 2881 ref 2133 2473 2661 2715 2742 2777 process_pipe_command 011224 constant entry internal dcl 2447 ref 2360 produce_argument_list 006745 constant entry internal dcl 1866 read_list 006755 constant entry internal dcl 1920 ref 835 1512 1518 1520 release_scratch_segments 015305 constant entry internal dcl 2990 ref 781 846 reset_lss 001444 constant entry external dcl 3157 return_string_advance 006251 constant entry internal dcl 1685 ref 1591 1640 select_scratch_segment 015023 constant entry internal dcl 2932 ref 2191 2237 set_line 001457 constant entry external dcl 3167 setup_lss 001426 constant entry external dcl 3144 setup_return_string 010144 constant entry internal dcl 2233 ref 2105 2344 simple_command_processor 001560 constant entry internal dcl 411 ref 385 skip_iter 007223 constant label dcl 2037 ref 1986 subsys_eval_string 000600 constant entry external dcl 301 subsys_execute_line 000511 constant entry external dcl 277 treat_af_result_as_atom 006137 constant entry internal dcl 1632 ref 1532 1537 1539 1545 1550 validate_cp_subsys_info 001400 constant entry external dcl 3063 validate_request_language 015564 constant entry internal dcl 3073 ref 3066 write_list 006767 constant entry internal dcl 1930 ref 838 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 21276 21440 20101 21306 Length 22166 20101 142 512 1174 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME command_processor_ 474 external procedure is an external procedure. on unit on line 376 64 on unit on unit on line 381 64 on unit simple_command_processor internal procedure shares stack frame of external procedure command_processor_. complex_command_processor 488 internal procedure enables or reverts conditions, and is declared options(non_quick). on unit on line 770 77 on unit make_list 180 internal procedure enables or reverts conditions. get_type internal procedure shares stack frame of internal procedure make_list. on unit on line 1352 76 on unit process_active_function internal procedure shares stack frame of internal procedure make_list. evaluate_af_result 90 internal procedure enables or reverts conditions. on unit on line 1596 76 on unit treat_af_result_as_atom internal procedure shares stack frame of internal procedure make_list. get_node 64 internal procedure is called by several nonquick procedures. return_string_advance 65 internal procedure is called by several nonquick procedures. match_iters 84 internal procedure is called by several nonquick procedures. count_iteration 84 internal procedure calls itself recursively. produce_argument_list 1349 internal procedure uses auto adjustable storage, and enables or reverts conditions. on unit on line 2122 64 on unit on unit on line 2123 64 on unit on unit on line 2133 70 on unit non_simple_arg internal procedure shares stack frame of internal procedure produce_argument_list. end_arg internal procedure shares stack frame of internal procedure produce_argument_list. setup_return_string internal procedure shares stack frame of internal procedure produce_argument_list. process_command internal procedure shares stack frame of internal procedure produce_argument_list. process_pipe internal procedure shares stack frame of internal procedure produce_argument_list. process_attach_description internal procedure shares stack frame of internal procedure produce_argument_list. process_pipe_command internal procedure shares stack frame of internal procedure produce_argument_list. atds_match internal procedure shares stack frame of internal procedure attach_output. get_word internal procedure shares stack frame of internal procedure attach_output. attach_input 94 internal procedure is called by several nonquick procedures. attach_output 944 internal procedure is called by several nonquick procedures. build_pipe_return_string internal procedure shares stack frame of internal procedure produce_argument_list. copy_thru_pipe 111 internal procedure is called during a stack extension. element_is_an_atd 201 internal procedure is called by several nonquick procedures. make_command_line_attach internal procedure shares stack frame of internal procedure produce_argument_list. process_pipe_cleanup 74 internal procedure is called by several nonquick procedures. initialize_scratch_segments 66 internal procedure is called by several nonquick procedures. select_scratch_segment internal procedure shares stack frame of internal procedure produce_argument_list. release_scratch_segments 99 internal procedure is called by several nonquick procedures. free_nodes 64 internal procedure is called by several nonquick procedures. validate_request_language 71 internal procedure is declared options(non_quick). STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME attach_input 000100 Sdefault_to_vfile attach_input attach_output 000106 Sdefault1 atds_match 000107 full_path1 atds_match 000507 full_path2 atds_match 001107 match_word1 atds_match 001120 match_word2 atds_match 001131 word_cnt1 atds_match 001132 word_cnt2 atds_match 001133 uid1 atds_match 001134 uid2 atds_match 001144 work_list get_word 001545 word get_word 001556 i get_word 001560 Sdefault_to_vfile attach_output command_processor_ 000100 line_ptr command_processor_ 000102 line_len command_processor_ 000104 execute_request command_processor_ 000110 old_execute_request command_processor_ 000114 code command_processor_ 000115 ignore_code command_processor_ 000116 multics_cp command_processor_ 000117 evaluate_string command_processor_ 000120 new_subsystem_call command_processor_ 000121 null_cl command_processor_ 000122 complex_line command_processor_ 000123 lss_on command_processor_ 000124 use_standard_language command_processor_ 000125 executing command_processor_ 000126 abort_command_execution command_processor_ 000132 top_level_string_type command_processor_ 000133 start command_processor_ 000134 error_message command_processor_ 000252 permanent_scratch_segment_list_ptr command_processor_ 000254 cp_subsys_info_ptr command_processor_ 000302 line_lth simple_command_processor 000303 start simple_command_processor 000304 line_ptr simple_command_processor 000306 arg_list simple_command_processor 000513 descriptors simple_command_processor 000553 saved_start simple_command_processor 000554 reading_command_name simple_command_processor 000555 end_of_command simple_command_processor 000556 n_arguments simple_command_processor 000557 token_lth simple_command_processor 000560 next_start simple_command_processor 000562 command_name_ptr simple_command_processor 000564 command_name_lth simple_command_processor 000566 command_entry_ptr simple_command_processor complex_command_processor 000100 line_len complex_command_processor 000101 start complex_command_processor 000102 line_ptr complex_command_processor 000104 scratch_lock_id complex_command_processor 000106 local_temporary_scratch_segment_list complex_command_processor 000130 temporary_scratch_segment_list_ptr complex_command_processor 000132 temporary_scratch_segment_list_n_allocated complex_command_processor 000133 dummy_node complex_command_processor 000145 dummy_af_node complex_command_processor 000160 block_ptr complex_command_processor 000162 last_block_ptr complex_command_processor 000164 node_index complex_command_processor 000166 stack_space complex_command_processor 000644 system_area_ptr complex_command_processor 000646 atom_len complex_command_processor 000650 atom_ptr complex_command_processor 000652 return_ptr complex_command_processor 000654 return_len complex_command_processor 000656 full_language_ptr complex_command_processor 000660 token_language_ptr complex_command_processor 000662 using_stack complex_command_processor 000664 last_np complex_command_processor 000666 first_node complex_command_processor 000670 new_first_node complex_command_processor 000672 arg_count complex_command_processor 000673 count complex_command_processor 000674 iter_count complex_command_processor 000675 iter_index complex_command_processor 000676 make_list_depth complex_command_processor 000677 iter_level complex_command_processor 000700 command_pipe_control_ptr complex_command_processor count_iteration 000100 sub_count count_iteration 000101 temp_count count_iteration 000102 need_space count_iteration 000103 first_count count_iteration element_is_an_atd 000100 dirname element_is_an_atd 000152 entryname element_is_an_atd 000162 io_module_attach_entry element_is_an_atd 000244 command_entry_ptr element_is_an_atd evaluate_af_result 000100 pipe_control_ptr evaluate_af_result make_list 000100 line_ptr make_list 000102 line_len make_list 000103 start make_list 000104 pipe_line_pos make_list 000105 token_breaks_sw make_list 000106 af_is_atom make_list 000107 af_is_tokens make_list 000110 catenate_values make_list 000111 semicolon_in_af make_list 000112 pp make_list 000114 np make_list 000116 top_level_pp make_list 000120 processing_type make_list 000122 afp make_list 000124 first_node make_list 000126 new_first_node make_list 000130 af_line_ptr make_list 000132 the_character make_list 000133 next_character make_list 000134 next_next_character make_list 000135 continue_scan make_list 000136 arg_count make_list 000137 iter_count make_list 000140 iter_index make_list 000141 af_line_len make_list 000142 af_start make_list 000143 idx make_list 000144 sv_pipe_control_ptr make_list 000146 after_bracket_idx make_list match_iters 000100 p match_iters 000102 pp match_iters 000104 first_iter match_iters produce_argument_list 000100 read_list_entry produce_argument_list 000102 p produce_argument_list 000104 pp produce_argument_list 000106 start_arg produce_argument_list 000107 null_iter produce_argument_list 000110 rethreaded produce_argument_list 000111 saved_level produce_argument_list 000112 argument_idx produce_argument_list 000114 command_name_ptr produce_argument_list 000116 command_entry_ptr produce_argument_list 000120 extension_size produce_argument_list 000121 needed_space produce_argument_list 000122 arg_ptr produce_argument_list 000124 stack_ptr produce_argument_list 000126 space_ptr produce_argument_list 000130 arg_space produce_argument_list 000132 object_ptr produce_argument_list 000134 object_lth produce_argument_list 000136 suffix produce_argument_list 000140 current_arg_len produce_argument_list 000141 arg_len produce_argument_list 000142 arg_list produce_argument_list 000142 descriptor produce_argument_list 000240 aligned_command_name process_pipe 000250 pipe_control_ptr process_pipe 000252 Satds_match process_pipe 000253 Sdefault_curr_to_vfile process_pipe 000254 attach_description process_pipe 000654 command_entry_ptr process_pipe 000656 pipeout_file_path process_pipe 000730 sv_pipe_path process_pipe 001000 command_line_attach make_command_line_attach 001410 permanent_scratch_segment_ptr select_scratch_segment 001412 old_temporary_scratch_segment_list_ptr select_scratch_segment 001414 new_temporary_scratch_segment_list_ptr select_scratch_segment 001416 segment_ptr select_scratch_segment 001420 idx select_scratch_segment release_scratch_segments 000100 permanent_scratch_segment_ptr release_scratch_segments 000102 idx release_scratch_segments validate_request_language 000100 begin_iterations validate_request_language 000101 end_iterations validate_request_language 000102 begin_active_strings validate_request_language 000103 end_active_strings validate_request_language 000104 processing_type validate_request_language 000105 idx validate_request_language THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_l_a r_e_as r_ne_as r_le_a r_ge_a alloc_char_temp cat_realloc_chars call_ent_var_desc call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac tra_ext_1 tra_ext_2 alloc_auto_adj mdfx1 enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc set_chars_eis op_alloc_ op_freen_ index_before_cs index_after_cs stacq_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. absolute_pathname_ check_star_name_ com_err_ cu_$gen_call cu_$grow_stack_frame expand_pathname_ find_char_$first_in_table find_command_ find_command_$fc_no_message get_system_free_area_ get_temp_segment_ get_wdir_ hcs_$get_uid_file pipe_$attach_pipe pipe_$close_pipe pipe_$copy pipe_$detach_pipe pipe_$get_return_string pipe_$get_return_string_nnl pipe_$initiate pipe_$open_pipe pipe_$terminate release_temp_segment_ release_temp_segments_ sub_err_ transform_command_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cp_data_$command_table_ptr cp_data_$permanent_scratch_segment_list cp_data_$scratch_lock_id cp_data_$scratch_release_factor cp_data_$standard_language cp_data_$under_lss error_table_$bad_file_name error_table_$bad_pipe_syntax error_table_$bad_subr_arg error_table_$command_line_overflow error_table_$mismatched_iter error_table_$no_file error_table_$noentry error_table_$null_brackets error_table_$unbalanced_brackets error_table_$unbalanced_parentheses error_table_$unbalanced_quotes error_table_$unimplemented_version sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 106 000406 253 000422 254 000424 255 000425 256 000426 257 000431 258 000433 263 000434 266 000465 267 000467 268 000470 269 000471 270 000476 272 000502 277 000503 280 000535 281 000536 282 000540 283 000541 284 000542 289 000543 292 000564 293 000565 294 000566 295 000567 296 000570 301 000571 305 000633 306 000634 307 000636 308 000637 309 000640 310 000645 311 000651 316 000652 318 000654 320 000661 322 000662 324 000663 326 000665 329 000675 330 000700 331 000704 335 000765 337 000766 340 000771 342 001002 343 001004 344 001017 345 001032 346 001034 347 001035 348 001036 350 001037 352 001040 353 001042 356 001044 359 001052 361 001063 364 001071 366 001077 371 001124 373 001126 374 001127 375 001130 376 001133 379 001151 380 001157 376 001160 381 001161 383 001175 384 001203 385 001204 386 001206 388 001212 391 001213 393 001230 397 001301 398 001335 400 001364 403 001372 405 001373 3063 001374 3066 001412 3068 001422 3144 001423 3149 001433 3150 001436 3151 001442 3157 001443 3160 001451 3161 001453 3167 001454 3172 001464 3175 001514 3178 001515 3181 001524 3183 001554 3185 001557 411 001560 433 001562 467 001564 468 001567 469 001571 471 001573 473 001576 475 001601 477 001602 478 001604 479 001605 481 001606 483 001610 485 001630 488 001636 489 001640 490 001645 491 001647 492 001650 494 001651 495 001652 496 001655 497 001660 498 001662 500 001663 501 001671 502 001674 504 001677 507 001703 509 001704 514 001712 515 001731 516 001732 517 001736 518 001740 519 001741 520 001755 522 001761 524 001762 528 001772 529 001774 530 001776 533 002000 535 002003 537 002013 539 002022 542 002023 543 002025 544 002027 545 002044 547 002046 548 002063 549 002065 550 002067 551 002102 553 002103 555 002105 556 002107 557 002140 558 002142 561 002143 562 002145 563 002172 566 002174 568 002175 570 002176 577 002177 756 002205 757 002207 758 002213 759 002215 761 002217 763 002225 764 002227 765 002232 766 002234 768 002235 770 002245 772 002261 773 002266 776 002307 777 002312 780 002315 781 002326 782 002337 784 002340 787 002351 788 002354 795 002357 797 002362 798 002363 799 002364 800 002365 802 002366 803 002370 805 002372 806 002375 807 002377 808 002401 810 002403 811 002407 812 002412 813 002414 814 002416 815 002420 816 002422 818 002431 822 002435 825 002455 828 002464 829 002503 830 002513 831 002517 832 002522 835 002524 838 002545 839 002561 842 002606 843 002610 845 002613 846 002624 848 002635 850 002644 853 002664 854 002666 857 002670 859 002671 864 002672 899 002700 900 002702 901 002706 902 002710 903 002713 904 002715 906 002717 907 002726 908 002732 909 002733 910 002735 911 002736 917 002740 919 002743 921 002747 924 002776 927 003042 928 003043 930 003070 932 003133 934 003134 935 003136 936 003143 937 003147 938 003152 939 003160 940 003163 941 003166 944 003167 945 003172 946 003176 947 003201 948 003207 949 003212 950 003213 952 003214 953 003215 954 003216 955 003217 956 003235 975 003236 978 003242 984 003243 992 003251 993 003257 995 003264 996 003273 997 003274 998 003275 999 003276 1000 003277 1001 003300 1002 003303 1003 003306 1004 003310 1005 003313 1006 003314 1007 003317 1008 003320 1009 003323 1010 003324 1013 003327 1018 003332 1019 003335 1020 003341 1021 003345 1022 003353 1024 003355 1030 003365 1031 003401 1033 003403 1039 003407 1040 003411 1041 003417 1042 003420 1059 003421 1061 003444 1062 003445 1063 003451 1064 003455 1066 003456 1067 003462 1069 003472 1078 003475 1079 003501 1082 003521 1083 003523 1084 003530 1086 003535 1090 003540 1091 003542 1092 003544 1093 003546 1095 003554 1100 003555 1101 003562 1102 003566 1103 003570 1104 003574 1105 003600 1106 003606 1107 003610 1109 003613 1111 003614 1120 003626 1122 003637 1123 003642 1126 003647 1129 003652 1130 003654 1131 003656 1132 003660 1136 003666 1142 003667 1145 003671 1149 003672 1152 003676 1153 003702 1154 003705 1155 003713 1156 003715 1157 003717 1163 003720 1166 003724 1167 003730 1168 003733 1169 003741 1170 003742 1172 003744 1173 003750 1174 003765 1177 003772 1178 003774 1180 003775 1181 003776 1183 003777 1188 004000 1191 004006 1192 004010 1193 004012 1194 004027 1195 004030 1196 004035 1198 004040 1199 004044 1200 004047 1201 004053 1202 004056 1203 004060 1205 004070 1206 004071 1207 004072 1208 004073 1209 004075 1210 004076 1212 004077 1217 004100 1220 004106 1222 004116 1224 004120 1226 004133 1228 004135 1231 004165 1232 004167 1233 004171 1234 004175 1237 004176 1239 004220 1240 004222 1241 004223 1242 004227 1245 004230 1247 004252 1248 004254 1249 004255 1250 004261 1254 004262 1255 004266 1256 004271 1257 004277 1258 004301 1264 004302 1267 004303 1268 004307 1269 004312 1270 004314 1272 004316 1273 004317 1275 004321 1281 004322 1284 004323 1285 004327 1286 004334 1289 004337 1290 004343 1291 004350 1294 004353 1295 004357 1296 004364 1299 004367 1303 004376 1304 004402 1305 004406 1306 004411 1309 004413 1310 004416 1311 004421 1312 004423 1313 004424 1315 004426 1320 004427 1324 004430 1325 004434 1326 004437 1327 004441 1329 004443 1330 004445 1331 004447 1333 004450 1335 004462 1337 004463 1338 004466 1348 004467 1350 004502 1352 004505 1355 004521 1356 004527 1358 004552 1362 004556 1363 004563 1364 004565 1365 004566 1368 004571 1374 004572 1378 004573 1379 004577 1380 004604 1383 004607 1384 004623 1385 004626 1388 004631 1389 004635 1390 004641 1393 004644 1394 004650 1395 004654 1398 004657 1404 004664 1405 004674 1406 004704 1407 004710 1410 004713 1411 004717 1412 004724 1416 004727 1418 004750 1419 004753 1420 004756 1421 004760 1422 004764 1424 004765 1426 004774 1427 005000 1430 005003 1431 005010 1432 005012 1435 005014 1437 005015 1441 005023 1445 005024 1449 005025 1450 005032 1451 005036 1452 005040 1453 005044 1454 005050 1455 005056 1456 005060 1459 005063 1461 005064 1463 005070 1466 005113 1468 005125 1469 005132 1472 005135 1474 005140 1475 005143 961 005144 966 005146 968 005167 1480 005206 1489 005210 1490 005214 1491 005216 1492 005221 1493 005224 1495 005226 1498 005231 1502 005240 1507 005257 1511 005274 1512 005303 1514 005330 1516 005334 1517 005336 1518 005340 1519 005355 1520 005356 1522 005375 1528 005425 1532 005455 1533 005457 1537 005517 1539 005521 1542 005525 1545 005550 1546 005552 1550 005612 1553 005613 1556 005626 1559 005634 1560 005636 1563 005641 1565 005645 1566 005647 1567 005650 1568 005652 1569 005655 1570 005666 1573 005675 1574 005677 1577 005700 1579 005713 1583 005714 1589 005722 1590 005730 1591 005732 1593 005737 1594 005742 1596 005744 1599 005760 1600 005765 1602 006010 1603 006013 1605 006020 1607 006021 1609 006042 1610 006045 1611 006052 1612 006056 1614 006061 1615 006101 1616 006105 1618 006131 1619 006133 1621 006135 1623 006136 1632 006137 1635 006140 1636 006144 1637 006147 1638 006153 1640 006155 1642 006162 1650 006163 1653 006171 1655 006175 1656 006200 1659 006203 1661 006205 1663 006216 1664 006221 1665 006223 1666 006225 1669 006227 1671 006236 1672 006240 1673 006243 1675 006244 1676 006245 1678 006247 1685 006250 1688 006256 1690 006271 1692 006302 1694 006304 1703 006305 1714 006313 1715 006315 1716 006320 1718 006322 1719 006325 1720 006330 1721 006332 1723 006336 1725 006342 1727 006343 1730 006362 1731 006364 1732 006365 1733 006371 1734 006372 1735 006377 1737 006404 1740 006407 1741 006410 1746 006422 1747 006423 1749 006425 1750 006430 1752 006433 1753 006435 1755 006436 1757 006443 1758 006447 1760 006451 1762 006452 1766 006457 1771 006465 1774 006471 1785 006472 1793 006500 1794 006502 1795 006505 1797 006511 1798 006513 1799 006520 1800 006530 1802 006532 1805 006533 1806 006534 1807 006536 1808 006543 1809 006550 1810 006553 1811 006556 1813 006560 1814 006562 1815 006563 1817 006564 1818 006567 1820 006571 1821 006572 1822 006574 1824 006604 1827 006611 1828 006614 1829 006616 1830 006617 1832 006621 1834 006625 1835 006626 1837 006630 1840 006631 1841 006651 1842 006653 1844 006655 1845 006656 1846 006657 1848 006665 1849 006666 1851 006667 1852 006674 1854 006677 1855 006700 1857 006703 1859 006704 1900 006706 1902 006716 1914 006736 1866 006744 1920 006753 1923 006763 1924 006765 1930 006766 1933 006775 1936 006776 1938 007003 1939 007005 1940 007007 1942 007011 1944 007015 1946 007022 1947 007026 1948 007031 1949 007033 1951 007037 1952 007041 1954 007045 1955 007047 1956 007050 1957 007051 1958 007053 1960 007054 1961 007055 1963 007061 1964 007063 1967 007064 1968 007065 1969 007070 1971 007071 1974 007077 1976 007103 1978 007110 1979 007111 1980 007112 1982 007115 1983 007116 1984 007120 1985 007121 1986 007122 1988 007123 1990 007124 1991 007125 1992 007127 1993 007131 2001 007145 2002 007150 2004 007154 2005 007156 2006 007157 2007 007160 2008 007162 2009 007163 2011 007164 2013 007167 2015 007171 2017 007173 2020 007203 2022 007205 2026 007215 2029 007221 2030 007222 2037 007223 2039 007226 2042 007231 2043 007235 2045 007241 2046 007242 2047 007243 2051 007246 2052 007252 2053 007254 2054 007257 2060 007265 2063 007266 2065 007271 2069 007275 2071 007276 2075 007300 2077 007302 2078 007303 2080 007307 2082 007311 2085 007312 2088 007315 2090 007316 2094 007320 2096 007341 2098 007355 2099 007365 2100 007400 2101 007404 2102 007407 2104 007411 2105 007416 2106 007417 2107 007427 2108 007441 2110 007445 2111 007451 2117 007452 2118 007455 2119 007467 2120 007471 2122 007473 2123 007517 2126 007541 2129 007552 2130 007564 2131 007573 2133 007574 2135 007622 2136 007650 2139 007657 2145 007660 2147 007671 2149 007703 2151 007704 2153 007711 2154 007715 2156 007720 2159 007740 2161 007753 2163 007765 2165 007772 2167 007774 2172 007775 2175 007776 2176 010003 2177 010015 2178 010016 2180 010025 2182 010041 2183 010045 2184 010047 2186 010051 2187 010054 2190 010055 2191 010056 2192 010060 2193 010064 2194 010066 2195 010074 2197 010076 2201 010100 2202 010110 2203 010111 2204 010112 2206 010114 2210 010115 2213 010116 2215 010124 2216 010127 2218 010132 2221 010135 2223 010137 2224 010140 2225 010142 2227 010143 2233 010144 2236 010145 2237 010152 2238 010160 2241 010166 2243 010167 2247 010170 2253 010172 2254 010176 2255 010200 2257 010216 2260 010224 2261 010231 2265 010254 2267 010271 2271 010277 2272 010313 2274 010314 2276 010316 2277 010350 2278 010356 2281 010357 2282 010405 2284 010413 2292 010414 2324 010425 2325 010431 2326 010433 2328 010434 2330 010437 2332 010450 2337 010503 2338 010506 2339 010521 2342 010522 2343 010525 2344 010532 2349 010533 2350 010541 2357 010573 2358 010601 2359 010615 2360 010616 2362 010650 2367 010651 2374 010653 2379 010654 2380 010661 2381 010705 2386 010711 2387 010714 2388 010735 2394 010741 2399 010747 2400 010751 2402 010755 2404 011002 2409 011003 2410 011011 2411 011046 2412 011070 2421 011071 2425 011133 2426 011200 2428 011205 2435 011212 2436 011215 2437 011220 2441 011223 2447 011224 2456 011235 2458 011237 2459 011263 2461 011267 2462 011274 2463 011302 2464 011337 2466 011375 2467 011376 2469 011434 2472 011440 2473 011450 2475 011457 2478 011464 2482 011513 2483 011517 2484 011522 2487 011525 2492 011526 2510 011544 2511 011546 2515 011547 2521 011566 2524 011634 2525 011656 2532 011657 2535 011671 2536 011712 2542 011713 2548 011724 2549 011731 2550 011753 2552 011775 2553 012031 2554 012061 2555 012065 2556 012066 2559 012070 2560 012123 2561 012153 2562 012157 2563 012160 2566 012161 2567 012170 2573 012173 2574 012215 2576 012237 2586 012251 2588 012254 2599 012265 2600 012327 2602 012356 2603 012365 2604 012402 2605 012425 2606 012447 2608 012451 2616 012461 2627 012475 2628 012477 2630 012501 2632 012507 2638 012531 2642 012625 2643 012633 2644 012637 2647 012640 2651 012671 2652 012674 2653 012744 2656 012746 2657 012761 2658 012764 2660 013026 2661 013065 2662 013077 2664 013100 2670 013101 2681 013122 2682 013124 2684 013126 2685 013152 2691 013176 2692 013237 2695 013273 2696 013325 2700 013327 2701 013336 2704 013355 2707 013407 2708 013412 2709 013450 2712 013452 2713 013465 2714 013470 2715 013526 2716 013540 2719 013541 2725 013542 2733 013553 2734 013576 2736 013602 2739 013623 2742 013640 2743 013647 2749 013650 2756 013671 2758 013715 2759 013722 2760 013723 2763 013724 2764 013726 2766 013762 2768 013765 2770 014002 2774 014117 2777 014120 2779 014131 2785 014132 2801 014146 2802 014150 2804 014152 2806 014161 2808 014205 2811 014221 2812 014236 2814 014262 2815 014265 2816 014267 2819 014271 2825 014334 2829 014444 2832 014466 2835 014474 2836 014476 2837 014477 2844 014502 2849 014504 2850 014505 2852 014515 2854 014527 2856 014530 2858 014535 2859 014541 2861 014544 2865 014555 2867 014570 2869 014602 2871 014610 2872 014612 2881 014622 2890 014630 2891 014637 2893 014660 2896 014677 2897 014706 2898 014726 2900 014745 2907 014746 2912 014754 2913 014760 2914 014764 2915 014770 2918 014777 2919 015003 2921 015005 2922 015006 2924 015022 2932 015023 2941 015025 2943 015027 2944 015045 2945 015054 2946 015062 2947 015066 2948 015110 2950 015117 2951 015121 2953 015123 2955 015125 2956 015131 2957 015136 2958 015141 2959 015142 2961 015155 2963 015160 2965 015173 2966 015203 2970 015207 2971 015211 2972 015214 2976 015227 2977 015235 2978 015264 2979 015273 2982 015300 2990 015304 3000 015312 3001 015323 3002 015331 3003 015335 3004 015342 3006 015363 3008 015365 3010 015373 3012 015375 3014 015405 3016 015437 3017 015442 3018 015450 3019 015455 3023 015460 3026 015475 3032 015476 3037 015504 3038 015510 3039 015514 3041 015523 3042 015525 3043 015531 3044 015534 3047 015536 3050 015546 3051 015552 3052 015555 3053 015557 3054 015560 3057 015562 3073 015563 3085 015571 3087 015576 3088 015602 3089 015604 3092 015605 3093 015607 3094 015610 3097 015611 3098 015617 3099 015620 3100 015621 3103 015622 3105 015626 3106 015633 3108 015645 3111 015654 3112 015660 3115 015661 3117 015674 3119 015703 3121 015707 3123 015720 3126 015731 3128 015742 3130 015753 3132 015755 3134 015771 3136 016005 3138 016007 ----------------------------------------------------------- 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