COMPILATION LISTING OF SEGMENT v2pl1 Compiled by: Multics PL/I Compiler, Release 32c, of June 16, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 09/19/89 1011.9 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 4* * * 5* * Copyright, (C) Honeywell Bull Inc., 1987 * 6* * * 7* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 8* * * 9* * Copyright (c) 1972 by Massachusetts Institute of * 10* * Technology and Honeywell Information Systems, Inc. * 11* * * 12* *********************************************************** */ 13 14 15 16 /****^ HISTORY COMMENTS: 17* 1) change(87-03-05,Huen), approve(87-03-05,MCR7629), audit(87-04-15,RWaters), 18* install(87-05-14,MR12.1-1030): 19* Fix PL/1 errors 2141 - 20* Print a warning message about the truncation of the listing segment name. 21* 2) change(88-08-23,RWaters), approve(88-08-23,MCR7914), audit(88-09-28,Huen), 22* install(88-10-12,MR12.2-1163): 23* Added the -no_prefix control argument. 24* 3) change(89-04-17,JRGray), approve(89-04-17,MCR8078), audit(89-04-18,Huen), 25* install(89-06-09,MR12.3-1055): 26* Modified to allow for archive component pathnames. 27* 4) change(89-08-01,RWaters), approve(89-08-01,MCR8069), audit(89-09-07,Vu), 28* install(89-09-19,MR12.3-1068): 29* Added the -version and -no_version control arguments. 30* END HISTORY COMMENTS */ 31 32 /* PL/I COMMAND. 33* 34* This command has been rewritten in PL/I and observes Standard 35* Service System conventions. Modelled after the Fortran S.S.S. 36* command written by John Gintell. 37* 38* Written by: J.D.Mills 39* On: 26 September 1969 40* Modified on: 16 October 1969, by JDM. 41* Modified on: 30 October 1969, by JDM for multiple tree segments. 42* Modified on: 13 November 1969, by JDM to call hcs_ directly. 43* Modified on: 1 December 1969, by JDM to treat pre-expanded source correctly. 44* Modified on: 5 December 1969, by BLW to print compilation times 45* Modified on: 20 December 1969, by JDM for greater speed. 46* Modified on: 28 January 1970 by BLW to use cu_ 47* Modified on: 18 March 1970 by BLW to call optimizer 48* Modified on: 15 April 1970 by BLW for table option 49* Modified on: 8 July 1970 by BLW for new expand_ 50* Modified on: 16 July 1970 by BLW for epilogue 51* Modified on: 22 July 1970 by BLW for token_list in tree_ 52* Modified on: 6 August 1970 by PAG to eliminate varying strings in calls to hcs_ and 53* to check length of entry name and the suffix 54* Modified on: 26 August 1970 by PAG for Version II 55* Modified on: 18 September 1970 by PAG to optionally call semantic_translator 56* Modified on: 27 September 1970 by PG to compute percentages in $times entry 57* Modified on: 11 January 1971 by BLW to remove intermediate seg creation 58* and change to pl1_stat_ 59* Modified on: 29 January 1971 by BLW to be full PL/2 command 60* Modified on: 5 February l97l by PG for lexical stuff. 61* Modified on: 13 April 1971 by BLW to get ptr to error messages 62* Modified on: 7 August 1971 by PG to combine context_processor into parse 63* Modified on: 21 August 1971 by PG to combine lex and create_token 64* Modified on: 21 October 1971 by BLW to call code_gen_ 65* Modified on: 15 January 1972 by BLW for profile option 66* Modified on: 28 March 1972 by BLW for storage use summary 67* Modified on: 27 June 1972 by PG for tssi_, msf_manager_, prepare_symbol_table, and the link option 68* Modified on: 21 August 1972 by PG for find_include_file_ 69* Modified on: 20 December 1972 by RAB for 2 segment tree 70* Modified on: 23 June 1975 by EEW to recognize arg: -separate_static 71* Modified on: 4 December 1975 by EEW to fix cleanup problems (bug 1434) 72* Modified on: 14 April 1976 by RAB to use get_line_length_ 73* Modified on: 22 June 1976 by RHS to support the "new" area package, with full "retry" 74* Modified on: 29 July 1976 by RAB to not allow control args of the form "- xxxxxx" 75* Modified on: 1 Dec 1976 by RAB for -long_profile 76* Modified on: 16 Feb 1977 by RAB for -check_ansi 77* Modified on: April 1977 by RHS to use standard areas 78* Modified on: 770504 by PG for EIS lex 79* Modified on: 14 June 1977 by RAB for pl1_stat_$defined_list 80* Modified on: 770712 by PG for pl1_severity_ 81* Modified on: 17 October 1977 by RAB to fix bug 1681 82* Modified on: 26 September 1978 by PCK to flag unaligned decimal for Release 25, not accept -source and 83* -symbol control arguments, require a dash to precede every control argument, 84* and print the Release number of the compiler. 85* Modified on: 10 Feb 1978 by RAB to clean up printing out of tree and xeq_tree info. 86* Modified on: 24 May 1979 by PCK to implement options(packed_decimal) 87* Modified on: 26 May 1979 by D. Spector to add -single_symbol_list (-ssl) control arg. 88* Modified on: 3 October 1979 by PCK to allow pl1_version to be 89* bound with bound_pl1_ and rename pl1_error_messages_ 90* Modified on: 20 November 1979 by PCK to initialize cg_static_$in_prologue and 91* cg_static_$in_thunk to "0"b (part of the fix to bug 1858) 92* Modified on: 4 March 1980 by M. N. Davidoff to clean up, fix bugs 1874, 1876, 1904, 1907 and allow 93* -source, -symbols (suggestion 1892). 94* Modified on: 20 March 1980 by PCK to implement by name assignment 95* and increase the default error message width 96* Modified on: 17 April 1980 by M. N. Davidoff to use pl1_error_messages_ for installed compiler. 97* Modified on: 23 September 1980 by M. N. Davidoff to print message when invoked as an active function 98* (suggestion 1957) and did some restructuring to make planned modifications easier. 99* Modified on: 16 October 1980 by M. N. Davidoff to move call to tree_manager$init to after the command 100* argument parsing loop (2024), implement -long, -no_check, -no_check_ansi, -no_list, 101* -no_optimize, -no_profile, -no_separate_static, -no_table, -no_debug, -no_time (1943), and to 102* make -table the default unless -no_table, -brief_table or -optimize were specified (1946). 103* Modified on: 24 October 1980 by M. N. Davidoff to implement -prefix (1947). 104* Modified on: 19 November 1981 by C. Hornig to allow long_profile with separate_static. 105* Modified on: 25 April 1983 by Rick Gray to call find_source_file_ which allows archive 106* component pathnames. 107* Modified on: 28 August 1984 by JAFalksen to use date_time_$format ("date_time",... 108* Modified on: 15 January 1987 by S. Huen to print a warning message about the truncation of the listing segment name. 109* Modified on: 15 August 1988 by RWaters to accept the -no_prefix control argument. 110* Modified on: 28 February 1989 by RWaters to accept -version and -no_version. 111**/ 112 /* format: style3,idind30 */ 113 pl1exl: 114 v2pl1: 115 pl1: 116 procedure options (variable); 117 118 /* automatic */ 119 120 declare argument_no fixed bin; 121 declare arg_count fixed bin; 122 declare arg_length fixed bin (21); 123 declare arg_ptr ptr; 124 declare bitcnt fixed bin (24); 125 declare 1 blast_ca, 126 2 off bit (1), 127 2 on bit (1), 128 2 set bit (1); 129 declare blast_msg_len fixed bin (21); 130 declare blast_msg_ptr ptr; 131 declare 1 ca aligned, 132 2 no_optimize bit (1), 133 2 optimize bit (1), 134 2 no_table bit (1), 135 2 brief_table bit (1), 136 2 table bit (1), 137 2 no_check bit (1), 138 2 check bit (1), 139 2 no_list bit (1), 140 2 source bit (1), 141 2 symbols bit (1), 142 2 map bit (1), 143 2 list bit (1), 144 2 single_symbol_list bit (1), 145 2 brief bit (1), 146 2 long bit (1), 147 2 severity bit (1), 148 2 no_profile bit (1), 149 2 profile bit (1), 150 2 long_profile bit (1), 151 2 no_separate_static bit (1), 152 2 separate_static bit (1), 153 2 no_check_ansi bit (1), 154 2 check_ansi bit (1), 155 2 no_time bit (1), 156 2 time bit (1), 157 2 no_debug bit (1), 158 2 debug bit (1), 159 2 debug_semant bit (1), 160 2 debug_cg bit (1), 161 2 no_cpdcls bit (1), 162 2 cpdcls bit (1), 163 2 no_link bit (1), 164 2 link bit (1), 165 2 prefix bit (1), 166 2 no_version bit (1); 167 168 declare called_cg bit (1) aligned; 169 declare clock_time fixed bin (71); 170 declare code fixed bin (35); 171 declare component fixed bin; 172 declare fcb ptr; 173 declare i fixed bin; 174 declare in_cg bit (1) aligned; 175 declare len fixed bin (21); 176 declare list_hold ptr; 177 declare list_size fixed bin (19); 178 declare listname char (32); 179 declare lname char (32) varying; 180 declare object_hold ptr; 181 declare objectname char (32); 182 declare output_pt ptr; 183 declare pathname char (256); 184 declare pd_faults fixed bin; 185 declare 1 prefix aligned, 186 2 mask bit (12), 187 2 conditions bit (12); 188 declare prefix_string_length fixed bin (21); 189 declare prefix_string_ptr ptr; 190 declare produce_listing bit (1) aligned; 191 declare source_seg ptr; 192 declare sourcename char (32); 193 declare symbols_on bit (1) aligned; 194 declare translation_failed bit (1) aligned; 195 declare wdirname char (168); 196 197 /* based */ 198 199 declare arg_string char (arg_length) based (arg_ptr); 200 declare blast_msg char (blast_msg_len) based (blast_msg_ptr); 201 declare digit_pic picture "9" based; 202 declare prefix_string char (prefix_string_length) based (prefix_string_ptr); 203 declare source_string char (len) based (source_seg); 204 205 /* builtin */ 206 207 declare (addrel, baseno, before, binary, char, clock, codeptr, convert, divide, index, hbound, lbound, length, ltrim, 208 mod, null, rtrim, search, string, substr, verify) 209 builtin; 210 211 /* condition */ 212 213 declare cleanup condition; 214 declare listing_overflow condition; 215 216 /* internal static */ 217 218 declare HT_SP char (2) internal static options (constant) initial (" "); 219 declare HT_SP_COMMA char (3) internal static options (constant) initial (" ,"); 220 declare blast_time fixed bin (71) internal static initial (0); 221 declare comptime char (64) var internal static; 222 declare error_messages ptr internal static initial (null); 223 declare my_name char (3) internal static options (constant) initial ("pl1"); 224 declare ncpu (0:7) fixed bin (71) internal static initial ((8) 0); 225 declare npages (0:7) fixed bin internal static; 226 declare number_free_segs fixed bin internal static; 227 declare objectbc fixed bin (24) internal static; 228 declare phase_name (7) char (9) internal static options (constant) 229 initial ("setup", "parse", "semantics", "optimizer", "code gen", "listing", 230 "cleanup"); 231 declare storage (0:7) char (10) internal static initial ((8) (1)" 0"); 232 declare version char (132) varying internal static; 233 declare xeq_storage (0:7) char (10) internal static initial ((8) (1)" 0"); 234 235 /* external static */ 236 237 declare cg_static_$debug bit (1) aligned external static; 238 declare cg_static_$in_prologue bit (1) aligned external static; 239 declare cg_static_$in_thunk bit (1) aligned external static; 240 declare cg_static_$optimize bit (1) aligned external static; 241 declare cg_static_$separate_static bit (1) aligned external static; 242 declare cg_static_$stop_id bit (27) external static; 243 declare cg_static_$support bit (1) aligned external static; 244 declare error_table_$badopt fixed bin (35) external static; 245 declare error_table_$entlong fixed bin (35) external static; 246 declare error_table_$inconsistent fixed bin (35) external static; 247 declare error_table_$translation_failed 248 fixed bin (35) external static; 249 declare error_table_$zero_length_seg fixed bin (35) external static; 250 declare pl1_blast_$blast_message char (64) varying external static; 251 declare pl1_blast_$blast_on bit (1) aligned external static; 252 declare pl1_blast_$blast_time fixed bin (71) external static; 253 declare pl1_severity_ fixed bin (35) external static; 254 declare pl1_stat_$abort_label label external static; 255 declare pl1_stat_$brief_error_mode bit (1) aligned external static; 256 declare pl1_stat_$by_name_free_list ptr aligned external static; 257 declare pl1_stat_$by_name_parts_free_list 258 ptr aligned external static; 259 declare pl1_stat_$by_name_parts_tree ptr aligned external static; 260 declare pl1_stat_$by_name_ref_list ptr aligned external static; 261 declare pl1_stat_$char_pos fixed bin (21) external static; 262 declare pl1_stat_$check_ansi bit (1) aligned external static; 263 declare pl1_stat_$compiler_invoked bit (1) aligned external static; 264 declare pl1_stat_$compiler_name char (8) varying external static; 265 declare pl1_stat_$constant_list ptr external static; 266 declare pl1_stat_$debug_semant bit (1) aligned external static; 267 declare pl1_stat_$defined_list ptr external static; 268 declare pl1_stat_$dummy_block ptr external static; 269 declare pl1_stat_$error_messages ptr external static; 270 declare pl1_stat_$error_width fixed bin external static; 271 declare pl1_stat_$generate_symtab bit (1) aligned external static; 272 declare pl1_stat_$greatest_severity fixed bin external static; 273 declare pl1_stat_$index fixed bin external static; 274 declare pl1_stat_$last_statement_id bit (36) external static; 275 declare pl1_stat_$line_count fixed bin external static; 276 declare pl1_stat_$list_ptr ptr external static; 277 declare pl1_stat_$listing_on bit (1) aligned external static; 278 declare pl1_stat_$max_list_size fixed bin (21) external static; 279 declare pl1_stat_$max_node_type fixed bin external static; 280 declare pl1_stat_$new_fortran_option bit (1) aligned external static; 281 declare pl1_stat_$node_name (32) char (12) external static; 282 declare pl1_stat_$node_size (32) fixed bin external static; 283 declare pl1_stat_$node_uses (32) fixed bin external static; 284 declare pl1_stat_$ok_list ptr external static; 285 declare pl1_stat_$optimize bit (1) aligned external static; 286 declare pl1_stat_$options char (400) varying external static; 287 declare pl1_stat_$options_packed_dec bit (1) aligned external static; 288 declare pl1_stat_$pathname char (168) varying external static; 289 declare pl1_stat_$phase fixed bin external static; 290 declare pl1_stat_$print_cp_dcl bit (1) aligned external static; 291 declare pl1_stat_$profile bit (1) aligned external static; 292 declare pl1_stat_$profile_length fixed bin external static; 293 declare pl1_stat_$root ptr external static; 294 declare pl1_stat_$seg_name char (32) varying external static; 295 declare pl1_stat_$severity_plateau fixed bin external static; 296 declare pl1_stat_$single_symbol_list bit (1) aligned external static; 297 declare pl1_stat_$stop_id bit (27) external static; 298 declare pl1_stat_$table bit (1) aligned external static; 299 declare pl1_stat_$temporary_list ptr external static; 300 declare pl1_stat_$tree_area_ptr ptr external static; 301 declare pl1_stat_$unaligned_dec bit (1) aligned external static; 302 declare pl1_stat_$use_old_area bit (1) aligned external static; 303 declare pl1_stat_$user_id char (32) aligned external static; 304 declare pl1_stat_$validate_proc ptr external static; 305 declare pl1_stat_$version fixed bin external static; 306 declare pl1_stat_$xeq_tree_area_ptr ptr external static; 307 declare pl1_version$pl1_release char (3) varying external static; 308 declare pl1_version$pl1_version char (256) varying external static; 309 310 /* entry */ 311 312 /* Parts of the compiler */ 313 314 declare code_gen_ entry (char (32) varying, char (3) varying, char (132) varying, ptr, ptr, ptr, 315 ptr, ptr, ptr, fixed bin (71), fixed bin, bit (1) aligned, bit (1) aligned, 316 bit (1) aligned, bit (1) aligned, bit (1) aligned, bit (1) aligned, 317 bit (1) aligned, entry, entry, fixed bin (24), fixed bin, fixed bin (71), 318 bit (1) aligned, ptr, bit (1) aligned, fixed bin, fixed bin (71), bit (1) aligned) 319 ; 320 declare code_gen_$return_bit_count entry (fixed bin (24), fixed bin, fixed bin (71), fixed bin, fixed bin (71)); 321 declare error_$finish entry; 322 declare lex$terminate_source entry; 323 declare optimizer entry (ptr); 324 declare parse entry (ptr, char (*), 1 aligned, 2 bit (12), 2 bit (12)); 325 declare pl1_print$non_varying entry (char (*) aligned, fixed bin); 326 declare pl1_print$non_varying_nl entry (char (*) aligned, fixed bin); 327 declare pl1_print$varying_nl entry (char (*) varying); 328 declare pl1_signal_catcher entry (ptr, char (*), ptr, ptr, bit (1) aligned); 329 declare pl1_symbol_print entry (ptr, bit (1) aligned, bit (1) aligned); 330 declare prepare_symbol_table entry (ptr); 331 declare scan_token_table entry; 332 declare semantic_translator entry; 333 declare tree_manager$init entry (label); 334 declare tree_manager$truncate entry; 335 336 /* Others */ 337 338 declare com_err_ entry options (variable); 339 declare com_err_$suppress_name entry options (variable); 340 declare condition_ entry (char (*), entry); 341 declare cu_$arg_count entry (fixed bin, fixed bin (35)); 342 declare cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); 343 declare cpu_time_and_paging_ entry (fixed bin, fixed bin (71), fixed bin); 344 declare date_time_$format entry (char (*), fixed bin (71), char (*), char (*)) returns (char (250) var); 345 declare debug entry options (variable); 346 declare find_source_file_ entry (char (*), char (*), char (*), ptr, fixed bin (24), fixed bin (35)); 347 declare get_line_length_$switch entry (ptr, fixed bin (35)) returns (fixed bin); 348 declare get_group_id_ entry () returns (char (32)); 349 declare get_wdir_ entry () returns (char (168)); 350 declare hcs_$get_max_length_seg entry (ptr, fixed bin (19), fixed bin (35)); 351 declare hcs_$make_ptr entry (ptr, char (*), char (*), ptr, fixed bin (35)); 352 declare hcs_$terminate_noname entry (ptr, fixed bin (35)); 353 declare hcs_$truncate_seg entry (ptr, fixed bin (19), fixed bin (35)); 354 declare how_many_users entry options (variable); 355 declare ioa_ entry options (variable); 356 declare ioa_$nnl entry options (variable); 357 declare msf_manager_$get_ptr entry (ptr, fixed bin, bit (1), ptr, fixed bin (24), fixed bin (35)); 358 declare system_info_$installation_id entry (char (*)); 359 declare tssi_$clean_up_file entry (ptr, ptr); 360 declare tssi_$clean_up_segment entry (ptr); 361 declare tssi_$finish_file entry (ptr, fixed bin, fixed bin (24), bit (36) aligned, ptr, fixed bin (35)); 362 declare tssi_$finish_segment entry (ptr, fixed bin (24), bit (36) aligned, ptr, fixed bin (35)); 363 declare tssi_$get_file entry (char (*), char (*), ptr, ptr, ptr, fixed bin (35)); 364 declare tssi_$get_segment entry (char (*), char (*), ptr, ptr, fixed bin (35)); 365 366 /* format: style3,inddcls */ 367 1 1 /* BEGIN INCLUDE FILE ... condition_name.incl.pl1 */ 1 2 /* The long names and short names of the conditions are stored in the same 1 3* array. The indices of the long name and the short name differ by 10. The 1 4* size condition has the same long name and short name. */ 1 5 /* format: style3,^delnl */ 1 6 1 7 declare condition_name (19) char (16) internal static options (constant) initial 1 8 ("underflow", "overflow", "zerodivide", "fixedoverflow", "conversion", 1 9 "size", "subscriptrange", "stringrange", "stringsize", "size", 1 10 "ufl", "ofl", "zdiv", "fofl", "conv", 1 11 "size", "subrg", "strg", "strz"); 1 12 1 13 /* END INCLUDE FILE ... condition_name.incl.pl1 */ 368 2 1 /* BEGIN INCLUDE FILE area_structures.incl.pl1 10/75 */ 2 2 /* Modified September 1981 by J. Bongiovanni for allocation_p_clock */ 2 3 2 4 dcl area_version_1 fixed bin static init (1); /* version number for this area format */ 2 5 2 6 dcl areap ptr; 2 7 2 8 dcl 1 area_header aligned based (areap), 2 9 2 version fixed bin (35), /* 0 for buddy system, 1 for current areas */ 2 10 2 last_usable bit (18), /* rel pointer to end of area */ 2 11 2 next_virgin bit (18), /* rel pointer to next slot in virgin territory */ 2 12 2 flags, 2 13 3 extend bit (1) unal, /* says area is extensible */ 2 14 3 zero_on_alloc bit (1) unal, /* says to zero after allocation */ 2 15 3 zero_on_free bit (1) unal, /* says to zero after freeing */ 2 16 3 dont_free bit (1) unal, /* dont honor free request -- debugging tool */ 2 17 3 defined_by_call bit (1) unal, /* says area seg got via define_area_ call */ 2 18 3 system bit (1) unal, /* ayss area is managed by the system */ 2 19 3 mbz bit (30) unal, 2 20 2 allocation_method fixed bin, /* 0 is standard, 1 is no_freeing method */ 2 21 2 last_size bit (18), /* size of last allocated block before virgin territory */ 2 22 2 last_block bit (18), /* rel pointer to last allocated block before virgin territory */ 2 23 2 freep (3:16), /* free list info */ 2 24 3 relp bit (18) unal, /* pointer to first block on list */ 2 25 3 max_block_size bit (18) unal, /* size of largest block on list, if known. else zero */ 2 26 2 allocation_p_clock bit (36) aligned, /* counter to prevent IPS race */ 2 27 2 extend_info bit (18) unal, /* offset to extend info block */ 2 28 2 recovery_info bit (18) unal, /* eventually will hold recovery info relp */ 2 29 2 n_allocated fixed bin (17) unal, /* number of allocated blocks */ 2 30 2 n_free fixed bin (17) unal; /* number of free blocks */ 2 31 2 32 dcl (STANDARD_ALLOCATION_METHOD init (0), 2 33 NO_FREEING_ALLOCATION_METHOD init (1) 2 34 ) fixed bin internal static; 2 35 2 36 dcl extend_blockp ptr; 2 37 2 38 dcl 1 extend_block aligned based (extend_blockp), /* contents of extend block for extensible areas */ 2 39 2 first_area ptr unal, /* pointer to first area */ 2 40 2 next_area ptr unal, /* pointer to next area in chain */ 2 41 2 sequence_no fixed bin, /* sequence number for this component */ 2 42 2 name char (32), /* owner of the area */ 2 43 2 pad fixed; /* brings it to an even, 12 word allocation */ 2 44 2 45 dcl alloc_blkhdrsz static internal init(2); 2 46 dcl 1 no_free_area_header aligned based(areap), /* overlay for no_free areas */ 2 47 2 pad(4) ptr, 2 48 2 current_component ptr; /* points to component from which we are allocating */ 2 49 2 50 dcl blockp ptr; 2 51 2 52 dcl 1 block aligned based (blockp), /* declaration for block header */ 2 53 2 prev_size bit (18) unal, /* size of preceding block */ 2 54 2 cur_size bit (18) unal, /* size of current block */ 2 55 2 buddy_pad bit (8) unal, /* non_zero for buddy system area */ 2 56 2 prev_busy bit (1) unal, /* previous-block-is-used flag */ 2 57 2 marked bit (1) unal, 2 58 2 q_no bit (8) unal, /* stratum number when in free list */ 2 59 2 header bit (18) unal, /* pointer to head of area */ 2 60 2 fp bit (18) unal, /* forward free list thread */ 2 61 2 bp bit (18) unal; /* backward free list thread */ 2 62 2 63 dcl min_block_size fixed bin static init (8); /* minimum allowed block size */ 2 64 2 65 /* END INCLUDE FILE area_structures.incl.pl1 */ 369 3 1 dcl pl1_version fixed bin int static init(5); 370 371 372 /* program */ 373 374 pl1_severity_ = 5; 375 376 call cu_$arg_count (arg_count, code); 377 if code ^= 0 378 then do; 379 call com_err_ (code, my_name); 380 return; 381 end; 382 383 if pl1_stat_$compiler_invoked 384 then do; 385 call com_err_ (0, my_name, "The compiler has been invoked with a previous invocation suspended."); 386 call com_err_ (error_table_$translation_failed, my_name, 387 "Attempt to invoke pl1 recursively. Use release first."); 388 return; 389 end; 390 391 call cpu_time_and_paging_ (npages (0), ncpu (0), pd_faults); 392 393 do i = 1 to hbound (npages, 1); 394 npages (i) = -1; 395 end; 396 397 number_free_segs = 0; 398 399 if error_messages = null 400 then begin; 401 declare error_messages_name char (32); 402 403 version = pl1_version$pl1_version; 404 pl1_stat_$user_id = get_group_id_ (); 405 406 if pl1_version$pl1_release = "EXL" 407 then error_messages_name = "pl1exl_error_messages_"; 408 else error_messages_name = "pl1_error_messages_"; 409 410 call hcs_$make_ptr (codeptr (v2pl1), error_messages_name, "", error_messages, code); 411 if code ^= 0 412 then do; 413 call com_err_ (code, my_name, "^a", error_messages_name); 414 return; 415 end; 416 end; 417 418 pl1_stat_$error_messages = error_messages; 419 pl1_stat_$greatest_severity = 5; 420 pl1_stat_$compiler_name = my_name; 421 pl1_stat_$use_old_area = "0"b; 422 423 do i = 1 to pl1_stat_$max_node_type; 424 pl1_stat_$node_uses (i) = 0; 425 end; 426 427 pl1_stat_$abort_label = abort_return; 428 429 in_cg, called_cg, translation_failed, pl1_stat_$generate_symtab, pl1_stat_$last_statement_id, 430 pl1_stat_$new_fortran_option, pl1_stat_$unaligned_dec, pl1_stat_$options_packed_dec, cg_static_$support, 431 cg_static_$in_prologue, cg_static_$in_thunk = "0"b; 432 433 pl1_stat_$error_width = get_line_length_$switch (null, code); 434 435 pl1_stat_$validate_proc, pl1_stat_$constant_list, pl1_stat_$ok_list, pl1_stat_$dummy_block, 436 pl1_stat_$defined_list, pl1_stat_$by_name_free_list, pl1_stat_$by_name_parts_free_list, 437 pl1_stat_$by_name_parts_tree, pl1_stat_$by_name_ref_list, pl1_stat_$temporary_list = null; 438 439 pl1_stat_$profile_length, pl1_stat_$index = 0; 440 441 pl1_stat_$stop_id, cg_static_$stop_id = (27)"1"b; 442 443 pl1_stat_$version = pl1_version; 444 445 /* Parse the command line arguments. */ 446 447 ca = ""b; 448 argument_no = 0; 449 do i = 1 to arg_count; 450 call cu_$arg_ptr (i, arg_ptr, arg_length, code); 451 if code ^= 0 452 then do; 453 call com_err_ (code, my_name, "Argument ^d.", i); 454 return; 455 end; 456 457 if index (arg_string, "-") = 1 458 then if arg_string = "-no_optimize" | arg_string = "-not" 459 then do; 460 ca.no_optimize = "1"b; 461 ca.optimize = "0"b; 462 end; 463 464 else if arg_string = "-optimize" | arg_string = "-ot" 465 then do; 466 ca.no_optimize = "0"b; 467 ca.optimize = "1"b; 468 end; 469 470 else if arg_string = "-no_table" | arg_string = "-ntb" 471 then do; 472 ca.no_table = "1"b; 473 ca.brief_table = "0"b; 474 ca.table = "0"b; 475 end; 476 477 else if arg_string = "-brief_table " | arg_string = "-bftb" 478 then do; 479 ca.no_table = "0"b; 480 ca.brief_table = "1"b; 481 ca.table = "0"b; 482 end; 483 484 else if arg_string = "-table" | arg_string = "-tb" 485 then do; 486 ca.no_table = "0"b; 487 ca.brief_table = "0"b; 488 ca.table = "1"b; 489 end; 490 491 else if arg_string = "-no_check" | arg_string = "-nck" 492 then do; 493 ca.no_check = "1"b; 494 ca.check = "0"b; 495 end; 496 497 else if arg_string = "-check" | arg_string = "-ck" 498 then do; 499 ca.no_check = "0"b; 500 ca.check = "1"b; 501 end; 502 503 else if arg_string = "-no_list" | arg_string = "-nls" 504 then do; 505 ca.no_list = "1"b; 506 ca.source = "0"b; 507 ca.symbols = "0"b; 508 ca.map = "0"b; 509 ca.list = "0"b; 510 ca.single_symbol_list = "0"b; 511 end; 512 513 else if arg_string = "-source" | arg_string = "-sc" 514 then do; 515 ca.no_list = "0"b; 516 ca.source = "1"b; 517 end; 518 519 else if arg_string = "-symbols" | arg_string = "-sb" 520 then do; 521 ca.no_list = "0"b; 522 ca.symbols = "1"b; 523 end; 524 525 else if arg_string = "-map" 526 then do; 527 ca.no_list = "0"b; 528 ca.map = "1"b; 529 end; 530 531 else if arg_string = "-list" | arg_string = "-ls" 532 then do; 533 ca.no_list = "0"b; 534 ca.list = "1"b; 535 end; 536 537 else if arg_string = "-single_symbol_list" | arg_string = "-ssl" 538 then do; 539 ca.no_list = "0"b; 540 ca.single_symbol_list = "1"b; 541 end; 542 543 else if arg_string = "-brief" | arg_string = "-bf" 544 then do; 545 ca.brief = "1"b; 546 ca.long = "0"b; 547 end; 548 549 else if arg_string = "-long" | arg_string = "-lg" 550 then do; 551 ca.brief = "0"b; 552 ca.long = "1"b; 553 end; 554 555 else if index (arg_string, "-severity") = 1 556 then if ^parse_severity (arg_string, "-severity") 557 then return; 558 else ; 559 560 else if index (arg_string, "-sv") = 1 561 then if ^parse_severity (arg_string, "-sv") 562 then return; 563 else ; 564 565 else if arg_string = "-no_profile" | arg_string = "-npf" 566 then do; 567 ca.no_profile = "1"b; 568 ca.profile = "0"b; 569 ca.long_profile = "0"b; 570 end; 571 572 else if arg_string = "-profile" | arg_string = "-pf" 573 then do; 574 ca.no_profile = "0"b; 575 ca.profile = "1"b; 576 ca.long_profile = "0"b; 577 end; 578 579 else if arg_string = "-long_profile" | arg_string = "-lpf" 580 then do; 581 ca.no_profile = "0"b; 582 ca.profile = "0"b; 583 ca.long_profile = "1"b; 584 end; 585 586 else if arg_string = "-no_separate_static" | arg_string = "-nss" 587 then do; 588 ca.no_separate_static = "1"b; 589 ca.separate_static = "0"b; 590 end; 591 592 else if arg_string = "-separate_static" | arg_string = "-ss" 593 then do; 594 ca.no_separate_static = "0"b; 595 ca.separate_static = "1"b; 596 end; 597 598 else if arg_string = "-no_check_ansi" 599 then do; 600 ca.no_check_ansi = "1"b; 601 ca.check_ansi = "0"b; 602 end; 603 604 else if arg_string = "-check_ansi" 605 then do; 606 ca.no_check_ansi = "0"b; 607 ca.check_ansi = "1"b; 608 end; 609 610 else if arg_string = "-no_time" | arg_string = "-ntm" 611 then do; 612 ca.no_time = "1"b; 613 ca.time = "0"b; 614 end; 615 616 else if arg_string = "-time" | arg_string = "-tm" 617 then do; 618 ca.no_time = "0"b; 619 ca.time = "1"b; 620 end; 621 622 else if arg_string = "-no_debug" | arg_string = "-ndb" 623 then do; 624 ca.no_debug = "1"b; 625 ca.debug = "0"b; 626 ca.debug_semant = "0"b; 627 ca.debug_cg = "0"b; 628 end; 629 630 else if arg_string = "-debug" | arg_string = "-db" 631 then do; 632 ca.no_debug = "0"b; 633 ca.debug = "1"b; 634 end; 635 636 else if arg_string = "-debug_semant" | arg_string = "-dbse" 637 then do; 638 ca.no_debug = "0"b; 639 ca.debug_semant = "1"b; 640 end; 641 642 else if arg_string = "-debug_cg" | arg_string = "-dbcg" 643 then do; 644 ca.no_debug = "0"b; 645 ca.debug_cg = "1"b; 646 end; 647 648 else if arg_string = "-no_cpdcls" 649 then do; 650 ca.no_cpdcls = "1"b; 651 ca.cpdcls = "0"b; 652 end; 653 654 else if arg_string = "-cpdcls" 655 then do; 656 ca.no_cpdcls = "0"b; 657 ca.cpdcls = "1"b; 658 end; 659 660 else if arg_string = "-no_link" | arg_string = "-nlk" 661 then do; 662 ca.no_link = "1"b; 663 ca.link = "0"b; 664 end; 665 666 else if arg_string = "-link" | arg_string = "-lk" 667 then do; 668 ca.no_link = "0"b; 669 ca.link = "1"b; 670 end; 671 672 else if arg_string = "-version" 673 then do; 674 ca.no_version = "0"b; 675 end; 676 677 else if arg_string = "-no_version" 678 then do; 679 ca.no_version = "1"b; 680 end; 681 else if arg_string = "-no_prefix" 682 then do; 683 ca.prefix = "0"b; 684 end; 685 686 else if arg_string = "-prefix" 687 then do; 688 i = i + 1; 689 if i > arg_count 690 then do; 691 call com_err_ (0, my_name, "Missing prefix string after -prefix."); 692 return; 693 end; 694 695 call cu_$arg_ptr (i, prefix_string_ptr, prefix_string_length, code); 696 if code ^= 0 697 then do; 698 call com_err_ (code, my_name, "Argument ^d.", i); 699 return; 700 end; 701 702 ca.prefix = "1"b; 703 end; 704 705 else do; 706 call com_err_ (error_table_$badopt, my_name, "^a", arg_string); 707 return; 708 end; 709 710 else do; 711 argument_no = argument_no + 1; 712 if argument_no = 1 /* process pathname later */ 713 then pathname = arg_string; 714 end; 715 end; 716 717 if argument_no ^= 1 718 then do; 719 if arg_count > 1 | ca.no_version 720 then call com_err_$suppress_name (0, my_name, "Usage: ^a path {-control_args}", my_name); 721 else do; /* identify version of compiler */ 722 if pl1_version$pl1_release = "EXL" 723 then call ioa_ ("^a", pl1_version$pl1_version); 724 else call ioa_ ("PL/1 ^a", pl1_version$pl1_release); 725 end; 726 return; 727 end; 728 729 /* Apply defaults. */ 730 731 if ^ca.no_table & ^ca.brief_table & ^ca.optimize 732 then ca.table = "1"b; 733 734 /* We now know what options were specified. */ 735 736 pl1_stat_$options = ""; 737 738 pl1_stat_$optimize, cg_static_$optimize = ca.optimize; 739 if ca.optimize 740 then pl1_stat_$options = pl1_stat_$options || " optimize"; 741 742 if ca.brief_table 743 then pl1_stat_$options = pl1_stat_$options || " brief_table"; 744 745 pl1_stat_$table = ca.table; 746 if ca.table 747 then pl1_stat_$options = pl1_stat_$options || " table"; 748 749 if ca.check 750 then pl1_stat_$options = pl1_stat_$options || " check"; 751 752 if ca.source 753 then pl1_stat_$options = pl1_stat_$options || " source"; 754 755 if ca.symbols 756 then pl1_stat_$options = pl1_stat_$options || " symbols"; 757 758 if ca.map 759 then pl1_stat_$options = pl1_stat_$options || " map"; 760 761 if ca.list 762 then pl1_stat_$options = pl1_stat_$options || " list"; 763 764 pl1_stat_$single_symbol_list = ca.single_symbol_list; 765 if ca.single_symbol_list 766 then pl1_stat_$options = pl1_stat_$options || " single_symbol_list"; 767 768 symbols_on = ca.symbols | ca.map | ca.list | ca.single_symbol_list; 769 produce_listing, pl1_stat_$listing_on = ca.source | symbols_on; 770 771 pl1_stat_$brief_error_mode = ca.brief; 772 773 if ca.severity 774 then pl1_stat_$options = pl1_stat_$options || " severity" || convert (digit_pic, pl1_stat_$severity_plateau); 775 else pl1_stat_$severity_plateau = 1; 776 777 if ca.profile 778 then pl1_stat_$options = pl1_stat_$options || " profile"; 779 780 if ca.long_profile 781 then pl1_stat_$options = pl1_stat_$options || " long_profile"; 782 783 pl1_stat_$profile = ca.profile | ca.long_profile; 784 785 cg_static_$separate_static = ca.separate_static; 786 if ca.separate_static 787 then pl1_stat_$options = pl1_stat_$options || " separate_static"; 788 789 pl1_stat_$check_ansi = ca.check_ansi; 790 791 pl1_stat_$print_cp_dcl = ca.cpdcls; 792 if ca.cpdcls 793 then pl1_stat_$options = pl1_stat_$options || " cpdcls"; 794 795 cg_static_$debug = ca.debug | ca.debug_semant | ca.debug_cg; 796 pl1_stat_$debug_semant = ca.debug_semant; 797 798 if ca.link 799 then pl1_stat_$options = pl1_stat_$options || " link"; 800 801 if ca.no_version 802 then ; 803 else do; 804 if pl1_version$pl1_release = "EXL" 805 then call ioa_ ("^a", pl1_version$pl1_version); 806 else call ioa_ ("PL/1 ^a", pl1_version$pl1_release); 807 end; 808 809 prefix = ""b; 810 if ca.prefix 811 then if ^parse_prefix (prefix_string) 812 then return; 813 814 pl1_stat_$options = ltrim (pl1_stat_$options); 815 816 /* Find the source file. */ 817 call find_source_file_ (pathname, "pl1", sourcename, source_seg, bitcnt, code); 818 if source_seg = null 819 then do; 820 call com_err_ (code, my_name, "^a", pathname); 821 return; 822 end; 823 824 if bitcnt = 0 825 then do; 826 call com_err_ (error_table_$zero_length_seg, my_name, "^a", pathname); 827 call hcs_$terminate_noname (source_seg, code); 828 return; 829 end; 830 831 objectname = before (sourcename || " ", ".pl1 "); 832 objectname = before (objectname, ".ex "); 833 pl1_stat_$pathname = pathname; 834 pl1_stat_$seg_name = rtrim (objectname); 835 836 len = divide (bitcnt + 8, 9, 21); 837 838 if pl1_blast_$blast_on 839 then if pl1_blast_$blast_time > blast_time 840 then do; 841 call ioa_ ("^a", pl1_blast_$blast_message); 842 blast_time = clock (); 843 end; 844 845 wdirname = get_wdir_ (); 846 clock_time = clock (); 847 comptime = date_time_$format ("date_time", clock_time, "", ""); 848 849 list_hold = null; 850 object_hold = null; 851 852 on cleanup 853 begin; 854 if ^cg_static_$debug 855 then call truncate; 856 857 pl1_stat_$compiler_invoked = "0"b; 858 end; 859 860 if produce_listing 861 then begin; 862 declare installation_id char (32); 863 864 component = 0; 865 lname = rtrim (objectname); 866 if length (lname) > 27 867 then call com_err_ (error_table_$entlong, my_name, 868 "The name of the listing segment is truncated to ^a.lis", lname); 869 870 listname = lname || ".list"; 871 872 call tssi_$get_file (wdirname, listname, pl1_stat_$list_ptr, list_hold, fcb, code); 873 if pl1_stat_$list_ptr = null 874 then do; 875 call com_err_ (code, my_name, "^a^[>^]^a", wdirname, wdirname ^= ">", listname); 876 call hcs_$terminate_noname (source_seg, code); 877 return; 878 end; 879 880 call hcs_$get_max_length_seg (pl1_stat_$list_ptr, list_size, code); 881 if code ^= 0 882 then do; 883 call com_err_ (code, my_name, "^a^[>^]^a", wdirname, wdirname ^= ">", listname); 884 call hcs_$terminate_noname (source_seg, code); 885 return; 886 end; 887 888 pl1_stat_$max_list_size = 4 * list_size; 889 pl1_stat_$char_pos = 1; 890 891 call pl1_print$non_varying_nl (" COMPILATION LISTING OF SEGMENT " || rtrim (objectname), 0); 892 call pl1_print$non_varying_nl (" Compiled by: " || pl1_version$pl1_version, 0); 893 894 call system_info_$installation_id (installation_id); 895 call pl1_print$non_varying_nl (" Compiled at: " || installation_id, 0); 896 call pl1_print$non_varying_nl (" Compiled on: " || comptime, 0); 897 898 if length (pl1_stat_$options) > 0 899 then do; 900 call pl1_print$non_varying (" Options: ", 0); 901 call pl1_print$varying_nl (pl1_stat_$options); 902 end; 903 904 call pl1_print$non_varying_nl ("", 0); 905 end; 906 907 if produce_listing 908 then on listing_overflow 909 begin; 910 declare component_bit_count fixed binary (24); 911 912 component = component + 1; 913 914 call msf_manager_$get_ptr (fcb, component, "1"b /* create */, pl1_stat_$list_ptr, 915 component_bit_count, code); 916 917 if pl1_stat_$list_ptr ^= null 918 then call hcs_$get_max_length_seg (pl1_stat_$list_ptr, list_size, code); 919 920 if pl1_stat_$list_ptr = null | code ^= 0 921 then do; 922 call com_err_ (code, my_name, "Component ^d of ^a^[>^]^a", component, wdirname, 923 wdirname ^= ">", listname); 924 925 if in_cg 926 then call code_gen_$return_bit_count (objectbc, npages (5), ncpu (5), npages (6), 927 ncpu (6)); 928 929 translation_failed = "1"b; 930 goto close_list; 931 end; 932 933 pl1_stat_$max_list_size = 4 * list_size; 934 pl1_stat_$char_pos = 1; 935 end; 936 937 /* Call the phases of pl1. */ 938 939 call tree_manager$init (pl1_stat_$abort_label); 940 941 pl1_stat_$phase = 1; 942 pl1_severity_, pl1_stat_$greatest_severity = 0; 943 pl1_stat_$compiler_invoked = "1"b; 944 945 call condition_ ("any_other", pl1_signal_catcher); 946 947 call cpu_time_and_paging_ (npages (1), ncpu (1), pd_faults); 948 949 call parse (pl1_stat_$root, source_string, prefix); 950 951 call cpu_time_and_paging_ (npages (2), ncpu (2), pd_faults); 952 call set_storage_usage (storage (2), xeq_storage (2)); 953 954 if ca.debug_semant 955 then do; 956 call ioa_$nnl ("Beginning semantic translator.^/debug: "); 957 call debug; 958 end; 959 960 pl1_stat_$phase = 2; 961 call semantic_translator; 962 call scan_token_table; 963 964 call cpu_time_and_paging_ (npages (3), ncpu (3), pd_faults); 965 call set_storage_usage (storage (3), xeq_storage (3)); 966 967 if ^ca.check 968 then call generate_code (translation_failed); 969 970 continue_from_abort: 971 if translation_failed 972 then call com_err_ (error_table_$translation_failed, my_name, "^a", sourcename); 973 974 if ^called_cg 975 then do; 976 call cpu_time_and_paging_ (npages (5), ncpu (5), pd_faults); 977 npages (6) = npages (5); 978 ncpu (6) = ncpu (5); 979 end; 980 981 if produce_listing 982 then do; 983 if ^called_cg 984 then do; 985 if symbols_on 986 then call pl1_symbol_print (pl1_stat_$root, pl1_stat_$print_cp_dcl, 987 ca.check | translation_failed | pl1_stat_$greatest_severity >= 3); 988 989 call pl1_print$non_varying_nl ("", 0); 990 991 if pl1_stat_$greatest_severity > 0 992 then call error_$finish; 993 end; 994 995 close_list: 996 call tssi_$finish_file (fcb, component, 9 * pl1_stat_$char_pos - 9, "101"b, list_hold, code); 997 if code ^= 0 998 then call com_err_ (code, my_name, "^a^[>^]^a", wdirname, wdirname ^= ">", listname); 999 end; 1000 1001 if ^ca.check & ^translation_failed 1002 then do; 1003 call hcs_$truncate_seg (output_pt, divide (objectbc + 35, 36, 19), code); 1004 if code ^= 0 1005 then call com_err_ (code, my_name, "^a^[>^]^a", wdirname, wdirname ^= ">", objectname); 1006 1007 call tssi_$finish_segment (output_pt, objectbc, "110"b, object_hold, code); 1008 if code ^= 0 1009 then call com_err_ (code, my_name, "^a^[>^]^a", wdirname, wdirname ^= ">", objectname); 1010 end; 1011 1012 call cpu_time_and_paging_ (npages (7), ncpu (7), pd_faults); 1013 call set_storage_usage (storage (5), xeq_storage (5)); 1014 1015 storage (6), storage (7) = storage (5); 1016 xeq_storage (6), xeq_storage (7) = xeq_storage (5); 1017 1018 if ^cg_static_$debug 1019 then call truncate; 1020 1021 pl1_severity_ = pl1_stat_$greatest_severity; 1022 1023 pl1_stat_$compiler_invoked = "0"b; 1024 1025 if ca.time 1026 then call print_times; 1027 1028 return; 1029 1030 abort_return: 1031 call com_err_ (0, my_name, "An unrecoverable error has occurred."); 1032 translation_failed = "1"b; 1033 goto continue_from_abort; 1034 1035 times: 1036 entry options (variable); 1037 1038 call cu_$arg_count (arg_count, code); 1039 if code ^= 0 1040 then do; 1041 call com_err_ (code, my_name); 1042 return; 1043 end; 1044 1045 if arg_count ^= 0 1046 then do; 1047 call com_err_$suppress_name (0, my_name, "Usage: ^a$times", my_name); 1048 return; 1049 end; 1050 1051 call print_times; 1052 1053 return; 1054 1055 clean_up: 1056 entry options (variable); 1057 1058 call cu_$arg_count (arg_count, code); 1059 if code ^= 0 1060 then do; 1061 call com_err_ (code, my_name); 1062 return; 1063 end; 1064 1065 if arg_count ^= 0 1066 then do; 1067 call com_err_$suppress_name (0, my_name, "Usage: ^a$clean_up", my_name); 1068 return; 1069 end; 1070 1071 object_hold = null; 1072 list_hold = null; 1073 1074 call truncate; 1075 pl1_stat_$compiler_invoked = "0"b; 1076 1077 return; 1078 1079 blast: 1080 entry options (variable); 1081 1082 call cu_$arg_count (arg_count, code); 1083 if code ^= 0 1084 then do; 1085 call com_err_ (code, my_name); 1086 return; 1087 end; 1088 1089 string (blast_ca) = ""b; 1090 argument_no = 0; 1091 do i = 1 to arg_count; 1092 call cu_$arg_ptr (i, arg_ptr, arg_length, code); 1093 if code ^= 0 1094 then do; 1095 call com_err_ (code, my_name, "Argument ^d.", i); 1096 return; 1097 end; 1098 1099 if arg_string = "-on" 1100 then do; 1101 blast_ca.on = "1"b; 1102 blast_ca.off = "0"b; 1103 end; 1104 1105 else if arg_string = "-off" 1106 then do; 1107 blast_ca.on = "0"b; 1108 blast_ca.off = "1"b; 1109 end; 1110 1111 else if arg_string = "-set" 1112 then do; 1113 i = i + 1; 1114 if i > arg_count 1115 then do; 1116 call com_err_ (0, my_name, "Missing blast message after -set."); 1117 return; 1118 end; 1119 1120 call cu_$arg_ptr (i, blast_msg_ptr, blast_msg_len, code); 1121 if code ^= 0 1122 then do; 1123 call com_err_ (code, my_name, "Argument ^d.", i); 1124 return; 1125 end; 1126 1127 blast_ca.set = "1"b; 1128 end; 1129 1130 else if index (arg_string, "-") = 1 1131 then do; 1132 call com_err_ (error_table_$badopt, my_name, "^a", arg_string); 1133 return; 1134 end; 1135 1136 else argument_no = argument_no + 1; 1137 end; 1138 1139 if argument_no ^= 0 | string (blast_ca) = ""b 1140 then do; 1141 call com_err_$suppress_name (0, my_name, "Usage: ^a$blast -control_args", my_name); 1142 return; 1143 end; 1144 1145 if blast_ca.set & (blast_ca.on | blast_ca.off) 1146 then do; 1147 call com_err_ (error_table_$inconsistent, my_name, "-set and -^[on^;off^]", blast_ca.on); 1148 return; 1149 end; 1150 1151 if blast_ca.on 1152 then pl1_blast_$blast_on = "1"b; 1153 1154 else if blast_ca.off 1155 then pl1_blast_$blast_on = "0"b; 1156 1157 else if blast_ca.set 1158 then do; 1159 pl1_blast_$blast_on = "0"b; 1160 pl1_blast_$blast_message = blast_msg; 1161 pl1_blast_$blast_time = clock (); 1162 pl1_blast_$blast_on = "1"b; 1163 end; 1164 1165 call ioa_ ("Accepted."); 1166 1167 return; 1168 1169 parse_severity: 1170 procedure (arg_string, prefix) returns (bit (1) aligned); 1171 1172 declare arg_string char (*); 1173 declare prefix char (*); 1174 1175 declare severity fixed bin; 1176 1177 if length (rtrim (arg_string)) = length (prefix) + 1 1178 then severity = index ("1234", substr (arg_string, length (prefix) + 1, 1)); 1179 else severity = 0; 1180 1181 if severity = 0 1182 then do; 1183 call com_err_ (0, my_name, "Invalid severity level. ^a", arg_string); 1184 return ("0"b); 1185 end; 1186 1187 ca.severity = "1"b; 1188 pl1_stat_$severity_plateau = severity; 1189 1190 return ("1"b); 1191 end parse_severity; 1192 1193 parse_prefix: 1194 procedure (prefix_string) returns (bit (1) aligned); 1195 1196 declare prefix_string char (*); 1197 1198 declare scan_position fixed bin (21); 1199 1200 scan_position = verify (prefix_string, HT_SP); 1201 if scan_position = 0 1202 then return ("1"b); 1203 1204 pl1_stat_$options = pl1_stat_$options || " prefix("; 1205 1206 if ^parse_condition_name () 1207 then return ("0"b); 1208 do while (scan_position <= length (prefix_string)); 1209 if substr (prefix_string, scan_position, 1) ^= "," 1210 then do; 1211 call com_err_ (0, my_name, "Missing comma between condition names. ^a", prefix_string); 1212 return ("0"b); 1213 end; 1214 1215 scan_position = scan_position + 1; 1216 1217 if ^parse_condition_name () 1218 then return ("0"b); 1219 end; 1220 1221 pl1_stat_$options = pl1_stat_$options || ")"; 1222 1223 return ("1"b); 1224 1225 parse_condition_name: 1226 procedure returns (bit (1) aligned); 1227 1228 declare enabled bit (1) aligned; 1229 declare i fixed bin; 1230 declare token_length fixed bin (21); 1231 declare token_start fixed bin (21); 1232 1233 call skip_white_space; 1234 1235 token_length = search (substr (prefix_string, scan_position), HT_SP_COMMA) - 1; 1236 if token_length < 0 1237 then token_length = length (substr (prefix_string, scan_position)); 1238 1239 if token_length = 0 1240 then do; 1241 call com_err_ (0, my_name, "Missing condition name. ^a", prefix_string); 1242 return ("0"b); 1243 end; 1244 1245 token_start = scan_position; 1246 scan_position = scan_position + token_length; 1247 1248 enabled = index (substr (prefix_string, token_start, token_length), "no") ^= 1; 1249 if ^enabled 1250 then do; 1251 token_start = token_start + length ("no"); 1252 token_length = token_length - length ("no"); 1253 end; 1254 1255 do i = lbound (condition_name, 1) to hbound (condition_name, 1) 1256 while (condition_name (i) ^= substr (prefix_string, token_start, token_length)); 1257 end; 1258 1259 if i > hbound (condition_name, 1) 1260 then do; 1261 call com_err_ (0, my_name, "Invalid condition name. ^[no^]^a", ^enabled, 1262 substr (prefix_string, token_start, token_length)); 1263 return ("0"b); 1264 end; 1265 1266 /* The variable i never equals 10. This takes advantage of the condition_name 1267* array encoding. This is the same algorithm that statement_type uses. The 1268* long names and short names of the conditions are stored in the same array. 1269* The indices of the long name and the short name differ by 10. The size 1270* condition has the same long name and short name. */ 1271 1272 i = mod (i, 10); 1273 1274 if substr (prefix.mask, i, 1) 1275 then if substr (prefix.conditions, i, 1) ^= enabled 1276 then do; 1277 call com_err_ (0, my_name, 1278 "A condition may not be enabled and disabled in the prefix string. ^a", condition_name (i)); 1279 return ("0"b); 1280 end; 1281 else ; 1282 else do; 1283 substr (prefix.mask, i, 1) = "1"b; 1284 substr (prefix.conditions, i, 1) = enabled; 1285 1286 if substr (pl1_stat_$options, length (pl1_stat_$options)) ^= "(" 1287 then pl1_stat_$options = pl1_stat_$options || ","; 1288 1289 if ^enabled 1290 then pl1_stat_$options = pl1_stat_$options || "no"; 1291 1292 pl1_stat_$options = pl1_stat_$options || rtrim (condition_name (i)); 1293 end; 1294 1295 call skip_white_space; 1296 1297 return ("1"b); 1298 1299 skip_white_space: 1300 procedure; 1301 1302 declare scan_length fixed bin (21); 1303 1304 scan_length = verify (substr (prefix_string, scan_position), HT_SP) - 1; 1305 if scan_length < 0 1306 then scan_length = length (substr (prefix_string, scan_position)); 1307 1308 scan_position = scan_position + scan_length; 1309 end skip_white_space; 1310 1311 end parse_condition_name; 1312 1313 end parse_prefix; 1314 1315 generate_code: 1316 procedure (translation_failed); 1317 1318 declare translation_failed bit (1) aligned; 1319 1320 translation_failed = "0"b; 1321 1322 if pl1_stat_$greatest_severity >= 3 1323 then do; 1324 call com_err_ (0, my_name, "An error of severity ^d has occurred.", pl1_stat_$greatest_severity); 1325 1326 if ca.debug_cg 1327 then do; 1328 call ioa_$nnl ("debug for -debug_cg: "); 1329 call debug; 1330 end; 1331 1332 translation_failed = "1"b; 1333 return; 1334 end; 1335 1336 if pl1_stat_$table | pl1_stat_$generate_symtab 1337 then do; 1338 pl1_stat_$phase = 3; 1339 call prepare_symbol_table (pl1_stat_$root); 1340 end; 1341 1342 if ca.optimize 1343 then do; 1344 pl1_stat_$phase = 4; 1345 call optimizer (pl1_stat_$root); 1346 end; 1347 1348 call cpu_time_and_paging_ (npages (4), ncpu (4), pd_faults); 1349 call set_storage_usage (storage (4), xeq_storage (4)); 1350 1351 call tssi_$get_segment (wdirname, objectname, output_pt, object_hold, code); 1352 if output_pt = null 1353 then do; 1354 call com_err_ (code, my_name, "^a^[>^]^a", wdirname, wdirname ^= ">", objectname); 1355 translation_failed = "1"b; 1356 return; 1357 end; 1358 1359 if baseno (output_pt) = baseno (source_seg) 1360 then do; 1361 call com_err_ (0, my_name, 1362 "The source segment is the same as the object segment. It has been truncated. ^a", pathname); 1363 translation_failed = "1"b; 1364 return; 1365 end; 1366 1367 if ^ca.profile & ^ca.long_profile 1368 then pl1_stat_$profile_length = 0; 1369 1370 if ca.debug_cg 1371 then do; 1372 call ioa_$nnl ("Beginning code generator.^/debug: "); 1373 call debug; 1374 end; 1375 1376 in_cg = "1"b; 1377 pl1_stat_$phase = 5; 1378 1379 call code_gen_ (pl1_stat_$seg_name, (my_name), version, pl1_stat_$root, pl1_stat_$validate_proc, 1380 pl1_stat_$temporary_list, pl1_stat_$constant_list, pl1_stat_$ok_list, output_pt, clock_time, 1381 pl1_stat_$profile_length, produce_listing, symbols_on, pl1_stat_$print_cp_dcl, ca.map, ca.list, 1382 pl1_stat_$table, pl1_stat_$generate_symtab, pl1_symbol_print, error_$finish, objectbc, npages (5), 1383 ncpu (5), ca.link, pl1_stat_$dummy_block, ca.brief_table, npages (6), ncpu (6), ca.long_profile); 1384 1385 in_cg = "0"b; 1386 called_cg = "1"b; 1387 end generate_code; 1388 1389 print_times: 1390 procedure; 1391 1392 declare need_nl bit (1) aligned; 1393 declare tx float bin; 1394 declare ty float bin; 1395 1396 ty = -1e0; 1397 do i = hbound (ncpu, 1) to 1 by -1 while (ty < 0e0); 1398 ty = ncpu (i) - ncpu (0); 1399 end; 1400 1401 if ty <= 0e0 1402 then do; 1403 call com_err_ (0, my_name, "No times available."); 1404 return; 1405 end; 1406 1407 call ioa_ ("^/Segment ^a (^d lines) was compiled by ^a on ^a", pl1_stat_$seg_name, pl1_stat_$line_count, 1408 my_name, comptime); 1409 1410 call how_many_users; 1411 1412 call ioa_ ("^/Phase CPU % Pages Tree Xeq_tree"); 1413 1414 do i = 1 to hbound (npages, 1); 1415 if npages (i) < 0 1416 then do; 1417 ncpu (i) = ncpu (i - 1); 1418 npages (i) = npages (i - 1); 1419 storage (i) = storage (i - 1); 1420 xeq_storage (i) = xeq_storage (i - 1); 1421 end; 1422 1423 tx = ncpu (i) - ncpu (i - 1); 1424 call ioa_ ("^9a^9.3f^6.1f^6d ^10a ^10a", phase_name (i), tx / 1.0e6, 1.0e2 * tx / ty, 1425 npages (i) - npages (i - 1), storage (i), xeq_storage (i)); 1426 end; 1427 1428 call ioa_ ("TOTAL ^9.3f ^6d", ty / 1.0e6, npages (7) - npages (0)); 1429 1430 call ioa_ ("^/Summary of node usage in ^d free segments^/", number_free_segs); 1431 call ioa_ ((2)"NODE TYPE NUMBER SIZE TOTAL^8x"); 1432 1433 need_nl = "0"b; 1434 do i = 1 to pl1_stat_$max_node_type; 1435 if pl1_stat_$node_uses (i) ^= 0 1436 then do; 1437 call ioa_$nnl ("^12a^6d^6d^8d^[^/^;^8x^]", pl1_stat_$node_name (i), pl1_stat_$node_uses (i), 1438 pl1_stat_$node_size (i), pl1_stat_$node_uses (i) * pl1_stat_$node_size (i), need_nl); 1439 need_nl = ^need_nl; 1440 end; 1441 end; 1442 1443 call ioa_ ("^[^/^]", need_nl); 1444 end print_times; 1445 1446 truncate: 1447 procedure; 1448 1449 call lex$terminate_source; 1450 call tree_manager$truncate; 1451 1452 if object_hold ^= null 1453 then call tssi_$clean_up_segment (object_hold); 1454 1455 if list_hold ^= null 1456 then call tssi_$clean_up_file (fcb, list_hold); 1457 end truncate; 1458 1459 set_storage_usage: 1460 procedure (tree_used, xeq_tree_used); 1461 1462 declare tree_used char (*); 1463 declare xeq_tree_used char (*); 1464 1465 declare n fixed bin; 1466 1467 tree_used = char (binary (pl1_stat_$tree_area_ptr -> area_header.next_virgin, 18), 10); 1468 1469 number_free_segs = count_components (pl1_stat_$tree_area_ptr); 1470 if number_free_segs > 1 1471 then substr (tree_used, 1, 3) = "(" || convert (digit_pic, number_free_segs) || ")"; 1472 1473 xeq_tree_used = char (binary (pl1_stat_$xeq_tree_area_ptr -> area_header.next_virgin, 18), 10); 1474 1475 n = count_components (pl1_stat_$xeq_tree_area_ptr); 1476 if n > 1 1477 then substr (xeq_tree_used, 1, 3) = "(" || convert (digit_pic, n) || ")"; 1478 1479 number_free_segs = number_free_segs + n; 1480 1481 return; 1482 1483 count_components: 1484 procedure (areap) returns (fixed bin); 1485 1486 declare areap ptr; 1487 1488 declare p ptr; 1489 declare i fixed bin; 1490 1491 i = 0; 1492 do p = areap repeat addrel (p, p -> area_header.extend_info) -> extend_block.next_area while (p ^= null); 1493 i = i + 1; 1494 end; 1495 1496 return (i); 1497 end count_components; 1498 1499 end set_storage_usage; 1500 1501 end v2pl1; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 09/19/89 1011.9 v2pl1.pl1 >spec>install>1068>v2pl1.pl1 368 1 08/13/81 2043.5 condition_name.incl.pl1 >ldd>include>condition_name.incl.pl1 369 2 09/14/81 1347.6 area_structures.incl.pl1 >ldd>include>area_structures.incl.pl1 370 3 03/10/77 1345.4 pl1_version.incl.pl1 >ldd>include>pl1_version.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. HT_SP constant char(2) initial packed unaligned dcl 218 ref 1200 1304 HT_SP_COMMA 000134 constant char(3) initial packed unaligned dcl 219 ref 1235 addrel builtin function dcl 207 ref 1494 area_header based structure level 1 dcl 2-8 areap parameter pointer dcl 1486 ref 1483 1492 arg_count 000101 automatic fixed bin(17,0) dcl 121 set ref 376* 449 689 719 1038* 1045 1058* 1065 1082* 1091 1114 arg_length 000102 automatic fixed bin(21,0) dcl 122 set ref 450* 457 457 457 464 464 470 470 477 477 484 484 491 491 497 497 503 503 513 513 519 519 525 531 531 537 537 543 543 549 549 555 555 555 560 560 560 565 565 572 572 579 579 586 586 592 592 598 604 610 610 616 616 622 622 630 630 636 636 642 642 648 654 660 660 666 666 672 677 681 686 706 706 712 1092* 1099 1105 1111 1130 1132 1132 arg_ptr 000104 automatic pointer dcl 123 set ref 450* 457 457 457 464 464 470 470 477 477 484 484 491 491 497 497 503 503 513 513 519 519 525 531 531 537 537 543 543 549 549 555 555 560 560 565 565 572 572 579 579 586 586 592 592 598 604 610 610 616 616 622 622 630 630 636 636 642 642 648 654 660 660 666 666 672 677 681 686 706 712 1092* 1099 1105 1111 1130 1132 arg_string parameter char packed unaligned dcl 1172 in procedure "parse_severity" set ref 1169 1177 1177 1183* arg_string based char packed unaligned dcl 199 in procedure "pl1" set ref 457 457 457 464 464 470 470 477 477 484 484 491 491 497 497 503 503 513 513 519 519 525 531 531 537 537 543 543 549 549 555 555* 560 560* 565 565 572 572 579 579 586 586 592 592 598 604 610 610 616 616 622 622 630 630 636 636 642 642 648 654 660 660 666 666 672 677 681 686 706* 712 1099 1105 1111 1130 1132* argument_no 000100 automatic fixed bin(17,0) dcl 120 set ref 448* 711* 711 712 717 1090* 1136* 1136 1139 baseno builtin function dcl 207 ref 1359 1359 before builtin function dcl 207 ref 831 832 binary builtin function dcl 207 ref 1467 1473 bitcnt 000106 automatic fixed bin(24,0) dcl 124 set ref 817* 824 836 blast_ca 000107 automatic structure level 1 packed packed unaligned dcl 125 set ref 1089* 1139 blast_msg based char packed unaligned dcl 200 ref 1160 blast_msg_len 000110 automatic fixed bin(21,0) dcl 129 set ref 1120* 1160 blast_msg_ptr 000112 automatic pointer dcl 130 set ref 1120* 1160 blast_time 000010 internal static fixed bin(71,0) initial dcl 220 set ref 838 842* brief 15 000114 automatic bit(1) level 2 dcl 131 set ref 545* 551* 771 brief_table 3 000114 automatic bit(1) level 2 dcl 131 set ref 473* 480* 487* 731 742 1379* ca 000114 automatic structure level 1 dcl 131 set ref 447* called_cg 000157 automatic bit(1) dcl 168 set ref 429* 974 983 1386* cg_static_$debug 000202 external static bit(1) dcl 237 set ref 795* 854 1018 cg_static_$in_prologue 000204 external static bit(1) dcl 238 set ref 429* cg_static_$in_thunk 000206 external static bit(1) dcl 239 set ref 429* cg_static_$optimize 000210 external static bit(1) dcl 240 set ref 738* cg_static_$separate_static 000212 external static bit(1) dcl 241 set ref 785* cg_static_$stop_id 000214 external static bit(27) packed unaligned dcl 242 set ref 441* cg_static_$support 000216 external static bit(1) dcl 243 set ref 429* char builtin function dcl 207 ref 1467 1473 check 6 000114 automatic bit(1) level 2 dcl 131 set ref 494* 500* 749 967 985 1001 check_ansi 26 000114 automatic bit(1) level 2 dcl 131 set ref 601* 607* 789 cleanup 000432 stack reference condition dcl 213 ref 852 clock builtin function dcl 207 ref 842 846 1161 clock_time 000160 automatic fixed bin(71,0) dcl 169 set ref 846* 847* 1379* code 000162 automatic fixed bin(35,0) dcl 170 set ref 376* 377 379* 410* 411 413* 433* 450* 451 453* 695* 696 698* 817* 820* 827* 872* 875* 876* 880* 881 883* 884* 914* 917* 920 922* 995* 997 997* 1003* 1004 1004* 1007* 1008 1008* 1038* 1039 1041* 1058* 1059 1061* 1082* 1083 1085* 1092* 1093 1095* 1120* 1121 1123* 1351* 1354* code_gen_ 000416 constant entry external dcl 314 ref 1379 code_gen_$return_bit_count 000420 constant entry external dcl 320 ref 925 codeptr builtin function dcl 207 ref 410 410 com_err_ 000456 constant entry external dcl 338 ref 379 385 386 413 453 691 698 706 820 826 866 875 883 922 970 997 1004 1008 1030 1041 1061 1085 1095 1116 1123 1132 1147 1183 1211 1241 1261 1277 1324 1354 1361 1403 com_err_$suppress_name 000460 constant entry external dcl 339 ref 719 1047 1067 1141 component 000163 automatic fixed bin(17,0) dcl 171 set ref 864* 912* 912 914* 922* 995* component_bit_count 000100 automatic fixed bin(24,0) dcl 910 set ref 914* comptime 000012 internal static varying char(64) dcl 221 set ref 847* 896 1407* condition_ 000462 constant entry external dcl 340 ref 945 condition_name 000000 constant char(16) initial array packed unaligned dcl 1-7 set ref 1255 1255 1255 1259 1277* 1292 conditions 1 000334 automatic bit(12) level 2 dcl 185 set ref 1274 1284* convert builtin function dcl 207 ref 773 1470 1476 cpdcls 36 000114 automatic bit(1) level 2 dcl 131 set ref 651* 657* 791 792 cpu_time_and_paging_ 000470 constant entry external dcl 343 ref 391 947 951 964 976 1012 1348 cu_$arg_count 000464 constant entry external dcl 341 ref 376 1038 1058 1082 cu_$arg_ptr 000466 constant entry external dcl 342 ref 450 695 1092 1120 date_time_$format 000472 constant entry external dcl 344 ref 847 debug 32 000114 automatic bit(1) level 2 in structure "ca" dcl 131 in procedure "pl1" set ref 625* 633* 795 debug 000474 constant entry external dcl 345 in procedure "pl1" ref 957 1329 1373 debug_cg 34 000114 automatic bit(1) level 2 dcl 131 set ref 627* 645* 795 1326 1370 debug_semant 33 000114 automatic bit(1) level 2 dcl 131 set ref 626* 639* 795 796 954 digit_pic based picture(1) packed unaligned dcl 201 ref 773 1470 1476 divide builtin function dcl 207 ref 836 1003 1003 enabled 000520 automatic bit(1) dcl 1228 set ref 1248* 1249 1261 1274 1284 1289 error_$finish 000422 constant entry external dcl 321 ref 991 1379 1379 error_messages 000034 internal static pointer initial dcl 222 set ref 399 410* 418 error_messages_name 000451 automatic char(32) packed unaligned dcl 401 set ref 406* 408* 410* 413* error_table_$badopt 000220 external static fixed bin(35,0) dcl 244 set ref 706* 1132* error_table_$entlong 000222 external static fixed bin(35,0) dcl 245 set ref 866* error_table_$inconsistent 000224 external static fixed bin(35,0) dcl 246 set ref 1147* error_table_$translation_failed 000226 external static fixed bin(35,0) dcl 247 set ref 386* 970* error_table_$zero_length_seg 000230 external static fixed bin(35,0) dcl 249 set ref 826* extend_block based structure level 1 dcl 2-38 extend_info 26 based bit(18) level 2 packed packed unaligned dcl 2-8 ref 1494 fcb 000164 automatic pointer dcl 172 set ref 872* 914* 995* 1455* find_source_file_ 000476 constant entry external dcl 346 ref 817 get_group_id_ 000502 constant entry external dcl 348 ref 404 get_line_length_$switch 000500 constant entry external dcl 347 ref 433 get_wdir_ 000504 constant entry external dcl 349 ref 845 hbound builtin function dcl 207 ref 393 1255 1259 1397 1414 hcs_$get_max_length_seg 000506 constant entry external dcl 350 ref 880 917 hcs_$make_ptr 000510 constant entry external dcl 351 ref 410 hcs_$terminate_noname 000512 constant entry external dcl 352 ref 827 876 884 hcs_$truncate_seg 000514 constant entry external dcl 353 ref 1003 how_many_users 000516 constant entry external dcl 354 ref 1410 i 000166 automatic fixed bin(17,0) dcl 173 in procedure "pl1" set ref 393* 394* 423* 424* 449* 450* 453* 688* 688 689 695* 698* 1091* 1092* 1095* 1113* 1113 1114 1120* 1123* 1397* 1398* 1414* 1415 1417 1417 1418 1418 1419 1419 1420 1420 1423 1423 1424 1424 1424 1424 1424* 1434* 1435 1437 1437 1437 1437 1437* i 000574 automatic fixed bin(17,0) dcl 1489 in procedure "count_components" set ref 1491* 1493* 1493 1496 i 000521 automatic fixed bin(17,0) dcl 1229 in procedure "parse_condition_name" set ref 1255* 1255* 1259 1272* 1272 1274 1274 1277 1283 1284 1292 in_cg 000167 automatic bit(1) dcl 174 set ref 429* 925 1376* 1385* index builtin function dcl 207 ref 457 555 560 1130 1177 1248 installation_id 000461 automatic char(32) packed unaligned dcl 862 set ref 894* 895 ioa_ 000520 constant entry external dcl 355 ref 722 724 804 806 841 1165 1407 1412 1424 1428 1430 1431 1443 ioa_$nnl 000522 constant entry external dcl 356 ref 956 1328 1372 1437 lbound builtin function dcl 207 ref 1255 len 000170 automatic fixed bin(21,0) dcl 175 set ref 836* 949 949 length builtin function dcl 207 ref 866 898 1177 1177 1177 1208 1236 1251 1252 1286 1305 lex$terminate_source 000424 constant entry external dcl 322 ref 1449 link 40 000114 automatic bit(1) level 2 dcl 131 set ref 663* 669* 798 1379* list 13 000114 automatic bit(1) level 2 dcl 131 set ref 509* 534* 761 768 1379* list_hold 000172 automatic pointer dcl 176 set ref 849* 872* 995* 1072* 1455 1455* list_size 000174 automatic fixed bin(19,0) dcl 177 set ref 880* 888 917* 933 listing_overflow 000440 stack reference condition dcl 214 ref 907 listname 000175 automatic char(32) packed unaligned dcl 178 set ref 870* 872* 875* 883* 922* 997* lname 000205 automatic varying char(32) dcl 179 set ref 865* 866 866* 870 long 16 000114 automatic bit(1) level 2 dcl 131 set ref 546* 552* long_profile 22 000114 automatic bit(1) level 2 dcl 131 set ref 569* 576* 583* 780 783 1367 1379* ltrim builtin function dcl 207 ref 814 map 12 000114 automatic bit(1) level 2 dcl 131 set ref 508* 528* 758 768 1379* mask 000334 automatic bit(12) level 2 dcl 185 set ref 1274 1283* mod builtin function dcl 207 ref 1272 msf_manager_$get_ptr 000524 constant entry external dcl 357 ref 914 my_name 000214 constant char(3) initial packed unaligned dcl 223 set ref 379* 385* 386* 413* 420 453* 691* 698* 706* 719* 719* 820* 826* 866* 875* 883* 922* 970* 997* 1004* 1008* 1030* 1041* 1047* 1047* 1061* 1067* 1067* 1085* 1095* 1116* 1123* 1132* 1141* 1141* 1147* 1183* 1211* 1241* 1261* 1277* 1324* 1354* 1361* 1379 1403* 1407* n 000562 automatic fixed bin(17,0) dcl 1465 set ref 1475* 1476 1476 1479 ncpu 000036 internal static fixed bin(71,0) initial array dcl 224 set ref 391* 925* 925* 947* 951* 964* 976* 978* 978 1012* 1348* 1379* 1379* 1397 1398 1398 1417* 1417 1423 1423 need_nl 000550 automatic bit(1) dcl 1392 set ref 1433* 1437* 1439* 1439 1443* next_area 1 based pointer level 2 packed packed unaligned dcl 2-38 ref 1494 next_virgin 2 based bit(18) level 2 dcl 2-8 ref 1467 1473 no_check 5 000114 automatic bit(1) level 2 dcl 131 set ref 493* 499* no_check_ansi 25 000114 automatic bit(1) level 2 dcl 131 set ref 600* 606* no_cpdcls 35 000114 automatic bit(1) level 2 dcl 131 set ref 650* 656* no_debug 31 000114 automatic bit(1) level 2 dcl 131 set ref 624* 632* 638* 644* no_link 37 000114 automatic bit(1) level 2 dcl 131 set ref 662* 668* no_list 7 000114 automatic bit(1) level 2 dcl 131 set ref 505* 515* 521* 527* 533* 539* no_optimize 000114 automatic bit(1) level 2 dcl 131 set ref 460* 466* no_profile 20 000114 automatic bit(1) level 2 dcl 131 set ref 567* 574* 581* no_separate_static 23 000114 automatic bit(1) level 2 dcl 131 set ref 588* 594* no_table 2 000114 automatic bit(1) level 2 dcl 131 set ref 472* 479* 486* 731 no_time 27 000114 automatic bit(1) level 2 dcl 131 set ref 612* 618* no_version 42 000114 automatic bit(1) level 2 dcl 131 set ref 674* 679* 719 801 npages 000056 internal static fixed bin(17,0) array dcl 225 set ref 391* 393 394* 925* 925* 947* 951* 964* 976* 977* 977 1012* 1348* 1379* 1379* 1414 1415 1418* 1418 1424 1424 1428 1428 null builtin function dcl 207 ref 399 433 433 435 818 849 850 873 917 920 1071 1072 1352 1452 1455 1492 number_free_segs 000066 internal static fixed bin(17,0) dcl 226 set ref 397* 1430* 1469* 1470 1470 1479* 1479 object_hold 000216 automatic pointer dcl 180 set ref 850* 1007* 1071* 1351* 1452 1452* objectbc 000067 internal static fixed bin(24,0) dcl 227 set ref 925* 1003 1003 1007* 1379* objectname 000220 automatic char(32) packed unaligned dcl 181 set ref 831* 832* 832 834 865 891 1004* 1008* 1351* 1354* off 000107 automatic bit(1) level 2 packed packed unaligned dcl 125 set ref 1102* 1108* 1145 1154 on 0(01) 000107 automatic bit(1) level 2 packed packed unaligned dcl 125 set ref 1101* 1107* 1145 1147* 1151 optimize 1 000114 automatic bit(1) level 2 dcl 131 set ref 461* 467* 731 738 739 1342 optimizer 000426 constant entry external dcl 323 ref 1345 output_pt 000230 automatic pointer dcl 182 set ref 1003* 1007* 1351* 1352 1359 1379* p 000572 automatic pointer dcl 1488 set ref 1492* 1492* 1494 1494 parse 000430 constant entry external dcl 324 ref 949 pathname 000232 automatic char(256) packed unaligned dcl 183 set ref 712* 817* 820* 826* 833 1361* pd_faults 000332 automatic fixed bin(17,0) dcl 184 set ref 391* 947* 951* 964* 976* 1012* 1348* phase_name 000114 constant char(9) initial array packed unaligned dcl 228 set ref 1424* pl1_blast_$blast_message 000232 external static varying char(64) dcl 250 set ref 841* 1160* pl1_blast_$blast_on 000234 external static bit(1) dcl 251 set ref 838 1151* 1154* 1159* 1162* pl1_blast_$blast_time 000236 external static fixed bin(71,0) dcl 252 set ref 838 1161* pl1_print$non_varying 000432 constant entry external dcl 325 ref 900 pl1_print$non_varying_nl 000434 constant entry external dcl 326 ref 891 892 895 896 904 989 pl1_print$varying_nl 000436 constant entry external dcl 327 ref 901 pl1_severity_ 000240 external static fixed bin(35,0) dcl 253 set ref 374* 942* 1021* pl1_signal_catcher 000440 constant entry external dcl 328 ref 945 945 pl1_stat_$abort_label 000242 external static label variable dcl 254 set ref 427* 939* pl1_stat_$brief_error_mode 000244 external static bit(1) dcl 255 set ref 771* pl1_stat_$by_name_free_list 000246 external static pointer dcl 256 set ref 435* pl1_stat_$by_name_parts_free_list 000250 external static pointer dcl 257 set ref 435* pl1_stat_$by_name_parts_tree 000252 external static pointer dcl 259 set ref 435* pl1_stat_$by_name_ref_list 000254 external static pointer dcl 260 set ref 435* pl1_stat_$char_pos 000256 external static fixed bin(21,0) dcl 261 set ref 889* 934* 995 pl1_stat_$check_ansi 000260 external static bit(1) dcl 262 set ref 789* pl1_stat_$compiler_invoked 000262 external static bit(1) dcl 263 set ref 383 857* 943* 1023* 1075* pl1_stat_$compiler_name 000264 external static varying char(8) dcl 264 set ref 420* pl1_stat_$constant_list 000266 external static pointer dcl 265 set ref 435* 1379* pl1_stat_$debug_semant 000270 external static bit(1) dcl 266 set ref 796* pl1_stat_$defined_list 000272 external static pointer dcl 267 set ref 435* pl1_stat_$dummy_block 000274 external static pointer dcl 268 set ref 435* 1379* pl1_stat_$error_messages 000276 external static pointer dcl 269 set ref 418* pl1_stat_$error_width 000300 external static fixed bin(17,0) dcl 270 set ref 433* pl1_stat_$generate_symtab 000302 external static bit(1) dcl 271 set ref 429* 1336 1379* pl1_stat_$greatest_severity 000304 external static fixed bin(17,0) dcl 272 set ref 419* 942* 985 991 1021 1322 1324* pl1_stat_$index 000306 external static fixed bin(17,0) dcl 273 set ref 439* pl1_stat_$last_statement_id 000310 external static bit(36) packed unaligned dcl 274 set ref 429* pl1_stat_$line_count 000312 external static fixed bin(17,0) dcl 275 set ref 1407* pl1_stat_$list_ptr 000314 external static pointer dcl 276 set ref 872* 873 880* 914* 917 917* 920 pl1_stat_$listing_on 000316 external static bit(1) dcl 277 set ref 769* pl1_stat_$max_list_size 000320 external static fixed bin(21,0) dcl 278 set ref 888* 933* pl1_stat_$max_node_type 000322 external static fixed bin(17,0) dcl 279 ref 423 1434 pl1_stat_$new_fortran_option 000324 external static bit(1) dcl 280 set ref 429* pl1_stat_$node_name 000326 external static char(12) array packed unaligned dcl 281 set ref 1437* pl1_stat_$node_size 000330 external static fixed bin(17,0) array dcl 282 set ref 1437* 1437 pl1_stat_$node_uses 000332 external static fixed bin(17,0) array dcl 283 set ref 424* 1435 1437* 1437 pl1_stat_$ok_list 000334 external static pointer dcl 284 set ref 435* 1379* pl1_stat_$optimize 000336 external static bit(1) dcl 285 set ref 738* pl1_stat_$options 000340 external static varying char(400) dcl 286 set ref 736* 739* 739 742* 742 746* 746 749* 749 752* 752 755* 755 758* 758 761* 761 765* 765 773* 773 777* 777 780* 780 786* 786 792* 792 798* 798 814* 814 898 901* 1204* 1204 1221* 1221 1286 1286 1286* 1286 1289* 1289 1292* 1292 pl1_stat_$options_packed_dec 000342 external static bit(1) dcl 287 set ref 429* pl1_stat_$pathname 000344 external static varying char(168) dcl 288 set ref 833* pl1_stat_$phase 000346 external static fixed bin(17,0) dcl 289 set ref 941* 960* 1338* 1344* 1377* pl1_stat_$print_cp_dcl 000350 external static bit(1) dcl 290 set ref 791* 985* 1379* pl1_stat_$profile 000352 external static bit(1) dcl 291 set ref 783* pl1_stat_$profile_length 000354 external static fixed bin(17,0) dcl 292 set ref 439* 1367* 1379* pl1_stat_$root 000356 external static pointer dcl 293 set ref 949* 985* 1339* 1345* 1379* pl1_stat_$seg_name 000360 external static varying char(32) dcl 294 set ref 834* 1379* 1407* pl1_stat_$severity_plateau 000362 external static fixed bin(17,0) dcl 295 set ref 773 775* 1188* pl1_stat_$single_symbol_list 000364 external static bit(1) dcl 296 set ref 764* pl1_stat_$stop_id 000366 external static bit(27) packed unaligned dcl 297 set ref 441* pl1_stat_$table 000370 external static bit(1) dcl 298 set ref 745* 1336 1379* pl1_stat_$temporary_list 000372 external static pointer dcl 299 set ref 435* 1379* pl1_stat_$tree_area_ptr 000374 external static pointer dcl 300 set ref 1467 1469* pl1_stat_$unaligned_dec 000376 external static bit(1) dcl 301 set ref 429* pl1_stat_$use_old_area 000400 external static bit(1) dcl 302 set ref 421* pl1_stat_$user_id 000402 external static char(32) dcl 303 set ref 404* pl1_stat_$validate_proc 000404 external static pointer dcl 304 set ref 435* 1379* pl1_stat_$version 000406 external static fixed bin(17,0) dcl 305 set ref 443* pl1_stat_$xeq_tree_area_ptr 000410 external static pointer dcl 306 set ref 1473 1475* pl1_symbol_print 000442 constant entry external dcl 329 ref 985 1379 1379 pl1_version constant fixed bin(17,0) initial dcl 3-1 ref 443 pl1_version$pl1_release 000412 external static varying char(3) dcl 307 set ref 406 722 724* 804 806* pl1_version$pl1_version 000414 external static varying char(256) dcl 308 set ref 403 722* 804* 892 prefix parameter char packed unaligned dcl 1173 in procedure "parse_severity" ref 1169 1177 1177 prefix 000334 automatic structure level 1 dcl 185 in procedure "pl1" set ref 809* 949* prefix 41 000114 automatic bit(1) level 2 in structure "ca" dcl 131 in procedure "pl1" set ref 683* 702* 810 prefix_string based char packed unaligned dcl 202 in procedure "pl1" set ref 810* prefix_string parameter char packed unaligned dcl 1196 in procedure "parse_prefix" set ref 1193 1200 1208 1209 1211* 1235 1236 1241* 1248 1255 1261 1261 1304 1305 prefix_string_length 000336 automatic fixed bin(21,0) dcl 188 set ref 695* 810 810 prefix_string_ptr 000340 automatic pointer dcl 189 set ref 695* 810 prepare_symbol_table 000444 constant entry external dcl 330 ref 1339 produce_listing 000342 automatic bit(1) dcl 190 set ref 769* 860 907 981 1379* profile 21 000114 automatic bit(1) level 2 dcl 131 set ref 568* 575* 582* 777 783 1367 rtrim builtin function dcl 207 ref 834 865 891 1177 1292 scan_length 000532 automatic fixed bin(21,0) dcl 1302 set ref 1304* 1305 1305* 1308 scan_position 000510 automatic fixed bin(21,0) dcl 1198 set ref 1200* 1201 1208 1209 1215* 1215 1235 1236 1245 1246* 1246 1304 1305 1308* 1308 scan_token_table 000446 constant entry external dcl 331 ref 962 search builtin function dcl 207 ref 1235 semantic_translator 000450 constant entry external dcl 332 ref 961 separate_static 24 000114 automatic bit(1) level 2 dcl 131 set ref 589* 595* 785 786 set 0(02) 000107 automatic bit(1) level 2 packed packed unaligned dcl 125 set ref 1127* 1145 1157 severity 000500 automatic fixed bin(17,0) dcl 1175 in procedure "parse_severity" set ref 1177* 1179* 1181 1188 severity 17 000114 automatic bit(1) level 2 in structure "ca" dcl 131 in procedure "pl1" set ref 773 1187* single_symbol_list 14 000114 automatic bit(1) level 2 dcl 131 set ref 510* 540* 764 765 768 source 10 000114 automatic bit(1) level 2 dcl 131 set ref 506* 516* 752 769 source_seg 000344 automatic pointer dcl 191 set ref 817* 818 827* 876* 884* 949 1359 source_string based char packed unaligned dcl 203 set ref 949* sourcename 000346 automatic char(32) packed unaligned dcl 192 set ref 817* 831 970* storage 000070 internal static char(10) initial array packed unaligned dcl 231 set ref 952* 965* 1013* 1015 1015* 1015* 1349* 1419* 1419 1424* string builtin function dcl 207 set ref 1089* 1139 substr builtin function dcl 207 set ref 1177 1209 1235 1236 1248 1255 1261 1261 1274 1274 1283* 1284* 1286 1304 1305 1470* 1476* symbols 11 000114 automatic bit(1) level 2 dcl 131 set ref 507* 522* 755 768 symbols_on 000356 automatic bit(1) dcl 193 set ref 768* 769 985 1379* system_info_$installation_id 000526 constant entry external dcl 358 ref 894 table 4 000114 automatic bit(1) level 2 dcl 131 set ref 474* 481* 488* 731* 745 746 time 30 000114 automatic bit(1) level 2 dcl 131 set ref 613* 619* 1025 token_length 000522 automatic fixed bin(21,0) dcl 1230 set ref 1235* 1236 1236* 1239 1246 1248 1252* 1252 1255 1261 1261 token_start 000523 automatic fixed bin(21,0) dcl 1231 set ref 1245* 1248 1251* 1251 1255 1261 1261 translation_failed 000357 automatic bit(1) dcl 194 in procedure "pl1" set ref 429* 929* 967* 970 985 1001 1032* translation_failed parameter bit(1) dcl 1318 in procedure "generate_code" set ref 1315 1320* 1332* 1355* 1363* tree_manager$init 000452 constant entry external dcl 333 ref 939 tree_manager$truncate 000454 constant entry external dcl 334 ref 1450 tree_used parameter char packed unaligned dcl 1462 set ref 1459 1467* 1470* tssi_$clean_up_file 000530 constant entry external dcl 359 ref 1455 tssi_$clean_up_segment 000532 constant entry external dcl 360 ref 1452 tssi_$finish_file 000534 constant entry external dcl 361 ref 995 tssi_$finish_segment 000536 constant entry external dcl 362 ref 1007 tssi_$get_file 000540 constant entry external dcl 363 ref 872 tssi_$get_segment 000542 constant entry external dcl 364 ref 1351 tx 000551 automatic float bin(27) dcl 1393 set ref 1423* 1424 1424 ty 000552 automatic float bin(27) dcl 1394 set ref 1396* 1397 1398* 1401 1424 1428 verify builtin function dcl 207 ref 1200 1304 version 000114 internal static varying char(132) dcl 232 set ref 403* 1379* wdirname 000360 automatic char(168) packed unaligned dcl 195 set ref 845* 872* 875* 875 883* 883 922* 922 997* 997 1004* 1004 1008* 1008 1351* 1354* 1354 xeq_storage 000156 internal static char(10) initial array packed unaligned dcl 233 set ref 952* 965* 1013* 1016 1016* 1016* 1349* 1420* 1420 1424* xeq_tree_used parameter char packed unaligned dcl 1463 set ref 1459 1473* 1476* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. NO_FREEING_ALLOCATION_METHOD internal static fixed bin(17,0) initial dcl 2-32 STANDARD_ALLOCATION_METHOD internal static fixed bin(17,0) initial dcl 2-32 alloc_blkhdrsz internal static fixed bin(17,0) initial dcl 2-45 area_version_1 internal static fixed bin(17,0) initial dcl 2-4 areap automatic pointer dcl 2-6 block based structure level 1 dcl 2-52 blockp automatic pointer dcl 2-50 extend_blockp automatic pointer dcl 2-36 min_block_size internal static fixed bin(17,0) initial dcl 2-63 no_free_area_header based structure level 1 dcl 2-46 NAMES DECLARED BY EXPLICIT CONTEXT. abort_return 006350 constant label dcl 1030 ref 427 blast 006604 constant entry external dcl 1079 clean_up 006500 constant entry external dcl 1055 close_list 005765 constant label dcl 995 ref 930 continue_from_abort 005630 constant label dcl 970 ref 1033 count_components 011661 constant entry internal dcl 1483 ref 1469 1475 generate_code 010236 constant entry internal dcl 1315 ref 967 parse_condition_name 007613 constant entry internal dcl 1225 ref 1206 1217 parse_prefix 007441 constant entry internal dcl 1193 ref 810 parse_severity 007322 constant entry internal dcl 1169 ref 555 560 pl1 001275 constant entry external dcl 113 pl1exl 001313 constant entry external dcl 113 print_times 010735 constant entry internal dcl 1389 ref 1025 1051 set_storage_usage 011474 constant entry internal dcl 1459 ref 952 965 1013 1349 skip_white_space 010206 constant entry internal dcl 1299 ref 1233 1295 times 006401 constant entry external dcl 1035 truncate 011423 constant entry internal dcl 1446 ref 854 1018 1074 v2pl1 001304 constant entry external dcl 113 ref 410 410 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 14046 14612 12343 14056 Length 15466 12343 544 640 1503 172 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME pl1 994 external procedure is an external procedure. begin block on line 399 begin block shares stack frame of external procedure pl1. on unit on line 852 64 on unit begin block on line 860 begin block shares stack frame of external procedure pl1. on unit on line 907 110 on unit parse_severity internal procedure shares stack frame of external procedure pl1. parse_prefix internal procedure shares stack frame of external procedure pl1. parse_condition_name internal procedure shares stack frame of external procedure pl1. skip_white_space internal procedure shares stack frame of external procedure pl1. generate_code internal procedure shares stack frame of external procedure pl1. print_times internal procedure shares stack frame of external procedure pl1. truncate 74 internal procedure is called by several nonquick procedures. set_storage_usage internal procedure shares stack frame of external procedure pl1. count_components internal procedure shares stack frame of external procedure pl1. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 blast_time pl1 000012 comptime pl1 000034 error_messages pl1 000036 ncpu pl1 000056 npages pl1 000066 number_free_segs pl1 000067 objectbc pl1 000070 storage pl1 000114 version pl1 000156 xeq_storage pl1 STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME on unit on line 907 000100 component_bit_count on unit on line 907 pl1 000100 argument_no pl1 000101 arg_count pl1 000102 arg_length pl1 000104 arg_ptr pl1 000106 bitcnt pl1 000107 blast_ca pl1 000110 blast_msg_len pl1 000112 blast_msg_ptr pl1 000114 ca pl1 000157 called_cg pl1 000160 clock_time pl1 000162 code pl1 000163 component pl1 000164 fcb pl1 000166 i pl1 000167 in_cg pl1 000170 len pl1 000172 list_hold pl1 000174 list_size pl1 000175 listname pl1 000205 lname pl1 000216 object_hold pl1 000220 objectname pl1 000230 output_pt pl1 000232 pathname pl1 000332 pd_faults pl1 000334 prefix pl1 000336 prefix_string_length pl1 000340 prefix_string_ptr pl1 000342 produce_listing pl1 000344 source_seg pl1 000346 sourcename pl1 000356 symbols_on pl1 000357 translation_failed pl1 000360 wdirname pl1 000451 error_messages_name begin block on line 399 000461 installation_id begin block on line 860 000500 severity parse_severity 000510 scan_position parse_prefix 000520 enabled parse_condition_name 000521 i parse_condition_name 000522 token_length parse_condition_name 000523 token_start parse_condition_name 000532 scan_length skip_white_space 000550 need_nl print_times 000551 tx print_times 000552 ty print_times 000562 n set_storage_usage 000572 p count_components 000574 i count_components THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_ne_as r_ge_a alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this call_int_other begin_return_mac return_mac tra_ext_1 mdfx1 enable_op shorten_stack ext_entry int_entry set_chars_eis index_chars_eis index_before_cs clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. code_gen_ code_gen_$return_bit_count com_err_ com_err_$suppress_name condition_ cpu_time_and_paging_ cu_$arg_count cu_$arg_ptr date_time_$format debug error_$finish find_source_file_ get_group_id_ get_line_length_$switch get_wdir_ hcs_$get_max_length_seg hcs_$make_ptr hcs_$terminate_noname hcs_$truncate_seg how_many_users ioa_ ioa_$nnl lex$terminate_source msf_manager_$get_ptr optimizer parse pl1_print$non_varying pl1_print$non_varying_nl pl1_print$varying_nl pl1_signal_catcher pl1_symbol_print prepare_symbol_table scan_token_table semantic_translator system_info_$installation_id tree_manager$init tree_manager$truncate tssi_$clean_up_file tssi_$clean_up_segment tssi_$finish_file tssi_$finish_segment tssi_$get_file tssi_$get_segment THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cg_static_$debug cg_static_$in_prologue cg_static_$in_thunk cg_static_$optimize cg_static_$separate_static cg_static_$stop_id cg_static_$support error_table_$badopt error_table_$entlong error_table_$inconsistent error_table_$translation_failed error_table_$zero_length_seg pl1_blast_$blast_message pl1_blast_$blast_on pl1_blast_$blast_time pl1_severity_ pl1_stat_$abort_label pl1_stat_$brief_error_mode pl1_stat_$by_name_free_list pl1_stat_$by_name_parts_free_list pl1_stat_$by_name_parts_tree pl1_stat_$by_name_ref_list pl1_stat_$char_pos pl1_stat_$check_ansi pl1_stat_$compiler_invoked pl1_stat_$compiler_name pl1_stat_$constant_list pl1_stat_$debug_semant pl1_stat_$defined_list pl1_stat_$dummy_block pl1_stat_$error_messages pl1_stat_$error_width pl1_stat_$generate_symtab pl1_stat_$greatest_severity pl1_stat_$index pl1_stat_$last_statement_id pl1_stat_$line_count pl1_stat_$list_ptr pl1_stat_$listing_on pl1_stat_$max_list_size pl1_stat_$max_node_type pl1_stat_$new_fortran_option pl1_stat_$node_name pl1_stat_$node_size pl1_stat_$node_uses pl1_stat_$ok_list pl1_stat_$optimize pl1_stat_$options pl1_stat_$options_packed_dec pl1_stat_$pathname pl1_stat_$phase pl1_stat_$print_cp_dcl pl1_stat_$profile pl1_stat_$profile_length pl1_stat_$root pl1_stat_$seg_name pl1_stat_$severity_plateau pl1_stat_$single_symbol_list pl1_stat_$stop_id pl1_stat_$table pl1_stat_$temporary_list pl1_stat_$tree_area_ptr pl1_stat_$unaligned_dec pl1_stat_$use_old_area pl1_stat_$user_id pl1_stat_$validate_proc pl1_stat_$version pl1_stat_$xeq_tree_area_ptr pl1_version$pl1_release pl1_version$pl1_version LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 113 001274 374 001320 376 001322 377 001332 379 001334 380 001351 383 001352 385 001355 386 001401 388 001425 391 001426 393 001440 394 001445 395 001451 397 001453 399 001455 403 001461 404 001473 406 001506 408 001520 410 001523 411 001554 413 001556 414 001605 418 001607 419 001612 420 001614 421 001621 423 001622 424 001631 425 001634 427 001636 429 001643 433 001656 435 001672 439 001706 441 001710 443 001713 447 001715 448 001760 449 001761 450 001771 451 002006 453 002010 454 002041 457 002042 460 002066 461 002070 462 002071 464 002072 466 002102 467 002103 468 002105 470 002106 472 002116 473 002120 474 002121 475 002122 477 002123 479 002133 480 002134 481 002136 482 002137 484 002140 486 002150 487 002151 488 002152 489 002154 491 002155 493 002165 494 002167 495 002170 497 002171 499 002201 500 002202 501 002204 503 002205 505 002215 506 002217 507 002220 508 002221 509 002222 510 002223 511 002224 513 002225 515 002235 516 002236 517 002240 519 002241 521 002251 522 002252 523 002254 525 002255 527 002261 528 002262 529 002264 531 002265 533 002275 534 002276 535 002300 537 002301 539 002311 540 002312 541 002314 543 002315 545 002325 546 002327 547 002330 549 002331 551 002341 552 002342 553 002344 555 002345 558 002410 560 002411 563 002451 565 002452 567 002463 568 002465 569 002466 570 002467 572 002470 574 002500 575 002501 576 002503 577 002504 579 002505 581 002515 582 002516 583 002517 584 002521 586 002522 588 002532 589 002534 590 002535 592 002536 594 002546 595 002547 596 002551 598 002552 600 002556 601 002560 602 002561 604 002562 606 002566 607 002567 608 002571 610 002572 612 002602 613 002604 614 002605 616 002606 618 002616 619 002617 620 002621 622 002622 624 002632 625 002634 626 002635 627 002636 628 002637 630 002640 632 002650 633 002651 634 002653 636 002654 638 002664 639 002665 640 002667 642 002670 644 002700 645 002701 646 002703 648 002704 650 002710 651 002712 652 002713 654 002714 656 002720 657 002721 658 002723 660 002724 662 002734 663 002736 664 002737 666 002740 668 002750 669 002751 670 002753 672 002754 674 002760 675 002761 677 002762 679 002766 680 002770 681 002771 683 002775 684 002776 686 002777 688 003003 689 003004 691 003007 692 003034 695 003035 696 003052 698 003054 699 003105 702 003106 703 003110 706 003111 707 003143 708 003144 711 003145 712 003146 715 003154 717 003156 719 003161 722 003217 724 003246 726 003264 731 003265 736 003276 738 003300 739 003303 742 003317 745 003335 746 003337 749 003353 752 003370 755 003405 758 003422 761 003440 764 003456 765 003460 768 003474 769 003505 771 003510 773 003512 775 003562 777 003565 780 003602 783 003620 785 003623 786 003625 789 003641 791 003643 792 003645 795 003661 796 003665 798 003667 801 003705 804 003710 806 003736 809 003754 810 003756 814 004002 817 004026 818 004064 820 004070 821 004117 824 004120 826 004122 827 004151 828 004162 831 004163 832 004202 833 004213 834 004222 836 004243 838 004247 841 004254 842 004273 845 004276 846 004304 847 004306 849 004353 850 004355 852 004356 854 004372 857 004401 858 004403 860 004404 864 004407 865 004410 866 004430 870 004463 872 004501 873 004535 875 004542 876 004610 877 004621 880 004623 881 004635 883 004637 884 004706 885 004717 888 004721 889 004725 891 004727 892 004772 894 005027 895 005041 896 005065 898 005120 900 005124 901 005147 904 005161 907 005177 912 005216 914 005220 917 005242 920 005262 922 005272 925 005343 929 005365 930 005370 933 005373 934 005376 935 005400 939 005401 941 005410 942 005413 943 005415 945 005417 947 005444 949 005457 951 005503 952 005516 954 005532 956 005534 957 005550 960 005555 961 005560 962 005564 964 005571 965 005604 967 005624 970 005630 974 005662 976 005664 977 005677 978 005702 981 005704 983 005707 985 005711 989 005740 991 005756 995 005765 997 006014 1001 006065 1003 006072 1004 006111 1007 006162 1008 006203 1012 006254 1013 006267 1015 006307 1016 006321 1018 006332 1021 006340 1023 006343 1025 006344 1028 006347 1030 006350 1032 006375 1033 006377 1035 006400 1038 006406 1039 006417 1041 006421 1042 006436 1045 006437 1047 006441 1048 006474 1051 006475 1053 006476 1055 006477 1058 006505 1059 006516 1061 006520 1062 006535 1065 006536 1067 006540 1068 006570 1071 006571 1072 006573 1074 006574 1075 006600 1077 006602 1079 006603 1082 006611 1083 006622 1085 006624 1086 006641 1089 006642 1090 006644 1091 006645 1092 006655 1093 006672 1095 006674 1096 006725 1099 006726 1101 006734 1102 006736 1103 006740 1105 006741 1107 006745 1108 006747 1109 006751 1111 006752 1113 006756 1114 006757 1116 006762 1117 007007 1120 007010 1121 007025 1123 007027 1124 007060 1127 007061 1128 007063 1130 007064 1132 007076 1133 007130 1136 007131 1137 007132 1139 007134 1141 007141 1142 007171 1145 007172 1147 007213 1148 007245 1151 007246 1154 007254 1157 007261 1159 007263 1160 007265 1161 007277 1162 007302 1165 007304 1167 007321 1169 007322 1177 007340 1179 007373 1181 007374 1183 007376 1184 007430 1187 007433 1188 007435 1190 007437 1193 007441 1200 007452 1201 007466 1204 007472 1206 007506 1208 007516 1209 007521 1211 007527 1212 007561 1215 007564 1217 007565 1219 007575 1221 007576 1223 007607 1225 007613 1233 007615 1235 007616 1236 007637 1239 007643 1241 007644 1242 007676 1245 007701 1246 007703 1248 007705 1249 007721 1251 007722 1252 007724 1255 007726 1257 007745 1259 007747 1261 007752 1263 010024 1272 010030 1274 010033 1277 010043 1279 010075 1281 010100 1283 010101 1284 010104 1286 010107 1289 010132 1292 010146 1295 010201 1297 010202 1299 010206 1304 010207 1305 010230 1308 010234 1309 010235 1315 010236 1320 010240 1322 010241 1324 010245 1326 010275 1328 010277 1329 010313 1332 010320 1333 010323 1336 010324 1338 010332 1339 010334 1342 010342 1344 010344 1345 010347 1348 010355 1349 010370 1351 010405 1352 010435 1354 010441 1355 010510 1356 010513 1359 010514 1361 010523 1363 010554 1364 010557 1367 010560 1370 010567 1372 010571 1373 010605 1376 010612 1377 010614 1379 010617 1385 010731 1386 010732 1387 010734 1389 010735 1396 010736 1397 010740 1398 010747 1399 010757 1401 010762 1403 010764 1404 011011 1407 011012 1410 011047 1412 011054 1414 011070 1415 011075 1417 011100 1418 011105 1419 011110 1420 011115 1423 011120 1424 011130 1426 011217 1428 011221 1430 011253 1431 011273 1433 011307 1434 011310 1435 011321 1437 011325 1439 011374 1441 011400 1443 011402 1444 011421 1446 011422 1449 011430 1450 011434 1452 011441 1455 011455 1457 011473 1459 011474 1467 011512 1469 011535 1470 011545 1473 011575 1475 011617 1476 011627 1479 011656 1481 011660 1483 011661 1491 011663 1492 011664 1493 011674 1494 011675 1496 011705 ----------------------------------------------------------- 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