COMPILATION LISTING OF SEGMENT pl1_symbol_print Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-18_1130.12_Tue_mdt 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 /****^ HISTORY COMMENTS: 16* 1) change(87-04-15,RWaters), approve(87-04-15,MCR7639), audit(87-04-28,Huen), 17* install(87-05-21,MR12.1-1033): 18* Fix bug #2092 19* 2) change(87-06-25,Huen), approve(87-06-25,MCR7696), audit(87-06-25,RWaters), 20* install(87-12-01,MR12.2-1005): 21* Fix bug2149 22* 3) change(88-01-29,RWaters), approve(88-01-29,MCR7724), audit(88-02-05,Huen), 23* install(88-02-16,MR12.2-1024): 24* Treat explicit_packed as packed. 25* 4) change(89-04-04,Huen), approve(89-04-04,MCR8092), audit(89-05-24,RWaters), 26* install(89-05-31,MR12.3-1050): 27* Fix bug2195 - Emit the "NAME DECLARED BY THE DECLARE STATEMENT AND NEVER 28* REFERENCED" section when all of the declared variables were not 29* referenced. Fix bug2194 - List only referenced external variables under 30* the "EXTERNAL VARIABLES ARE USED" section. 31* END HISTORY COMMENTS */ 32 33 /* Modified on: June 23 1975 by EEW for new object map 34* Modified 770404 by PG to explain why blocks are not quick. 35* Modified 5 May 1977 by SHW for new pl1_operator_names_ 36* Modified 14 July 1978 by PCK for unsigned binary 37* Modified Dec 1978 by David Spector: 38* 1. Fixed begin block/on unit 'on line xxx' bug 39* 2. New filling of last column out to 132 columns and indenting continuation lines 40* 3. Eliminated "internal" from builtin and generic functions 41* 4. Allowed more space on line for long identifiers 42* 5. Changed "uses condition statements" nonquick reason to "enables or reverts conditions" 43* 6. Containing-block qualification for duplicate identifiers 44* 7. Containing-structure qualification for duplicate identifiers 45* 8. Cross-reference lists ordered within each source input file 46* 9. Increased maximum number of symbols listed from 2500 to 3072 47* 10. Marked cross-references as 'set' or not 48* 11. Placed "unsigned" attribute after "packed" 49* 12. Fixed stringrange bug for long procedure names 50* 13. Storage tables for internal static and automatic variables 51* Modified 18 Jan 1979 by RAB to resume printing "set" if symbol.set is on 52* Modified 26 May 1979 by D. Spector for -single_symbol_list (-ssl) 53* Modified 26 May 1979 by D. Spector to not list undeclared level 2+ names 54* Modified 13 Nov 1979 by Peter Krupp to fix bug 1859 55* Modified 25 March 1980 by M. N. Davidoff to increase maximum number of symbols listed from 3072 to 4096. 56* Modified 830415 BIM to deal with tokens as labels rather than ref nodes. 57* Modified 860811 RW to not call "print" when "-ssl" flag is on when there are no symbols 58* Modified 870625 SH to print the negative scale factors correctly in the listing. 59* Modified 882801 RW to believe explicit_packed is also packed. 60* Modified 891703 SH to emit the "NAMES DECLARED BY THE DECLARE STATEMENT AND 61* NEVER REFERENCED" section when all of the declared variables were not 62* referenced. (pl1_2195) 63* Modified 891703 SH to list only referenced external variables under the 64* "EXTERNAL VARIABLES ARE USED" section. (pl1_2194) 65**/ 66 /* format: style3 */ 67 pl1_symbol_print: 68 proc (root, do_cp_dcl, no_object); 69 70 dcl root ptr, 71 (do_cp_dcl, no_object) 72 bit (1) aligned; 73 74 dcl digits_pic picture "-------9"; /* fixed decimal (8) */ 75 dcl (i, j, k, m, n, size, int_static_list_length, auto_list_length, unused, unused_members) 76 fixed bin (17), 77 (p, q) ptr, 78 line aligned char (132), 79 ( 80 dt1 (4) init (by_declare, by_explicit_context, by_context, by_compiler), 81 dt2 (4) init (by_declare, by_explicit_context, by_implication, by_compiler) 82 ) bit (3) aligned, 83 s char (1) varying, 84 declare_type (4) char (24) varying int static 85 init ("DECLARE STATEMENT.", "EXPLICIT CONTEXT.", "CONTEXT OR IMPLICATION.", "COMPILER."); 86 87 dcl pl1_stat_$single_symbol_list 88 bit (1) aligned external static; 89 dcl cg_static_$used_operator 90 bit (900) ext, 91 cg_static_$bit_count 92 fixed bin ext, 93 ( 94 cg_static_$ext_proc_list, 95 cg_static_$ext_var_list, 96 cg_static_$root, 97 cg_static_$objmap_pt 98 ) ptr ext, 99 pl1_operator_names_$pl1_operator_names_ 100 ext; 101 102 dcl 1 name_pair aligned based, 103 2 rel_ptr unaligned bit (18), 104 2 size unaligned bit (18); 105 106 dcl based_string aligned char (size) based; 107 108 dcl (addr, bin, divide, fixed, hbound, length, ltrim, index, mod) 109 builtin; 110 dcl (null, ptr, string, substr) 111 builtin; 112 113 dcl symbol_list (4096) ptr; 114 dcl 1 int_static_list_st 115 aligned, 116 2 int_static_list (1024) ptr unaligned; /* For efficiency */ 117 dcl 1 auto_list_st aligned, 118 2 auto_list (1024) ptr unaligned; /* For efficiency */ 119 120 dcl sym_sort_alphabetic entry (ptr, fixed bin); 121 dcl binoct entry (bit (18) aligned) returns (char (12) aligned), 122 ioa_$rsnpnnl entry options (variable), 123 cg_error entry (fixed bin, fixed bin), 124 pl1_print$varying_nl 125 entry (char (*) varying), 126 pl1_print$non_varying_nl 127 entry (char (*) aligned, fixed bin); 128 129 dcl FF char (1) static aligned init (" "); 1 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 1 2 1 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 1 4 1 5 dcl ( block_node initial("000000001"b), 1 6 statement_node initial("000000010"b), 1 7 operator_node initial("000000011"b), 1 8 reference_node initial("000000100"b), 1 9 token_node initial("000000101"b), 1 10 symbol_node initial("000000110"b), 1 11 context_node initial("000000111"b), 1 12 array_node initial("000001000"b), 1 13 bound_node initial("000001001"b), 1 14 format_value_node initial("000001010"b), 1 15 list_node initial("000001011"b), 1 16 default_node initial("000001100"b), 1 17 machine_state_node initial("000001101"b), 1 18 source_node initial("000001110"b), 1 19 label_node initial("000001111"b), 1 20 cross_reference_node initial("000010000"b), 1 21 sf_par_node initial("000010001"b), 1 22 temporary_node initial("000010010"b), 1 23 label_array_element_node initial("000010011"b), 1 24 by_name_agg_node initial("000010100"b)) 1 25 bit(9) internal static aligned options(constant); 1 26 1 27 dcl 1 node based aligned, 1 28 2 type unal bit(9), 1 29 2 source_id unal structure, 1 30 3 file_number bit(8), 1 31 3 line_number bit(14), 1 32 3 statement_number bit(5); 1 33 1 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 130 2 1 /* BEGIN INCLUDE FILE ... declare_type.incl.pl1 */ 2 2 2 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 2 4 2 5 dcl ( by_declare initial("001"b), 2 6 by_explicit_context initial("010"b), 2 7 by_context initial("011"b), 2 8 by_implication initial("100"b), 2 9 by_compiler initial("101"b)) int static bit(3) aligned options(constant); 2 10 2 11 /* END INCLUDE FILE ... declare_type.incl.pl1 */ 131 3 1 /* BEGIN INCLUDE FILE operator_names.incl.pl1 77-5-2 SHW */ 3 2 3 3 /* Modified June 83 JMAthane for full qualification of "refer" args in dcls */ 3 4 3 5 dcl op_names_pt ptr; 3 6 3 7 dcl 1 operator_names aligned based (op_names_pt), 3 8 2 first fixed bin (18), /* offset of first operator in operator segment */ 3 9 2 last fixed bin (18), /* offset of last operator in operator segment */ 3 10 2 first_special fixed bin (18), /* offset of first special operator */ 3 11 2 last_special fixed bin (18), /* offset of last special operator */ 3 12 2 number_special fixed bin, /* number of special operators */ 3 13 3 14 2 names (1 refer (operator_names.first):1 refer (operator_names.last)), /* array of pointers to and lengths of names */ 3 15 3 namep bit (18) unal, /* rel pointer to ACI string for name */ 3 16 3 len fixed bin (17) unal, /* length of this operator name */ 3 17 3 18 2 special (0 refer (operator_names.number_special)), /* array of info about special operators */ 3 19 3 offset fixed bin (18), /* offset of start of code for this operator */ 3 20 3 namep bit (18) unal, /* rel pointer to ACI string for name */ 3 21 3 len fixed bin (17) unal; /* length of this operator name */ 3 22 3 23 /* END INCLUDE FILE operator_names.incl.pl1 */ 132 4 1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */ 4 2 4 3 /* Modified 26 June 81 by EBush to add max_list_elements */ 4 4 4 5 4 6 dcl 1 list based aligned, 4 7 2 node_type bit(9) unaligned, 4 8 2 reserved bit(12) unaligned, 4 9 2 number fixed(14) unaligned, 4 10 2 element dimension(n refer(list.number)) ptr unaligned; 4 11 4 12 dcl max_list_elements fixed bin(17) internal static options (constant) 4 13 init(16383); 4 14 4 15 /* END INCLUDE FILE ... list.incl.pl1 */ 133 5 1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */ 5 2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */ 5 3 /* format: style3,idind30 */ 5 4 5 5 declare 1 block aligned based, 5 6 2 node_type bit (9) unaligned, 5 7 2 source_id structure unaligned, 5 8 3 file_number bit (8), 5 9 3 line_number bit (14), 5 10 3 statement_number bit (5), 5 11 2 father ptr unaligned, 5 12 2 brother ptr unaligned, 5 13 2 son ptr unaligned, 5 14 2 declaration ptr unaligned, 5 15 2 end_declaration ptr unaligned, 5 16 2 default ptr unaligned, 5 17 2 end_default ptr unaligned, 5 18 2 context ptr unaligned, 5 19 2 prologue ptr unaligned, 5 20 2 end_prologue ptr unaligned, 5 21 2 main ptr unaligned, 5 22 2 end_main ptr unaligned, 5 23 2 return_values ptr unaligned, 5 24 2 return_count ptr unaligned, 5 25 2 plio_ps ptr unaligned, 5 26 2 plio_fa ptr unaligned, 5 27 2 plio_ffsb ptr unaligned, 5 28 2 plio_ssl ptr unaligned, 5 29 2 plio_fab2 ptr unaligned, 5 30 2 block_type bit (9) unaligned, 5 31 2 prefix bit (12) unaligned, 5 32 2 like_attribute bit (1) unaligned, 5 33 2 no_stack bit (1) unaligned, 5 34 2 get_data bit (1) unaligned, 5 35 2 flush_at_call bit (1) unaligned, 5 36 2 processed bit (1) unaligned, 5 37 2 text_displayed bit (1) unaligned, 5 38 2 number fixed bin (9) unsigned unaligned, 5 39 2 free_temps dimension (3) ptr, /* these fields are used by the code generator */ 5 40 2 temp_list ptr, 5 41 2 entry_list ptr, 5 42 2 o_and_s ptr, 5 43 2 why_nonquick aligned, 5 44 3 auto_adjustable_storage bit (1) unaligned, 5 45 3 returns_star_extents bit (1) unaligned, 5 46 3 stack_extended_by_args bit (1) unaligned, 5 47 3 invoked_by_format bit (1) unaligned, 5 48 3 format_statement bit (1) unaligned, 5 49 3 io_statements bit (1) unaligned, 5 50 3 assigned_to_entry_var bit (1) unaligned, 5 51 3 condition_statements bit (1) unaligned, 5 52 3 no_owner bit (1) unaligned, 5 53 3 recursive_call bit (1) unaligned, 5 54 3 options_non_quick bit (1) unaligned, 5 55 3 options_variable bit (1) unaligned, 5 56 3 never_referenced bit (1) unaligned, 5 57 3 pad_nonquick bit (5) unaligned, 5 58 2 prologue_flag bit (1) unaligned, 5 59 2 options_main bit (1) unaligned, 5 60 2 pad bit (16) unaligned, 5 61 2 number_of_entries fixed bin (17), 5 62 2 level fixed bin (17), 5 63 2 last_auto_loc fixed bin (17), 5 64 2 symbol_block fixed bin (17), 5 65 2 entry_info fixed bin (18), 5 66 2 enter structure unaligned, 5 67 3 start fixed bin (17), 5 68 3 end fixed bin (17), 5 69 2 leave structure unaligned, 5 70 3 start fixed bin (17), 5 71 3 end fixed bin (17), 5 72 2 owner ptr; 5 73 5 74 declare max_block_number fixed bin internal static options (constant) initial (511); 5 75 5 76 /* END INCLUDE FILE ... block.incl.pl1 */ 134 6 1 dcl ( root_block initial("000000001"b), 6 2 external_procedure initial("000000010"b), 6 3 internal_procedure initial("000000011"b), 6 4 begin_block initial("000000100"b), 6 5 on_unit initial("000000101"b)) internal static bit(9) aligned options(constant); 135 7 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 7 2 7 3 dcl 1 symbol based aligned, 7 4 2 node_type bit(9) unal, 7 5 2 source_id structure unal, 7 6 3 file_number bit(8), 7 7 3 line_number bit(14), 7 8 3 statement_number bit(5), 7 9 2 location fixed(18) unal unsigned, 7 10 2 allocated bit(1) unal, 7 11 2 dcl_type bit(3) unal, 7 12 2 reserved bit(6) unal, 7 13 2 pix unal, 7 14 3 pic_fixed bit(1) unal, 7 15 3 pic_float bit(1) unal, 7 16 3 pic_char bit(1) unal, 7 17 3 pic_scale fixed(7) unal, 7 18 3 pic_size fixed(7) unal, 7 19 2 level fixed(8) unal, 7 20 2 boundary fixed(3) unal, 7 21 2 size_units fixed(3) unal, 7 22 2 scale fixed(7) unal, 7 23 2 runtime bit(18) unal, 7 24 2 runtime_offset bit(18) unal, 7 25 2 block_node ptr unal, 7 26 2 token ptr unal, 7 27 2 next ptr unal, 7 28 2 multi_use ptr unal, 7 29 2 cross_references ptr unal, 7 30 2 initial ptr unal, 7 31 2 array ptr unal, 7 32 2 descriptor ptr unal, 7 33 2 equivalence ptr unal, 7 34 2 reference ptr unal, 7 35 2 general ptr unal, 7 36 2 father ptr unal, 7 37 2 brother ptr unal, 7 38 2 son ptr unal, 7 39 2 word_size ptr unal, 7 40 2 bit_size ptr unal, 7 41 2 dcl_size ptr unal, 7 42 2 symtab_size ptr unal, 7 43 2 c_word_size fixed(24), 7 44 2 c_bit_size fixed(24), 7 45 2 c_dcl_size fixed(24), 7 46 7 47 2 attributes structure aligned, 7 48 3 data_type structure unal, 7 49 4 structure bit(1) , 7 50 4 fixed bit(1), 7 51 4 float bit(1), 7 52 4 bit bit(1), 7 53 4 char bit(1), 7 54 4 ptr bit(1), 7 55 4 offset bit(1), 7 56 4 area bit(1), 7 57 4 label bit(1), 7 58 4 entry bit(1), 7 59 4 file bit(1), 7 60 4 arg_descriptor bit(1), 7 61 4 storage_block bit(1), 7 62 4 explicit_packed bit(1), /* options(packed) */ 7 63 4 condition bit(1), 7 64 4 format bit(1), 7 65 4 builtin bit(1), 7 66 4 generic bit(1), 7 67 4 picture bit(1), 7 68 7 69 3 misc_attributes structure unal, 7 70 4 dimensioned bit(1), 7 71 4 initialed bit(1), 7 72 4 aligned bit(1), 7 73 4 unaligned bit(1), 7 74 4 signed bit(1), 7 75 4 unsigned bit(1), 7 76 4 precision bit(1), 7 77 4 varying bit(1), 7 78 4 local bit(1), 7 79 4 decimal bit(1), 7 80 4 binary bit(1), 7 81 4 real bit(1), 7 82 4 complex bit(1), 7 83 4 variable bit(1), 7 84 4 reducible bit(1), 7 85 4 irreducible bit(1), 7 86 4 returns bit(1), 7 87 4 position bit(1), 7 88 4 internal bit(1), 7 89 4 external bit(1), 7 90 4 like bit(1), 7 91 4 member bit(1), 7 92 4 non_varying bit(1), 7 93 4 options bit(1), 7 94 4 variable_arg_list bit(1), /* options(variable) */ 7 95 4 alloc_in_text bit(1), /* options(constant) */ 7 96 7 97 3 storage_class structure unal, 7 98 4 auto bit(1), 7 99 4 based bit(1), 7 100 4 static bit(1), 7 101 4 controlled bit(1), 7 102 4 defined bit(1), 7 103 4 parameter bit(1), 7 104 4 param_desc bit(1), 7 105 4 constant bit(1), 7 106 4 temporary bit(1), 7 107 4 return_value bit(1), 7 108 7 109 3 file_attributes structure unal, 7 110 4 print bit(1), 7 111 4 input bit(1), 7 112 4 output bit(1), 7 113 4 update bit(1), 7 114 4 stream bit(1), 7 115 4 reserved_1 bit(1), 7 116 4 record bit(1), 7 117 4 sequential bit(1), 7 118 4 direct bit(1), 7 119 4 interactive bit(1), /* env(interactive) */ 7 120 4 reserved_2 bit(1), 7 121 4 reserved_3 bit(1), 7 122 4 stringvalue bit(1), /* env(stringvalue) */ 7 123 4 keyed bit(1), 7 124 4 reserved_4 bit(1), 7 125 4 environment bit(1), 7 126 7 127 3 compiler_developed structure unal, 7 128 4 aliasable bit(1), 7 129 4 packed bit(1), 7 130 4 passed_as_arg bit(1), 7 131 4 allocate bit(1), 7 132 4 set bit(1), 7 133 4 exp_extents bit(1), 7 134 4 refer_extents bit(1), 7 135 4 star_extents bit(1), 7 136 4 isub bit(1), 7 137 4 put_in_symtab bit(1), 7 138 4 contiguous bit(1), 7 139 4 put_data bit(1), 7 140 4 overlayed bit(1), 7 141 4 error bit(1), 7 142 4 symtab_processed bit(1), 7 143 4 overlayed_by_builtin bit(1), 7 144 4 defaulted bit(1), 7 145 4 connected bit(1); 7 146 7 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 136 8 1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */ 8 2 8 3 dcl 1 reference based aligned, 8 4 2 node_type bit(9) unaligned, 8 5 2 array_ref bit(1) unaligned, 8 6 2 varying_ref bit(1) unaligned, 8 7 2 shared bit(1) unaligned, 8 8 2 put_data_sw bit(1) unaligned, 8 9 2 processed bit(1) unaligned, 8 10 2 units fixed(3) unaligned, 8 11 2 ref_count fixed(17) unaligned, 8 12 2 c_offset fixed(24), 8 13 2 c_length fixed(24), 8 14 2 symbol ptr unaligned, 8 15 2 qualifier ptr unaligned, 8 16 2 offset ptr unaligned, 8 17 2 length ptr unaligned, 8 18 2 subscript_list ptr unaligned, 8 19 /* these fields are used by the 645 code generator */ 8 20 2 address structure unaligned, 8 21 3 base bit(3), 8 22 3 offset bit(15), 8 23 3 op bit(9), 8 24 3 no_address bit(1), 8 25 3 inhibit bit(1), 8 26 3 ext_base bit(1), 8 27 3 tag bit(6), 8 28 2 info structure unaligned, 8 29 3 address_in structure, 8 30 4 b dimension(0:7) bit(1), 8 31 4 storage bit(1), 8 32 3 value_in structure, 8 33 4 a bit(1), 8 34 4 q bit(1), 8 35 4 aq bit(1), 8 36 4 string_aq bit(1), 8 37 4 complex_aq bit(1), 8 38 4 decimal_aq bit(1), 8 39 4 b dimension(0:7) bit(1), 8 40 4 storage bit(1), 8 41 4 indicators bit(1), 8 42 4 x dimension(0:7) bit(1), 8 43 3 other structure, 8 44 4 big_offset bit(1), 8 45 4 big_length bit(1), 8 46 4 modword_in_offset bit(1), 8 47 2 data_type fixed(5) unaligned, 8 48 2 bits structure unaligned, 8 49 3 padded_ref bit(1), 8 50 3 aligned_ref bit(1), 8 51 3 long_ref bit(1), 8 52 3 forward_ref bit(1), 8 53 3 ic_ref bit(1), 8 54 3 temp_ref bit(1), 8 55 3 defined_ref bit(1), 8 56 3 evaluated bit(1), 8 57 3 allocate bit(1), 8 58 3 allocated bit(1), 8 59 3 aliasable bit(1), 8 60 3 even bit(1), 8 61 3 perm_address bit(1), 8 62 3 aggregate bit(1), 8 63 3 hit_zero bit(1), 8 64 3 dont_save bit(1), 8 65 3 fo_in_qual bit(1), 8 66 3 hard_to_load bit(1), 8 67 2 relocation bit(12) unaligned, 8 68 2 more_bits structure unaligned, 8 69 3 substr bit(1), 8 70 3 padded_for_store_ref bit(1), 8 71 3 aligned_for_store_ref bit(1), 8 72 3 mbz bit(15), 8 73 2 store_ins bit(18) unaligned; 8 74 8 75 /* END INCLUDE FILE ... reference.incl.pl1 */ 137 9 1 /* *********************************************************** 9 2* * * 9 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 9 4* * * 9 5* *********************************************************** */ 9 6 /* BEGIN INCLUDE FILE ... statement.incl.pl1 */ 9 7 /* Internal interface of the PL/I compiler */ 9 8 9 9 dcl 1 statement based aligned, 9 10 2 node_type bit(9) unaligned, 9 11 2 source_id structure unaligned, 9 12 3 file_number bit(8), 9 13 3 line_number bit(14), 9 14 3 statement_number bit(5), 9 15 2 next ptr unaligned, 9 16 2 back ptr unaligned, 9 17 2 root ptr unaligned, 9 18 2 labels ptr unaligned, 9 19 2 reference_list ptr unaligned, 9 20 2 state_list ptr unaligned, 9 21 2 reference_count fixed(17) unaligned, 9 22 2 ref_count_copy fixed(17) unaligned, 9 23 2 object structure unaligned, 9 24 3 start fixed(17), 9 25 3 finish fixed(17), 9 26 2 source structure unaligned, 9 27 3 segment fixed(11), 9 28 3 start fixed(23), 9 29 3 length fixed(11), 9 30 2 prefix bit(12) unaligned, 9 31 2 optimized bit(1) unaligned, 9 32 2 free_temps bit(1) unaligned, 9 33 2 LHS_in_RHS bit(1) unaligned, 9 34 2 statement_type bit(9) unaligned, 9 35 2 bits structure unaligned, 9 36 3 processed bit(1) unaligned, 9 37 3 put_in_profile bit(1) unaligned, 9 38 3 generated bit(1) unaligned, 9 39 3 snap bit(1) unaligned, 9 40 3 system bit(1) unaligned, 9 41 3 irreducible bit(1) unaligned, 9 42 3 checked bit(1) unaligned, 9 43 3 save_temps bit(1) unaligned, 9 44 3 suppress_warnings bit(1) unaligned, 9 45 3 force_nonquick bit(1) unaligned, 9 46 3 expanded_by_name bit(1) unaligned, 9 47 3 begins_loop bit(1) unaligned, 9 48 3 pad bit(24) unaligned; 9 49 9 50 /* END INCLUDE FILE ... statement.incl.pl1 */ 138 10 1 /* BEGIN INCLUDE FILE ... token.incl.pl1 */ 10 2 10 3 dcl 1 token based aligned, 10 4 2 node_type bit(9) unaligned, 10 5 2 type bit(9) unaligned, 10 6 2 loc bit(18) unaligned, /* symtab offset for identifiers, "p" flag for constants */ 10 7 2 declaration ptr unaligned, 10 8 2 next ptr unaligned, 10 9 2 size fixed(9), 10 10 2 string char(n refer(token.size)); 10 11 10 12 /* END INCLUDE FILE ... token.incl.pl1 */ 139 11 1 /* BEGIN INCLUDE FILE ... object_map.incl.pl1 */ 11 2 /* coded February 8, 1972 by Michael J. Spier */ 11 3 /* Last modified on 05/20/72 at 13:29:38 by R F Mabee. */ 11 4 /* Made to agree with Spier's document on 20 May 1972 by R F Mabee. */ 11 5 /* modified on 6 May 1972 by R F Mabee to add map_ptr at end of object map. */ 11 6 /* modified May, 1972 by M. Weaver */ 11 7 /* modified 5/75 by E. Wiatrowski and 6/75 by M. Weaver */ 11 8 /* modified 5/77 by M. Weaver to add perprocess_static bit */ 11 9 11 10 declare 1 object_map aligned based, /* Structure describing standard object map */ 11 11 11 12 2 decl_vers fixed bin, /* Version number of current structure format */ 11 13 2 identifier char (8) aligned, /* Must be the constant "obj_map" */ 11 14 2 text_offset bit (18) unaligned, /* Offset relative to base of object segment of base of text section */ 11 15 2 text_length bit (18) unaligned, /* Length in words of text section */ 11 16 2 definition_offset bit (18) unaligned, /* Offset relative to base of object seg of base of definition section */ 11 17 2 definition_length bit (18) unaligned, /* Length in words of definition section */ 11 18 2 linkage_offset bit (18) unaligned, /* Offset relative to base of object seg of base of linkage section */ 11 19 2 linkage_length bit (18) unaligned, /* Length in words of linkage section */ 11 20 2 static_offset bit (18) unaligned, /* Offset relative to base of obj seg of static section */ 11 21 2 static_length bit (18) unaligned, /* Length in words of static section */ 11 22 2 symbol_offset bit (18) unaligned, /* Offset relative to base of object seg of base of symbol section */ 11 23 2 symbol_length bit (18) unaligned, /* Length in words of symbol section */ 11 24 2 break_map_offset bit (18) unaligned, /* Offset relative to base of object seg of base of break map */ 11 25 2 break_map_length bit (18) unaligned, /* Length in words of break map */ 11 26 2 entry_bound bit (18) unaligned, /* Offset in text of last gate entry */ 11 27 2 text_link_offset bit (18) unaligned, /* Offset of first text-embedded link */ 11 28 2 format aligned, /* Word containing bit flags about object type */ 11 29 3 bound bit (1) unaligned, /* On if segment is bound */ 11 30 3 relocatable bit (1) unaligned, /* On if segment has relocation info in its first symbol block */ 11 31 3 procedure bit (1) unaligned, /* On if segment is an executable object program */ 11 32 3 standard bit (1) unaligned, /* On if segment is in standard format (more than just standard map) */ 11 33 3 separate_static bit(1) unaligned, /* On if static is a separate section from linkage */ 11 34 3 links_in_text bit (1) unaligned, /* On if there are text-embedded links */ 11 35 3 perprocess_static bit (1) unaligned, /* On if static is not to be per run unit */ 11 36 3 unused bit (29) unaligned; /* Reserved */ 11 37 11 38 declare map_ptr bit(18) aligned based; /* Last word of the segment. It points to the base of the object map. */ 11 39 11 40 declare object_map_version_2 fixed bin static init(2); 11 41 11 42 /* END INCLUDE FILE ... object_map.incl.pl1 */ 140 141 142 /* program */ 143 144 call pl1_print$varying_nl (FF || " NAMES DECLARED IN THIS COMPILATION."); 145 146 /* NOTE: the strings used in the following calls contain tabs */ 147 148 call pl1_print$varying_nl (" 149 IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES"); 150 call pl1_print$varying_nl ( 151 " (* indicates a set context)"); 152 153 int_static_list_length = 0; /* Initialize storage table saved lists */ 154 auto_list_length = 0; 155 156 /* Create lists of symbols and print them */ 157 158 if pl1_stat_$single_symbol_list 159 then do; 160 n, unused, unused_members = 0; 161 call select_all_symbols (root); 162 if n > 1 163 then do; 164 call sym_sort_alphabetic (addr (symbol_list), n); 165 call pl1_print$varying_nl (""); 166 /* Print newline */ 167 call print (0); /* Print all symbols */ 168 end; 169 else call pl1_print$varying_nl ("THERE WERE NO NAMES DECLARED IN THIS COMPILATION."); 170 end; 171 else do i = 1 to 4 while (i ^= 4 | do_cp_dcl); /* Print up to 4 separate lists */ 172 173 /* Get all declarations of desired types */ 174 175 n, unused, unused_members = 0; 176 177 call sort_on_dcl_type (root, (dt1 (i)), (dt2 (i))); 178 179 if n > hbound (symbol_list, 1) 180 then do; 181 full: 182 call cg_error (327, hbound (symbol_list, 1)); 183 n = hbound (symbol_list, 1); 184 end; 185 186 if n > 1 187 then call sym_sort_alphabetic (addr (symbol_list), n); 188 189 if i ^= 1 190 then do; 191 size = n; 192 k = 0; /* All symbol indicator */ 193 end; 194 else do; 195 size = n - (unused + unused_members); 196 k = -1; /* Referenced symbol indicator */ 197 end; 198 199 if size = 0 200 then call pl1_print$varying_nl (" 201 THERE WERE NO NAMES DECLARED BY " || declare_type (i)); 202 else do; 203 if size = 1 204 then s = ""; 205 else s = "S"; 206 207 call pl1_print$varying_nl (" 208 NAME" || s || " DECLARED BY " || declare_type (i)); 209 210 call print (k); /* Print symbols according to indicator */ 211 end; 212 213 if i = 1 & unused > 0 214 then do; 215 if unused = 1 216 then s = ""; 217 else s = "S"; 218 219 call pl1_print$varying_nl (" 220 NAME" || s || " DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED."); 221 222 call print (1); /* Print non_referenced symbols */ 223 end; 224 225 end; 226 227 /* Print storage requirements */ 228 229 if no_object 230 then return; 231 232 call pl1_print$varying_nl (" 233 STORAGE REQUIREMENTS FOR THIS PROGRAM."); 234 235 q = cg_static_$objmap_pt; 236 237 call ioa_$rsnpnnl ("^/^-Object^-Text^-Link^-Symbol^-Defs^-Static^/Start^10x0^7x0^10o^12o^8o^12o", line, k, 238 fixed (q -> object_map.linkage_offset, 18), fixed (q -> object_map.symbol_offset, 18), 239 fixed (q -> object_map.definition_offset, 18), fixed (q -> object_map.static_offset, 18)); 240 241 call pl1_print$non_varying_nl (line, k); 242 243 call ioa_$rsnpnnl ("Length^10o^8o^10o^12o^8o^12o", line, k, divide (cg_static_$bit_count, 36, 17, 0), 244 fixed (q -> object_map.text_length, 18), fixed (q -> object_map.linkage_length, 18), 245 fixed (q -> object_map.symbol_length, 18), fixed (q -> object_map.definition_length, 18), 246 fixed (q -> object_map.static_length, 18)); 247 248 call pl1_print$non_varying_nl (line, k); 249 250 call pl1_print$varying_nl (""); 251 252 call pl1_print$varying_nl ( 253 "BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME"); 254 255 p = cg_static_$root -> block.son; 256 257 do while (p ^= null); 258 call prt_block (p); 259 260 if p -> block.son ^= null /* This code walks the tree of blocks by */ 261 then p = p -> block.son; /* recursing down the son chain until it */ 262 else if p -> block.brother ^= null /* runs out, then it switches to the brother */ 263 then p = p -> block.brother; /* chain (of the last son) until it runs out, then it */ 264 else do; /* picks up the brother chains it missed the first time */ 265 p = p -> block.father; /* down the tree. */ 266 do while (p -> block.brother = null & cg_static_$root ^= p); 267 p = p -> block.father; 268 end; 269 p = p -> block.brother; 270 end; 271 end; 272 273 call print_int_static_table (int_static_list_st, int_static_list_length); 274 275 call print_auto_table (auto_list_st, auto_list_length); 276 277 if cg_static_$used_operator 278 then ; 279 else goto chk_ext; 280 281 call pl1_print$varying_nl (" 282 THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM."); 283 284 line = ""; 285 i, k = 1; 286 j = 0; 287 op_names_pt = addr (pl1_operator_names_$pl1_operator_names_); 288 289 look: 290 n = index (substr (cg_static_$used_operator, k), "1"b); 291 292 if n ^= 0 293 then do; 294 295 k = k + n - 1; 296 if k >= operator_names.first & k <= operator_names.last 297 then do; 298 p = addr (operator_names.names (k)); 299 goto place; 300 end; 301 302 do n = 1 to operator_names.number_special; 303 if operator_names.special (n).offset = k 304 then do; 305 p = addr (operator_names.special (n).namep); 306 goto place; 307 end; 308 end; 309 310 goto step; 311 312 place: 313 size = fixed (p -> name_pair.size, 18); 314 p = ptr (p, p -> name_pair.rel_ptr); 315 316 substr (line, i, size) = p -> based_string; 317 318 j = i + size - 1; 319 i = i + 20; 320 321 if i >= 121 322 then do; 323 call pl1_print$non_varying_nl (line, j); 324 line = ""; 325 i = 1; 326 j = 0; 327 end; 328 329 step: 330 k = k + 1; 331 goto look; 332 end; 333 334 if j ^= 0 335 then call pl1_print$non_varying_nl (line, j); 336 337 chk_ext: 338 p = cg_static_$ext_proc_list; 339 call print_list (1); /* List ext. entry info */ 340 341 p = cg_static_$ext_var_list; 342 call print_list (2); /* List ext. variable info */ 343 done: 344 call pl1_print$varying_nl (""); 345 346 return; 347 348 print_list: 349 proc (ext_code); 350 351 /* parameters */ 352 353 dcl ext_code fixed bin; /* Print_list 1: external entries, 354* 2: external variables */ 355 356 /* automatic */ 357 dcl (hder_no_ext, hder_has_ext) 358 char (512) varying; 359 dcl sym2 ptr; 360 361 if ext_code = 1 362 then do; 363 hder_no_ext = " 364 NO EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM."; 365 hder_has_ext = " 366 THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM."; 367 end; 368 else do; 369 hder_no_ext = " 370 NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM."; 371 hder_has_ext = " 372 THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM."; 373 end; 374 375 if (p ^= null) 376 then do; 377 n = 0; 378 379 do while (p ^= null); 380 sym2 = p -> element (2); 381 382 if ((sym2 -> symbol.cross_references ^= null) | (sym2 -> symbol.allocate)) 383 then do; 384 n = n + 1; 385 symbol_list (n) = sym2; 386 end; 387 p = p -> element (1); 388 end; 389 390 if (n > 0) 391 then do; 392 393 call pl1_print$varying_nl (hder_has_ext); 394 call sym_sort_alphabetic (addr (symbol_list), n); 395 line = ""; 396 i = 1; 397 j = 0; 398 399 do k = 1 to n; 400 p = symbol_list (k) -> symbol.token; 401 size = p -> token.size; 402 403 if i + size >= 121 404 then do; 405 call pl1_print$non_varying_nl (line, j); 406 line = " "; 407 i = 1; 408 j = 0; 409 end; 410 411 substr (line, i, size) = p -> token.string; 412 j = i + size - 1; 413 if size = 30 414 then size = size + 1; 415 416 m = mod (size, 30); 417 if m ^= 0 418 then size = size + (30 - m); 419 i = i + size; 420 end; 421 422 if j ^= 0 423 then call pl1_print$non_varying_nl (line, j); 424 end; 425 else call pl1_print$varying_nl (hder_no_ext); 426 end; 427 else call pl1_print$varying_nl (hder_no_ext); 428 429 end; 430 431 prt_block: 432 proc (pt); 433 434 dcl pt ptr; 435 436 dcl (bp, fp) ptr, 437 (bt1, bt2, info_len) 438 fixed bin, 439 (name1, name2) char (256) varying; 440 441 dcl 1 bline aligned, 442 2 name char (29) unal, 443 2 sp1 char (4) unal, 444 2 size picture "-----9" unal, 445 2 sp2 char (1) unal, 446 2 type char (19) unal, 447 2 sp3 char (1) unal, 448 2 info char (70); 449 450 dcl block_type (5) char (18) varying int static 451 init ("root block", "external procedure", "internal procedure", "begin block", "on unit"); 452 453 dcl nonquick_reasons (13) char (40) varying aligned internal static options (constant) 454 init ("uses auto adjustable storage", "uses returns(char(*)) or returns(bit(*))", 455 "is called during a stack extension", "is invoked by a format statement", 456 "contains a format statement", "uses I/O statements", "is assigned to an entry variable", 457 "enables or reverts conditions", "is called by several nonquick procedures", 458 "calls itself recursively", "is declared options(non_quick)", 459 "is declared options(variable)", "is never referenced"); 460 461 bp = pt; 462 string (bline) = ""; 463 464 call block_name (bp, name1, bt1); 465 if length (name1) > length (bline.name) 466 then call pl1_print$varying_nl (name1); 467 else bline.name = name1; 468 469 bline.type = block_type (bt1); 470 471 if bp -> block.no_stack 472 then do; 473 fp = bp; 474 do while (fp -> block.no_stack); 475 if fp -> block.owner = null 476 then fp = fp -> block.father; 477 else fp = fp -> block.owner; 478 end; 479 480 call block_name (fp, name2, bt2); 481 name1 = "shares stack frame of "; 482 if bt2 ^= bin (begin_block) & bt2 ^= bin (on_unit) 483 then do; 484 name1 = name1 || block_type (bt2); 485 name1 = name1 || " "; 486 end; 487 name1 = name1 || name2; 488 bline.info = name1; 489 info_len = length (name1); 490 end; 491 else do; 492 bline.size = bp -> block.last_auto_loc; 493 info_len = 0; 494 495 if bt1 = bin (external_procedure) /* special-case the main procedure */ 496 then do; 497 bline.info = "is an external procedure"; 498 info_len = length ("is an external procedure"); 499 end; 500 else do i = 1 to hbound (nonquick_reasons, 1); 501 if substr (string (bp -> block.why_nonquick), i, 1) 502 then do; 503 if info_len > 0 /* if something already printed... */ 504 then if i = hbound (nonquick_reasons, 1) 505 then do; 506 substr (bline.info, info_len + 1, 6) = ", and "; 507 info_len = info_len + 6; 508 end; 509 else if substr (string (bp -> block.why_nonquick), i + 1) = ""b 510 then do; 511 substr (bline.info, info_len + 1, 6) = ", and "; 512 info_len = info_len + 6; 513 end; 514 else do; 515 substr (bline.info, info_len + 1, 2) = ", "; 516 info_len = info_len + 2; 517 end; 518 519 n = length (nonquick_reasons (i)); 520 if info_len + n + 1 > length (bline.info) 521 then do; 522 call pl1_print$non_varying_nl (string (bline), 523 length (string (bline)) - length (bline.info) + info_len); 524 string (bline) = ""; 525 info_len = 0; 526 end; 527 528 substr (bline.info, info_len + 1, n) = nonquick_reasons (i); 529 info_len = info_len + n; 530 end; 531 end; 532 end; 533 534 if info_len > 0 & info_len < length (bline.info) 535 then do; 536 substr (bline.info, info_len + 1, 1) = "."; 537 info_len = info_len + 1; 538 end; 539 540 call pl1_print$non_varying_nl (string (bline), length (string (bline)) - length (bline.info) + info_len); 541 542 end; /* end of prt_block */ 543 544 block_name: 545 proc (blkp, name, type); 546 547 dcl blkp ptr, 548 name char (256) varying, 549 type fixed bin; 550 551 dcl blk ptr; 552 dcl name_ptr ptr; 553 554 blk = blkp; 555 type = fixed (blk -> block_type, 3); 556 557 if blk -> block_type = begin_block | blk -> block_type = on_unit 558 then do; 559 if blk -> block.block_type = begin_block 560 then name = "begin block"; 561 else name = "on unit"; 562 name = name || " on line "; 563 number_name: 564 if blk -> block.file_number ^= "0"b 565 then do; 566 digits_pic = fixed (blk -> block.file_number, 8); 567 name = name || ltrim (digits_pic); 568 name = name || "-"; 569 end; 570 digits_pic = fixed (blk -> block.line_number, 14); 571 name = name || ltrim (digits_pic); 572 end; 573 else do; 574 name_ptr = blk -> block.main -> statement.labels -> list.element (2); 575 if name_ptr -> reference.node_type = reference_node 576 then name = name_ptr -> reference.symbol -> symbol.token -> token.string; 577 else if name_ptr -> token.node_type = token_node 578 then name = name_ptr -> token.string; 579 else do; 580 name = ""; 581 go to number_name; 582 end; 583 end; 584 585 end; 586 587 /* Select all symbols and store in list */ 588 589 select_all_symbols: 590 proc (pt); 591 592 dcl pt ptr; /* points at block node */ 593 dcl dt bit (3) aligned, 594 null builtin, 595 (block_pt, sym_pt) ptr; 596 597 block_pt = pt; 598 do while (block_pt ^= null); 599 600 sym_pt = block_pt -> block.declaration; 601 do while (sym_pt ^= null); 602 603 dt = sym_pt -> symbol.dcl_type; 604 605 if dt = by_compiler /* Compiler-declared symbol */ 606 then if ^do_cp_dcl 607 then go to step; 608 609 if n = hbound (symbol_list, 1) 610 then goto full; 611 612 n = n + 1; 613 symbol_list (n) = sym_pt; 614 615 if sym_pt -> symbol.cross_references = null & ^sym_pt -> symbol.allocate 616 then if sym_pt -> symbol.level <= 1 617 then unused = unused + 1; 618 else unused_members = unused_members + 1; 619 620 step: 621 sym_pt = sym_pt -> symbol.next; 622 end; 623 624 sym_pt = block_pt -> block.son; 625 if sym_pt ^= null 626 then call select_all_symbols (sym_pt); 627 628 block_pt = block_pt -> block.brother; 629 end; 630 631 end; 632 633 /* Procedure to fill in an array with pointers to all declarations of a given 634* declare type. 635* 636* Initial Version: 13 January 1969 by JDM for Version I 637* Modified: 23 Februrary 1971 by BLW for Version II */ 638 639 sort_on_dcl_type: 640 proc (pt, dtp1, dtp2); 641 642 dcl pt ptr, /* points at block node */ 643 dtp1 bit (3) aligned, /* first declare type */ 644 dtp2 bit (3) aligned; /* second declare type */ 645 646 dcl (dt, dt1, dt2) bit (3) aligned, 647 null builtin, 648 (block_pt, sym_pt) ptr; 649 650 651 dt1 = dtp1; 652 dt2 = dtp2; 653 654 block_pt = pt; 655 do while (block_pt ^= null); 656 657 sym_pt = block_pt -> block.declaration; 658 do while (sym_pt ^= null); 659 660 dt = sym_pt -> symbol.dcl_type; 661 662 if dt ^= dt1 663 then if dt ^= dt2 664 then goto step; 665 666 if n = hbound (symbol_list, 1) 667 then goto full; 668 669 n = n + 1; 670 symbol_list (n) = sym_pt; 671 672 if sym_pt -> symbol.cross_references = null & ^sym_pt -> symbol.allocate 673 then if sym_pt -> symbol.level <= 1 674 then unused = unused + 1; 675 else unused_members = unused_members + 1; 676 677 step: 678 sym_pt = sym_pt -> symbol.next; 679 end; 680 681 sym_pt = block_pt -> block.son; 682 if sym_pt ^= null 683 then call sort_on_dcl_type (sym_pt, dt1, dt2); 684 685 block_pt = block_pt -> block.brother; 686 end; 687 688 end; 689 690 print: 691 proc (ignore_code); 692 693 /* parameters */ 694 695 dcl ignore_code fixed bin; /* Print -1: referenced, 696* 0: all, 697* +1: non-referenced declarations. */ 698 699 /* automatic */ 700 701 dcl (sym_pt, p) ptr; 702 dcl ref_list (1024) ptr unaligned; 703 dcl (k, ctype, dtype, ext, cur_attrib_col, nn, bo, i, name_width, ignore) 704 fixed bin; 705 dcl next_k fixed bin; /* index of next non-ignored name */ 706 dcl ref_list_length fixed bin; 707 dcl wo fixed bin (18); 708 dcl id char (256) varying; 709 dcl name char (256) varying; 710 dcl temp char (296) varying; 711 dcl number char (12) varying; 712 dcl c6 char (6); 713 dcl ref_too_many bit (1); 714 dcl prev_dupl bit (1); /* last name was duplicate of current */ 715 dcl next_dupl bit (1); /* next name is dupl of current */ 716 dcl id_printed bit (1); 717 dcl something_to_print bit (1); 718 dcl ignore_symbol bit (1); 719 720 /* pictures */ 721 722 dcl six_digits picture "------9"; 723 724 /* internal static */ 725 726 dcl char_per_line fixed bin int static init (132); 727 728 dcl int_ext (0:1) char (8) int static options (constant) init ("internal", "external"); 729 730 dcl class_name (0:23) char (20) aligned int static 731 init ("ILLEGAL 0", "ILLEGAL 1", "automatic", "ILLEGAL 3", "based", "ILLEGAL 5", 732 "internal static", "external static", "internal ctl", "external ctl", "defined", 733 "ILLEGAL 11", "parameter", "ILLEGAL 13", "param descriptor", "ILLEGAL 15", "constant", 734 "constant", "temporary", "ILLEGAL 19", "return value", "ILLEGAL 21", "stack reference", 735 "constant"); 736 737 dcl dt (0:26) char (17) aligned varying int static 738 init ("unknown", "fixed bin", "fixed dec", "float bin", "float dec", "complex fixed bin", 739 "complex fixed dec", "complex float bin", "complex float dec", "char", "varying char", 740 "bit", "varying bit", "label", "label variable", "entry", "entry variable", "file", 741 "file variable", "pointer", "offset", "structure", "area", "condition", "format", 742 "format variable", "picture"); 743 744 dcl file_attr_words (16) char (11) varying int static 745 init ("print", "input", "output", "update", "stream", "", "record", "sequential", "direct", 746 "interactive", "", "", "stringvalue", "keyed", "namelist", "environment"); 747 748 dcl auto_static_const bit (10) int static init ("1010000100"b); 749 750 dcl indent fixed bin int static init (2);/* indentation for continuation lines */ 751 752 dcl line_pt ptr; 753 754 dcl 1 sl, 755 2 symbol char (20) unal, 756 2 sp1 char (1) unal, 757 2 word_offset char (6) unal, 758 2 bit_offset (4) char (1) unal, 759 2 sp2 char (1) unal, 760 2 location char (6) unal, 761 2 sp3 char (1) unal, 762 2 class char (15) unal, 763 2 sp4 char (1) unal, 764 2 data_type char (25) unal, 765 2 sp6 char (1) unal, 766 2 attributes char (60) unal; 767 768 dcl line char (132) defined (sl); 769 770 dcl (bit, ltrim, verify) 771 builtin; 772 773 dcl digit (0:9) char (1) aligned int static 774 initial ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9"); 775 12 1 /* BEGIN INCLUDE FILE ... cgsystem.incl.pl1 */ 12 2 12 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 12 4 12 5 dcl ( bits_per_char init(9), 12 6 bits_per_half init(18), 12 7 bits_per_word init(36), 12 8 bits_per_two_words init(72), 12 9 bits_per_four_words init(144), 12 10 bits_per_words(2) init(36,72), 12 11 packed_digits_per_char init(2), 12 12 chars_per_word init(4), 12 13 packed_digits_per_word init(8), 12 14 12 15 break_even_bits init(216), 12 16 break_even_words init(6), 12 17 12 18 label_size init(4), 12 19 12 20 convert_size(13:14) init(9,1), 12 21 max_offset(13:14) init(27,35), 12 22 max_short_size(13:14) init(8,72), 12 23 12 24 units_per_word(0:5) init(1,36,8,4,2,1), 12 25 12 26 max_dec_scale init(32), 12 27 min_dec_scale init(-31), 12 28 max_p_xreg init(18), 12 29 max_p_fix_bin_1 init(35), 12 30 max_p_flt_bin_1 init(27), 12 31 max_p_fix_dec init(59), 12 32 max_length_p init(24), 12 33 default_fix_bin_p init(17)) fixed bin(8) int static options(constant); 12 34 12 35 dcl (convert_offset(0:5) init(36,1,4.5,9,18,36), 12 36 bits_per_packed_digit init(4.5)) fixed bin(8,1) int static options(constant); 12 37 12 38 dcl max_index_register_value init(262143) fixed bin(31) int static options(constant); 12 39 12 40 /* END INCLUDE FILE ... cgsystem.incl.pl1 */ 12 41 776 13 1 dcl 1 label based aligned, 13 2 2 node_type bit(9) unaligned, 13 3 2 source_id structure unaligned, 13 4 3 file_number bit(8), 13 5 3 line_number bit(14), 13 6 3 statement_number bit(5), 13 7 2 location fixed(17) unaligned, 13 8 2 allocated bit(1) unaligned, 13 9 2 dcl_type bit(3) unaligned, 13 10 2 reserved bit(29) unaligned, 13 11 2 array bit(1) unaligned, 13 12 2 used_as_format bit(1) unaligned, 13 13 2 used_in_goto bit(1) unaligned, 13 14 2 symbol_table bit(18) unaligned, 13 15 2 low_bound fixed(17) unaligned, 13 16 2 high_bound fixed(17) unaligned, 13 17 2 block_node ptr unaligned, 13 18 2 token ptr unaligned, 13 19 2 next ptr unaligned, 13 20 2 multi_use ptr unaligned, 13 21 2 cross_reference ptr unaligned, 13 22 2 statement ptr unaligned; 777 14 1 /* BEGIN INCLUDE FILE ... cross_reference.incl.pl1 */ 14 2 14 3 dcl 1 cross_reference based aligned, 14 4 2 node_type bit(9) unaligned, 14 5 2 source_id structure unaligned, 14 6 3 file_number bit(8), 14 7 3 line_number bit(14), 14 8 3 statement_number bit(5), 14 9 2 next ptr unaligned, 14 10 2 ref_type structure unaligned, 14 11 3 set_reference bit(1), 14 12 3 pad bit(35); 14 13 14 14 /* END INCLUDE FILE ... cross_reference.incl.pl1 */ 778 779 780 line_pt = addr (line); 781 ignore = ignore_code; 782 783 /* The following code selects symbols for printing and determines whether duplicates occur */ 784 next_dupl = "0"b; 785 k = 0; /* No current symbol */ 786 do next_k = 1 to n; /* Scan symbol_list */ 787 788 /* Consider symbol symbol_list (next_k) only if it is not to be ignored */ 789 /* Ignore non-referenced variables if "ignore" is */ 790 /* negative, referenced variables if "ignore" */ 791 /* is positive non-zero. */ 792 begin; 793 dcl sym_pt ptr; 794 dcl referenced bit (1); 795 sym_pt = symbol_list (next_k); 796 ignore_symbol = "0"b; /* Assume symbol is not to be ignored */ 797 if ignore ^= 0 | sym_pt -> symbol.level > 1 798 then do; 799 referenced = (sym_pt -> symbol.cross_references ^= null | sym_pt -> symbol.allocate); 800 /* identifier is referenced */ 801 if ignore < 0 & ^referenced | ignore > 0 & referenced 802 | sym_pt -> symbol.level > 1 & ^referenced 803 then ignore_symbol = "1"b; 804 end; 805 end; 806 if ^ignore_symbol 807 then do; 808 if k ^= 0 809 then do; 810 prev_dupl = next_dupl; 811 next_dupl = 812 (symbol_list (k) -> symbol.token -> token.string 813 = symbol_list (next_k) -> symbol.token -> token.string); 814 call print_k; 815 end; 816 k = next_k; 817 end; 818 end; 819 prev_dupl = "0"b; 820 call print_k; /* Print last symbol (there must be one) */ 821 return; 822 823 /* Print symbol table entry for current symbol */ 824 print_k: 825 proc; 826 sym_pt = symbol_list (k); 827 call init_attrib; 828 dtype, ctype = 0; 829 id = sym_pt -> symbol.token -> token.string; /* save identifier for later */ 830 id_printed = "0"b; 831 if sym_pt -> node.type = label_node 832 then do; 833 ctype = 16; 834 sl.data_type = dt (13); 835 836 if sym_pt -> label.array 837 then do; 838 temp = "array("; 839 840 if sym_pt -> label.low_bound ^= 1 841 then do; 842 six_digits = sym_pt -> label.low_bound; 843 temp = temp || ltrim (six_digits); 844 temp = temp || ":"; 845 end; 846 847 six_digits = sym_pt -> label.high_bound; 848 temp = temp || ltrim (six_digits); 849 temp = temp || ")"; 850 call attrib (temp); /* "array(low:high)" */ 851 end; 852 go to set_loc; 853 end; 854 855 if sym_pt -> symbol.builtin 856 then do; 857 sl.data_type = "builtin function"; 858 goto done; 859 end; 860 861 if sym_pt -> symbol.generic 862 then do; 863 sl.data_type = "generic function"; 864 goto done; 865 end; 866 867 ext = fixed (sym_pt -> symbol.external, 1); 868 869 if sym_pt -> symbol.entry 870 then do; 871 872 if sym_pt -> symbol.variable 873 then do; 874 dtype = 16; 875 goto have_type; 876 end; 877 878 dtype = 15; 879 if sym_pt -> symbol.external & sym_pt -> symbol.initial = null 880 then ctype = 23; 881 else ctype = 16; 882 883 call attrib ((int_ext (ext))); /* "internal" or "external" entry constant */ 884 goto set_loc; 885 end; 886 887 if sym_pt -> symbol.condition 888 then do; 889 ctype = 22; 890 dtype = 23; 891 goto set_loc; 892 end; 893 894 if sym_pt -> symbol.fixed 895 then do; 896 dtype = 1; 897 goto arith; 898 end; 899 900 if sym_pt -> symbol.float 901 then do; 902 dtype = 3; 903 904 arith: 905 if sym_pt -> symbol.decimal 906 then dtype = dtype + 1; 907 if sym_pt -> symbol.complex 908 then dtype = dtype + 4; 909 goto have_type; 910 end; 911 912 if sym_pt -> symbol.char 913 then do; 914 dtype = 9; 915 goto str; 916 end; 917 918 if sym_pt -> symbol.bit 919 then do; 920 dtype = 11; 921 922 str: 923 if sym_pt -> symbol.varying 924 then dtype = dtype + 1; 925 goto have_type; 926 end; 927 928 if sym_pt -> symbol.picture 929 then do; 930 dtype = 26; 931 go to have_type; 932 end; 933 934 if sym_pt -> symbol.label 935 then do; 936 dtype = 13; 937 goto cv; 938 end; 939 940 if sym_pt -> symbol.format 941 then do; 942 dtype = 24; 943 goto cv; 944 end; 945 946 if sym_pt -> symbol.file 947 then do; 948 dtype = 17; 949 950 cv: 951 if sym_pt -> symbol.variable 952 then dtype = dtype + 1; 953 goto have_type; 954 end; 955 956 if sym_pt -> symbol.ptr 957 then dtype = 19; 958 else if sym_pt -> symbol.offset 959 then dtype = 20; 960 else if sym_pt -> symbol.structure 961 then dtype = 21; 962 else if sym_pt -> symbol.area 963 then dtype = 22; 964 965 have_type: 966 ctype = 2 * index (string (sym_pt -> symbol.storage_class), "1"b) + ext; 967 968 if sym_pt -> symbol.allocated 969 then if string (sym_pt -> symbol.storage_class) & auto_static_const 970 then do; 971 972 /* Save variables for later printout in storage table */ 973 if sym_pt -> symbol.level <= 1 974 then do; /* Members of structures ignored */ 975 if ctype = 6 976 then do; /* Internal static */ 977 if int_static_list_length = hbound (int_static_list, 1) 978 then call cg_error (327, int_static_list_length); 979 else do; 980 int_static_list_length = int_static_list_length + 1; 981 int_static_list (int_static_list_length) = sym_pt; 982 end; 983 end; 984 else if ctype = 2 985 then do; /* Automatic */ 986 if auto_list_length = hbound (auto_list, 1) 987 then call cg_error (327, auto_list_length); 988 else do; 989 auto_list_length = auto_list_length + 1; 990 auto_list (auto_list_length) = sym_pt; 991 end; 992 end; 993 end; 994 995 set_loc: 996 sl.location = substr (binoct (bit (fixed (sym_pt -> symbol.location, 18), 18)), 1, 6); 997 end; 998 999 sl.class = substr (class_name (ctype), 1, 15); 1000 1001 if sym_pt -> node.type = label_node 1002 then goto done; 1003 1004 p = sym_pt -> symbol.reference; 1005 if p -> reference.offset = null 1006 then do; 1007 nn = p -> reference.c_offset * convert_offset (p -> reference.units); 1008 wo = divide (nn, bits_per_word, 17, 0); 1009 bo = mod (nn, bits_per_word); 1010 1011 if wo ^= 0 1012 then do; 1013 c6 = substr (binoct (bit (wo, 18)), 1, 6); 1014 1015 substr (c6, 1, verify (c6, "0") - 1) = " "; 1016 /* Suppress leading zeros */ 1017 1018 sl.word_offset = c6; 1019 end; 1020 1021 if bo ^= 0 1022 then do; 1023 if wo = 0 1024 then substr (sl.word_offset, 6, 1) = "0"; 1025 1026 sl.bit_offset (1) = "("; 1027 1028 sl.bit_offset (3) = digit (mod (bo, 10)); 1029 1030 bo = divide (bo, 10, 17, 0); 1031 sl.bit_offset (2) = digit (mod (bo, 10)); 1032 1033 sl.bit_offset (4) = ")"; 1034 end; 1035 1036 end; 1037 1038 if sym_pt -> symbol.c_dcl_size ^= 0 1039 then do; 1040 digits_pic = sym_pt -> symbol.c_dcl_size; 1041 number = ltrim (digits_pic); 1042 1043 if substr ("110011000000000000000000000000"b, dtype, 1) 1044 then do; 1045 number = number || ","; 1046 digits_pic = sym_pt -> symbol.scale; 1047 number = number || ltrim (digits_pic); 1048 end; 1049 1050 temp = dt (dtype); 1051 temp = temp || "("; 1052 temp = temp || number; 1053 temp = temp || ")"; 1054 sl.data_type = temp; 1055 end; 1056 else sl.data_type = dt (dtype); 1057 1058 if sym_pt -> symbol.local 1059 then do; 1060 call attrib ("local"); 1061 end; 1062 1063 if sym_pt -> symbol.initialed 1064 then do; 1065 call attrib ("initial"); 1066 end; 1067 1068 if sym_pt -> symbol.array ^= null 1069 then do; 1070 call attrib ("array"); 1071 end; 1072 1073 if sym_pt -> symbol.father ^= null | dtype = 21 1074 then do; 1075 temp = "level " || digit (sym_pt -> symbol.level); 1076 call attrib (temp); 1077 1078 /* Qualify by structure */ 1079 if sym_pt -> symbol.level > 1 & (prev_dupl | next_dupl) 1080 then do; 1081 do p = sym_pt repeat p -> symbol.father while (p -> symbol.level > 1); 1082 end; /* find level 1 containing structure */ 1083 call attrib ("in structure"); /* Print the structure qualification */ 1084 temp = """"; 1085 temp = temp || p -> symbol.token -> token.string; 1086 /* Name of containing structure */ 1087 temp = temp || """"; 1088 call attrib (temp); 1089 end; 1090 1091 if sym_pt -> symbol.packed | sym_pt -> symbol.explicit_packed 1092 then do; 1093 call attrib ("packed"); 1094 end; 1095 1096 end; 1097 1098 if sym_pt -> symbol.packed | sym_pt -> symbol.explicit_packed 1099 then call attrib ("packed"); 1100 1101 if sym_pt -> symbol.unsigned 1102 then do; 1103 call attrib ("unsigned"); 1104 end; 1105 1106 if ^sym_pt -> symbol.aligned 1107 then do; 1108 call attrib ("unaligned"); 1109 end; 1110 1111 if sym_pt -> symbol.file 1112 then do i = 1 to hbound (file_attr_words, 1); 1113 if substr (string (sym_pt -> symbol.file_attributes), i, 1) 1114 then call attrib ((file_attr_words (i))); 1115 end; 1116 1117 done: 1118 if string (sym_pt -> symbol.source_id) ^= (27)"0"b 1119 then do; 1120 call file_line (sym_pt); 1121 temp = "dcl " || number; 1122 call attrib (temp); /* make sure "dcl" and number are on same line */ 1123 1124 /* Qualify by block */ 1125 p = sym_pt -> symbol.block_node; /* Find containing block */ 1126 if (prev_dupl | next_dupl) & p -> block.main ^= null 1127 then do; /* This is a duplicate symbol not contained in the root block */ 1128 call block_name (p, name, dtype); 1129 /* Print block qualification */ 1130 if dtype = bin (begin_block) | dtype = bin (on_unit) 1131 then do; 1132 temp = "in "; /* begin block on line xxx */ 1133 temp = temp || name; 1134 call attrib (temp); 1135 end; 1136 else do; 1137 call attrib ("in procedure"); 1138 /* procedure "name" */ 1139 temp = """"; 1140 temp = temp || name; 1141 temp = temp || """"; 1142 call attrib (temp); 1143 end; 1144 end; 1145 end; 1146 1147 /* Process cross-reference list */ 1148 p = sym_pt -> symbol.cross_references; 1149 ref_too_many = "0"b; 1150 ref_list_length = 0; 1151 1152 /* Create list of cross references */ 1153 do while (p ^= null); 1154 if ref_list_length = hbound (ref_list, 1) 1155 then ref_too_many = "1"b; 1156 else do; 1157 ref_list_length = ref_list_length + 1; 1158 ref_list (ref_list_length) = p; 1159 end; 1160 p = p -> cross_reference.next; 1161 end; 1162 1163 /* Sort the cross reference list within each included file. 1164* (Note: list stored in REVERSE order). 1165* Algorithm is insertion sort, which is the most efficient since list is usually 1166* ordered already. */ 1167 1168 begin; 1169 dcl temp ptr; 1170 dcl compare bit (1); /* Compare next items */ 1171 dcl i fixed bin; /* Next item to be ordered */ 1172 dcl j1 fixed bin; /* Current item being ordered */ 1173 dcl j2 fixed bin; /* Previous item to compare with */ 1174 1175 do i = 2 to ref_list_length; 1176 compare = "1"b; 1177 do j1 = i repeat j2 while (compare & j1 > 1); 1178 /* "Bubble" item back to proper place */ 1179 j2 = j1 - 1; /* Next previous candidate for comparison */ 1180 if ref_list (j2) -> cross_reference.file_number = ref_list (j1) -> cross_reference.file_number 1181 then do; 1182 if ref_list (j2) -> cross_reference.line_number 1183 < ref_list (j1) -> cross_reference.line_number 1184 then do; 1185 temp = ref_list (j1); 1186 /* Exchange items in wrong order */ 1187 ref_list (j1) = ref_list (j2); 1188 ref_list (j2) = temp; 1189 end; 1190 else compare = "0"b; /* Stop bubbling when right order found */ 1191 end; 1192 end; 1193 end; 1194 end; 1195 1196 /* Print the cross reference list */ 1197 if ref_list_length ^= 0 1198 then do; 1199 if sym_pt -> symbol.set 1200 then call attrib ("set"); 1201 call attrib ("ref"); 1202 if ref_too_many 1203 then call attrib ("(more)"); 1204 do i = ref_list_length to 1 by -1; 1205 call file_line ((ref_list (i))); 1206 temp = number; 1207 if ref_list (i) -> cross_reference.set_reference 1208 then temp = temp || "*"; 1209 call attrib (temp); 1210 end; 1211 end; 1212 1213 if something_to_print 1214 then call output_line; 1215 1216 return; 1217 1218 end; /* End print_k */ 1219 1220 /* Convert source line number to char string */ 1221 file_line: 1222 proc (node_pt); 1223 dcl node_pt ptr; 1224 1225 if node_pt -> cross_reference.file_number = "0"b 1226 then number = ""; 1227 else do; 1228 digits_pic = fixed (node_pt -> cross_reference.file_number, 8); 1229 number = ltrim (digits_pic); 1230 number = number || "-"; 1231 end; 1232 1233 digits_pic = fixed (node_pt -> cross_reference.line_number, 14); 1234 number = number || ltrim (digits_pic); 1235 1236 end; /* End of file_line */ 1237 1238 attrib: 1239 proc (input_string); /* store leading space and item in "attributes" column */ 1240 dcl input_string char (296) varying; 1241 1242 if length (input_string) + cur_attrib_col > char_per_line 1243 then call output_line; /* item too big to fit on line */ 1244 if length (input_string) + cur_attrib_col > char_per_line 1245 then call pl1_print$varying_nl ((82)" " || input_string); 1246 /* item too big even for line of its own */ 1247 else do; 1248 substr (line, cur_attrib_col + 1, length (input_string)) = input_string; 1249 /* item fits on line */ 1250 cur_attrib_col = cur_attrib_col + length (input_string) + 1; 1251 /* include leading space */ 1252 something_to_print = "1"b; 1253 end; 1254 end; 1255 1256 output_line: 1257 proc; /* print out and initialize current print line */ 1258 if ^id_printed 1259 then do; 1260 name_width = 38; /* Print identifier. Try for maximum width. */ 1261 if sl.location ^= "" 1262 then name_width = 31; /* Narrower if there is a loc. */ 1263 if sl.word_offset ^= "" 1264 then name_width = 20; /* Narrowest if an offset. */ 1265 if length (id) <= name_width 1266 then substr (line, 1, length (id)) = id;/* Name fits into available space. */ 1267 else call pl1_print$varying_nl (id); /* Doesn't fit. */ 1268 id_printed = "1"b; 1269 end; 1270 call pl1_print$varying_nl (substr (line, 1, cur_attrib_col - 1)); 1271 call init_attrib; 1272 cur_attrib_col = cur_attrib_col + indent; 1273 end; 1274 1275 init_attrib: 1276 proc; /* initialize storing attributes in print line */ 1277 something_to_print = "0"b; 1278 cur_attrib_col = 80; /* col 80 will get a leading space */ 1279 line = ""; /* store spaces in print line (sl) */ 1280 end; 1281 1282 end; /* End of print. */ 1283 1284 print_int_static_table: 1285 proc (int_static_list_st, int_static_list_length); 1286 1287 dcl 1 int_static_list_st 1288 aligned, 1289 2 int_static_list (1024) ptr unaligned; /* For efficiency */ 1290 dcl int_static_list_length 1291 fixed bin; 1292 1293 dcl i fixed bin; 1294 dcl tabs (4) internal static options (constant) fixed bin init (1, 8, 36, 1000); 1295 1296 dcl (loc_item, name_item, procedure_item) 1297 char (256) varying; 1298 1299 if int_static_list_length = 0 1300 then return; /* No internal static variables */ 1301 call pl1_print$varying_nl (" 1302 STORAGE FOR INTERNAL STATIC VARIABLES. 1303 "); 1304 call column_print (tabs, " LOC", "IDENTIFIER", "BLOCK NAME", ""); 1305 call sort_storage_list (int_static_list_st, int_static_list_length, 0); 1306 /* Sort on location */ 1307 do i = 1 to int_static_list_length; 1308 call format_items ((int_static_list (i)), loc_item, name_item, procedure_item); 1309 /* Get strings */ 1310 call column_print (tabs, loc_item, name_item, procedure_item, ""); 1311 end; 1312 end; /* End of print_int_static_table */ 1313 1314 print_auto_table: 1315 proc (auto_list_st, auto_list_length); 1316 1317 dcl 1 auto_list_st aligned, 1318 2 auto_list (1024) ptr unaligned; /* For efficiency */ 1319 dcl auto_list_length fixed bin; 1320 1321 dcl (i, ignored_type) fixed bin; 1322 dcl tabs (4) internal static options (constant) fixed bin init (1, 26, 33, 61); 1323 1324 dcl p ptr; 1325 1326 dcl (stack_frame_item, loc_item, name_item, procedure_item, previous_stack_frame_item) 1327 char (256) varying; 1328 1329 if auto_list_length = 0 1330 then return; /* No automatic variables */ 1331 previous_stack_frame_item = ""; 1332 call pl1_print$varying_nl (" 1333 STORAGE FOR AUTOMATIC VARIABLES. 1334 "); 1335 call column_print (tabs, "STACK FRAME", " LOC", "IDENTIFIER", "BLOCK NAME"); 1336 call sort_storage_list (auto_list_st, auto_list_length, 1); 1337 /* Sort on location and stack frame */ 1338 do i = 1 to auto_list_length; 1339 p = auto_list (i) -> symbol.block_node; /* Find stack frame owner */ 1340 if p -> block.owner ^= null 1341 then p = p -> block.owner; 1342 call block_name (p, stack_frame_item, ignored_type); 1343 call format_items ((auto_list (i)), loc_item, name_item, procedure_item); 1344 /* Get strings */ 1345 if stack_frame_item = previous_stack_frame_item 1346 then stack_frame_item = ""; /* Blank out duplicate stack frame names */ 1347 else previous_stack_frame_item = stack_frame_item; 1348 call column_print (tabs, stack_frame_item, loc_item, name_item, procedure_item); 1349 end; 1350 end; /* End of print_auto_table */ 1351 1352 column_print: 1353 proc (tabs, v1, v2, v3, v4); 1354 1355 dcl tabs (4) fixed bin; 1356 dcl (v1, v2, v3, v4) char (256) varying; 1357 1358 dcl line char (512) varying; 1359 1360 line = v1; 1361 call print_item (tabs (2), v2); 1362 call print_item (tabs (3), v3); 1363 if v4 ^= "" 1364 then call print_item (tabs (4), v4); 1365 if line ^= "" 1366 then call pl1_print$varying_nl (line); 1367 return; 1368 1369 print_item: 1370 proc (tab, input_string); 1371 1372 dcl tab fixed bin; 1373 dcl input_string char (256) varying; 1374 1375 dcl copy builtin; 1376 1377 if length (line) < tab - 1 1378 then line = line || copy (" ", tab - 1 - length (line)); 1379 /* Input string fits on same line */ 1380 /* Pad to tab */ 1381 else do; /* Previous item exceeded current tab */ 1382 call pl1_print$varying_nl (line); /* Print all but current item */ 1383 line = copy (" ", tab - 1); /* Pad next line to tab */ 1384 end; 1385 line = line || input_string; /* Store item on current line */ 1386 end; /* End of print_item */ 1387 1388 end; /* End of column_print */ 1389 1390 sort_storage_list: 1391 proc (saved_list_st, saved_list_length, sorting_field); 1392 1393 dcl 1 saved_list_st aligned, 1394 2 saved_list (1024) ptr unaligned; /* For efficiency */ 1395 dcl saved_list_length fixed bin; 1396 dcl sorting_field fixed bin; 1397 1398 dcl (d, i, j, k) fixed bin; 1399 dcl ignored_type fixed bin; 1400 dcl (p1, p2) ptr; 1401 dcl p1_owner ptr; 1402 dcl p2_owner ptr; 1403 dcl (compare, interchange) 1404 bit (1); 1405 dcl p1_owner_name char (256) varying; 1406 dcl p2_owner_name char (256) varying; 1407 1408 /* Sort saved list of symbols on location or loc/stack owner. 1409* Algorithm is Shell sort. */ 1410 1411 d = saved_list_length; 1412 do while (d > 1); 1413 d = 2 * divide (d, 4, 17, 0) + 1; 1414 do i = 1 to saved_list_length - d; 1415 k = i + d; 1416 p2 = saved_list (k); 1417 compare = "1"b; 1418 do while (compare); 1419 compare = "0"b; 1420 j = k - d; 1421 p1 = saved_list (j); 1422 if sorting_field = 0 1423 then interchange = p1 -> symbol.location > p2 -> symbol.location; 1424 else do; 1425 p1_owner = p1 -> symbol.block_node; 1426 /* Find stack frame owners of p1 and p2 */ 1427 if p1_owner -> block.owner ^= null 1428 then p1_owner = p1_owner -> block.owner; 1429 p2_owner = p2 -> symbol.block_node; 1430 if p2_owner -> block.owner ^= null 1431 then p2_owner = p2_owner -> block.owner; 1432 if p1_owner = p2_owner 1433 then interchange = p1 -> symbol.location > p2 -> symbol.location; 1434 /* Sort symbols with same stack owner by loc */ 1435 else do; 1436 call block_name (p1_owner, p1_owner_name, ignored_type); 1437 /* Sort symbols by stack owner's name */ 1438 call block_name (p2_owner, p2_owner_name, ignored_type); 1439 interchange = p1_owner_name > p2_owner_name; 1440 end; 1441 end; 1442 if interchange 1443 then do; 1444 saved_list (j) = saved_list (k); 1445 /* Interchange out-of-order symbols */ 1446 saved_list (k) = p1; 1447 if j > d 1448 then do; 1449 k = j; 1450 compare = "1"b; 1451 end; 1452 end; 1453 end; 1454 end; 1455 end; 1456 1457 end; /* End of sort_storage_list */ 1458 1459 format_items: 1460 proc (sym_pt, loc_item, name_item, procedure_item); 1461 1462 dcl sym_pt ptr; 1463 dcl (loc_item, name_item, procedure_item) 1464 char (256) varying; 1465 1466 dcl type fixed bin; 1467 dcl bit builtin; 1468 1469 /* Get various strings from symbol node ptr */ 1470 1471 loc_item = substr (binoct (bit (fixed (sym_pt -> symbol.location, 18), 18)), 1, 6); 1472 name_item = sym_pt -> symbol.token -> token.string; 1473 call block_name ((sym_pt -> symbol.block_node), procedure_item, type); 1474 1475 end; /* End of format_items */ 1476 1477 end; /* End of pl1_symbol_print. */ SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/18/00 1130.1 pl1_symbol_print.pl1 >udd>sm>ds>w>ml>pl1_symbol_print.pl1 130 1 07/21/80 1646.3 nodes.incl.pl1 >ldd>incl>nodes.incl.pl1 131 2 10/25/79 1745.8 declare_type.incl.pl1 >ldd>incl>declare_type.incl.pl1 132 3 11/02/83 1945.0 operator_names.incl.pl1 >ldd>incl>operator_names.incl.pl1 133 4 08/13/81 2311.5 list.incl.pl1 >ldd>incl>list.incl.pl1 134 5 08/13/81 2143.5 block.incl.pl1 >ldd>incl>block.incl.pl1 135 6 05/03/76 1420.8 block_types.incl.pl1 >ldd>incl>block_types.incl.pl1 136 7 12/07/83 1801.7 symbol.incl.pl1 >ldd>incl>symbol.incl.pl1 137 8 07/21/80 1646.3 reference.incl.pl1 >ldd>incl>reference.incl.pl1 138 9 04/07/83 1735.0 statement.incl.pl1 >ldd>incl>statement.incl.pl1 139 10 09/14/77 1805.7 token.incl.pl1 >ldd>incl>token.incl.pl1 140 11 08/05/77 1122.5 object_map.incl.pl1 >ldd>incl>object_map.incl.pl1 776 12 10/25/79 1745.8 cgsystem.incl.pl1 >ldd>incl>cgsystem.incl.pl1 777 13 05/06/74 1842.1 label.incl.pl1 >ldd>incl>label.incl.pl1 778 14 10/25/79 1745.8 cross_reference.incl.pl1 >ldd>incl>cross_reference.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. FF 010347 constant char(1) initial dcl 129 ref 144 addr builtin function dcl 108 ref 164 164 186 186 287 298 305 394 394 780 aligned 31(21) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 1106 allocate 33(02) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 382 615 672 799 allocated 1(18) based bit(1) level 2 packed packed unaligned dcl 7-3 ref 968 area 31(07) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 962 array 2(15) based bit(1) level 2 in structure "label" packed packed unaligned dcl 13-1 in procedure "print" ref 836 array 12 based pointer level 2 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 1068 attributes 31 based structure level 2 dcl 7-3 auto_list 022174 automatic pointer array level 2 in structure "auto_list_st" packed packed unaligned dcl 117 in procedure "pl1_symbol_print" set ref 986 990* auto_list parameter pointer array level 2 in structure "auto_list_st" packed packed unaligned dcl 1317 in procedure "print_auto_table" set ref 1339 1343 auto_list_length parameter fixed bin(17,0) dcl 1319 in procedure "print_auto_table" set ref 1314 1329 1336* 1338 auto_list_length 000111 automatic fixed bin(17,0) dcl 75 in procedure "pl1_symbol_print" set ref 154* 275* 986 986* 989* 989 990 auto_list_st 022174 automatic structure level 1 dcl 117 in procedure "pl1_symbol_print" set ref 275* auto_list_st parameter structure level 1 dcl 1317 in procedure "print_auto_table" set ref 1314 1336* auto_static_const constant bit(10) initial packed unaligned dcl 748 ref 968 based_string based char dcl 106 ref 316 begin_block constant bit(9) initial dcl 6-1 ref 482 557 559 1130 bin builtin function dcl 108 ref 482 482 495 1130 1130 binoct 000032 constant entry external dcl 121 ref 995 1013 1471 bit builtin function dcl 770 in procedure "print" ref 995 995 1013 1013 bit 31(03) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 918 bit builtin function dcl 1467 in procedure "format_items" ref 1471 1471 bit_offset 6(27) 027474 automatic char(1) array level 2 packed packed unaligned dcl 754 set ref 1026* 1028* 1031* 1033* bits_per_word 010346 constant fixed bin(8,0) initial dcl 12-5 ref 1008 1009 bline 025035 automatic structure level 1 dcl 441 set ref 462* 522 522 522 524* 540 540 540 blk 025104 automatic pointer dcl 551 set ref 554* 555 557 557 559 563 566 570 574 blkp parameter pointer dcl 547 ref 544 554 block based structure level 1 dcl 5-5 block_node 4 based pointer level 2 packed packed unaligned dcl 7-3 ref 1125 1339 1425 1429 1473 block_pt 000104 automatic pointer dcl 646 in procedure "sort_on_dcl_type" set ref 654* 655 657 681 685* 685 block_pt 000102 automatic pointer dcl 593 in procedure "select_all_symbols" set ref 597* 598 600 624 628* 628 block_type 24 based bit(9) level 2 in structure "block" packed packed unaligned dcl 5-5 in procedure "pl1_symbol_print" ref 555 557 557 559 block_type 001005 constant varying char(18) initial array dcl 450 in procedure "prt_block" ref 469 484 bo 027130 automatic fixed bin(17,0) dcl 703 set ref 1009* 1021 1028 1030* 1030 1031 bp 024624 automatic pointer dcl 436 set ref 461* 464* 471 473 492 501 509 brother 2 based pointer level 2 packed packed unaligned dcl 5-5 ref 262 262 266 269 628 685 bt1 024630 automatic fixed bin(17,0) dcl 436 set ref 464* 469 495 bt2 024631 automatic fixed bin(17,0) dcl 436 set ref 480* 482 482 484 builtin 31(16) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 855 by_compiler constant bit(3) initial dcl 2-5 ref 75 75 605 by_context constant bit(3) initial dcl 2-5 ref 75 by_declare constant bit(3) initial dcl 2-5 ref 75 75 by_explicit_context constant bit(3) initial dcl 2-5 ref 75 75 by_implication constant bit(3) initial dcl 2-5 ref 75 c6 027460 automatic char(6) packed unaligned dcl 712 set ref 1013* 1015 1015* 1018 c_dcl_size 30 based fixed bin(24,0) level 2 dcl 7-3 ref 1038 1040 c_offset 1 based fixed bin(24,0) level 2 dcl 8-3 ref 1007 cg_error 000036 constant entry external dcl 121 ref 181 977 986 cg_static_$bit_count 000014 external static fixed bin(17,0) dcl 89 ref 243 243 cg_static_$ext_proc_list 000016 external static pointer dcl 89 ref 337 cg_static_$ext_var_list 000020 external static pointer dcl 89 ref 341 cg_static_$objmap_pt 000024 external static pointer dcl 89 ref 235 cg_static_$root 000022 external static pointer dcl 89 ref 255 266 cg_static_$used_operator 000012 external static bit(900) packed unaligned dcl 89 ref 277 289 char 31(04) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 912 char_per_line constant fixed bin(17,0) initial dcl 726 ref 1242 1244 class 11(27) 027474 automatic char(15) level 2 packed packed unaligned dcl 754 set ref 999* class_name 000372 constant char(20) initial array dcl 730 ref 999 compare 031112 automatic bit(1) packed unaligned dcl 1403 in procedure "sort_storage_list" set ref 1417* 1418 1419* 1450* compare 027556 automatic bit(1) packed unaligned dcl 1170 in begin block on line 1168 set ref 1176* 1177 1190* compiler_developed 32(35) based structure level 3 packed packed unaligned dcl 7-3 complex 31(31) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 907 condition 31(14) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 887 convert_offset 000010 constant fixed bin(8,1) initial array dcl 12-35 ref 1007 copy builtin function dcl 1375 ref 1377 1383 cross_reference based structure level 1 dcl 14-3 cross_references 10 based pointer level 2 packed packed unaligned dcl 7-3 ref 382 615 672 799 1148 ctype 027123 automatic fixed bin(17,0) dcl 703 set ref 828* 833* 879* 881* 889* 965* 975 984 999 cur_attrib_col 027126 automatic fixed bin(17,0) dcl 703 set ref 1242 1244 1248 1250* 1250 1270 1270 1272* 1272 1278* d 031074 automatic fixed bin(17,0) dcl 1398 set ref 1411* 1412 1413* 1413 1414 1415 1420 1447 data_type 15(27) 027474 automatic char(25) level 2 in structure "sl" packed packed unaligned dcl 754 in procedure "print" set ref 834* 857* 863* 1054* 1056* data_type 31 based structure level 3 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" dcl_type 1(19) based bit(3) level 2 packed packed unaligned dcl 7-3 ref 603 660 decimal 31(28) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 904 declaration 4 based pointer level 2 packed packed unaligned dcl 5-5 ref 600 657 declare_type 001043 constant varying char(24) initial array dcl 75 ref 199 207 definition_length 4(18) based bit(18) level 2 packed packed unaligned dcl 11-10 ref 243 243 definition_offset 4 based bit(18) level 2 packed packed unaligned dcl 11-10 ref 237 237 digit 000016 constant char(1) initial array dcl 773 ref 1028 1031 1075 digits_pic 000100 automatic picture(8) packed unaligned dcl 74 set ref 566* 567 570* 571 1040* 1041 1046* 1047 1228* 1229 1233* 1234 divide builtin function dcl 108 ref 243 243 1008 1030 1413 do_cp_dcl parameter bit(1) dcl 70 ref 67 171 605 dt 000100 automatic bit(3) dcl 593 in procedure "select_all_symbols" set ref 603* 605 dt 000130 constant varying char(17) initial array dcl 737 in procedure "print" ref 834 1050 1056 dt 000100 automatic bit(3) dcl 646 in procedure "sort_on_dcl_type" set ref 660* 662 662 dt1 000101 automatic bit(3) dcl 646 in procedure "sort_on_dcl_type" set ref 651* 662 682* dt1 000161 automatic bit(3) initial array dcl 75 in procedure "pl1_symbol_print" set ref 75* 75* 75* 75* 177 dt2 000102 automatic bit(3) dcl 646 in procedure "sort_on_dcl_type" set ref 652* 662 682* dt2 000165 automatic bit(3) initial array dcl 75 in procedure "pl1_symbol_print" set ref 75* 75* 75* 75* 177 dtp1 parameter bit(3) dcl 642 ref 639 651 dtp2 parameter bit(3) dcl 642 ref 639 652 dtype 027124 automatic fixed bin(17,0) dcl 703 set ref 828* 874* 878* 890* 896* 902* 904* 904 907* 907 914* 920* 922* 922 930* 936* 942* 948* 950* 950 956* 958* 960* 962* 1043 1050 1056 1073 1128* 1130 1130 element 1 based pointer array level 2 packed packed unaligned dcl 4-6 ref 380 387 574 entry 31(09) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 869 explicit_packed 31(13) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 1091 1098 ext 027125 automatic fixed bin(17,0) dcl 703 set ref 867* 883 965 ext_code parameter fixed bin(17,0) dcl 353 ref 348 361 external 32(02) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 867 879 external_procedure constant bit(9) initial dcl 6-1 ref 495 father 17 based pointer level 2 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 1073 1082 father 1 based pointer level 2 in structure "block" packed packed unaligned dcl 5-5 in procedure "pl1_symbol_print" ref 265 267 475 file 31(10) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 946 1111 file_attr_words 000030 constant varying char(11) initial array dcl 744 ref 1111 1113 file_attributes 32(19) based structure level 3 packed packed unaligned dcl 7-3 ref 1113 file_number 0(09) based bit(8) level 3 in structure "block" packed packed unaligned dcl 5-5 in procedure "pl1_symbol_print" ref 563 566 file_number 0(09) based bit(8) level 3 in structure "cross_reference" packed packed unaligned dcl 14-3 in procedure "print" ref 1180 1180 1225 1228 first based fixed bin(18,0) level 2 dcl 3-7 ref 296 298 303 305 fixed 31(01) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 894 fixed builtin function dcl 108 in procedure "pl1_symbol_print" ref 237 237 237 237 237 237 237 237 243 243 243 243 243 243 243 243 243 243 312 555 566 570 867 995 995 1228 1233 1471 1471 float 31(02) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 900 format 31(15) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 940 fp 024626 automatic pointer dcl 436 set ref 473* 474 475 475* 475 477* 477 480* generic 31(17) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 861 hbound builtin function dcl 108 ref 179 181 181 183 500 503 609 666 977 986 1111 1154 hder_has_ext 024411 automatic varying char(512) dcl 357 set ref 365* 371* 393* hder_no_ext 024210 automatic varying char(512) dcl 357 set ref 363* 369* 425* 427* high_bound 3(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 13-1 ref 847 i 027622 automatic fixed bin(17,0) dcl 1293 in procedure "print_int_static_table" set ref 1307* 1308* i 027131 automatic fixed bin(17,0) dcl 703 in procedure "print" set ref 1111* 1113 1113* 1204* 1205 1207* i 027557 automatic fixed bin(17,0) dcl 1171 in begin block on line 1168 set ref 1175* 1177* i 031075 automatic fixed bin(17,0) dcl 1398 in procedure "sort_storage_list" set ref 1414* 1415* i 030136 automatic fixed bin(17,0) dcl 1321 in procedure "print_auto_table" set ref 1338* 1339 1343* i 000102 automatic fixed bin(17,0) dcl 75 in procedure "pl1_symbol_print" set ref 171* 171* 177 177 189 199 207 213* 285* 316 318 319* 319 321 325* 396* 403 407* 411 412 419* 419 500* 501 503 509 519 528* id 027137 automatic varying char(256) dcl 708 set ref 829* 1265 1265 1265 1267* id_printed 027465 automatic bit(1) packed unaligned dcl 716 set ref 830* 1258 1268* ignore 027133 automatic fixed bin(17,0) dcl 703 set ref 781* 797 801 801 ignore_code parameter fixed bin(17,0) dcl 695 ref 690 781 ignore_symbol 027467 automatic bit(1) packed unaligned dcl 718 set ref 796* 801* 806 ignored_type 031100 automatic fixed bin(17,0) dcl 1399 in procedure "sort_storage_list" set ref 1436* 1438* ignored_type 030137 automatic fixed bin(17,0) dcl 1321 in procedure "print_auto_table" set ref 1342* indent constant fixed bin(17,0) initial dcl 750 ref 1272 index builtin function dcl 108 ref 289 965 info 17 025035 automatic char(70) level 2 dcl 441 set ref 488* 497* 506* 511* 515* 520 522 528* 534 536* 540 info_len 024632 automatic fixed bin(17,0) dcl 436 set ref 489* 493* 498* 503 506 507* 507 511 512* 512 515 516* 516 520 522 525* 528 529* 529 534 534 536 537* 537 540 initial 11 based pointer level 2 packed packed unaligned dcl 7-3 ref 879 initialed 31(20) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 1063 input_string parameter varying char(256) dcl 1373 in procedure "print_item" ref 1369 1385 input_string parameter varying char(296) dcl 1240 in procedure "attrib" ref 1238 1242 1244 1244 1248 1248 1250 int_ext 000562 constant char(8) initial array packed unaligned dcl 728 ref 883 int_static_list parameter pointer array level 2 in structure "int_static_list_st" packed packed unaligned dcl 1287 in procedure "print_int_static_table" set ref 1308 int_static_list 020174 automatic pointer array level 2 in structure "int_static_list_st" packed packed unaligned dcl 114 in procedure "pl1_symbol_print" set ref 977 981* int_static_list_length parameter fixed bin(17,0) dcl 1290 in procedure "print_int_static_table" set ref 1284 1299 1305* 1307 int_static_list_length 000110 automatic fixed bin(17,0) dcl 75 in procedure "pl1_symbol_print" set ref 153* 273* 977 977* 980* 980 981 int_static_list_st parameter structure level 1 dcl 1287 in procedure "print_int_static_table" set ref 1284 1305* int_static_list_st 020174 automatic structure level 1 dcl 114 in procedure "pl1_symbol_print" set ref 273* interchange 031113 automatic bit(1) packed unaligned dcl 1403 set ref 1422* 1432* 1439* 1442 ioa_$rsnpnnl 000034 constant entry external dcl 121 ref 237 243 j 000103 automatic fixed bin(17,0) dcl 75 in procedure "pl1_symbol_print" set ref 286* 318* 323* 326* 334 334* 397* 405* 408* 412* 422 422* j 031076 automatic fixed bin(17,0) dcl 1398 in procedure "sort_storage_list" set ref 1420* 1421 1444 1447 1449 j1 027560 automatic fixed bin(17,0) dcl 1172 set ref 1177* 1177* 1179 1180 1182 1185 1187* j2 027561 automatic fixed bin(17,0) dcl 1173 set ref 1179* 1180 1182 1187 1188 1192 k 027122 automatic fixed bin(17,0) dcl 703 in procedure "print" set ref 785* 808 811 816* 826 k 031077 automatic fixed bin(17,0) dcl 1398 in procedure "sort_storage_list" set ref 1415* 1416 1420 1444 1446 1449* k 000104 automatic fixed bin(17,0) dcl 75 in procedure "pl1_symbol_print" set ref 192* 196* 210* 237* 241* 243* 248* 285* 289 295* 295 296 296 298 303 329* 329 399* 400* label 31(08) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 934 label based structure level 1 dcl 13-1 in procedure "print" label_node constant bit(9) initial dcl 1-5 ref 831 1001 labels 4 based pointer level 2 packed packed unaligned dcl 9-9 ref 574 last 1 based fixed bin(18,0) level 2 dcl 3-7 ref 296 303 305 last_auto_loc 46 based fixed bin(17,0) level 2 dcl 5-5 ref 492 length builtin function dcl 108 ref 465 465 489 498 519 520 522 522 534 540 540 1242 1244 1248 1250 1265 1265 1377 1377 level 2(11) based fixed bin(8,0) level 2 packed packed unaligned dcl 7-3 ref 615 672 797 801 973 1075 1079 1081 line 030656 automatic varying char(512) dcl 1358 in procedure "column_print" set ref 1360* 1365 1365* 1377 1377* 1377 1377 1382* 1383* 1385* 1385 line 000120 automatic char(132) dcl 75 in procedure "pl1_symbol_print" set ref 237* 241* 243* 248* 284* 316* 323* 324* 334* 395* 405* 406* 411* 422* line defined char(132) packed unaligned dcl 768 in procedure "print" set ref 780 1248* 1265* 1270 1270 1279* line_number 0(17) based bit(14) level 3 in structure "block" packed packed unaligned dcl 5-5 in procedure "pl1_symbol_print" ref 570 line_number 0(17) based bit(14) level 3 in structure "cross_reference" packed packed unaligned dcl 14-3 in procedure "print" ref 1182 1182 1233 line_pt 027472 automatic pointer dcl 752 set ref 780* linkage_length 5(18) based bit(18) level 2 packed packed unaligned dcl 11-10 ref 243 243 linkage_offset 5 based bit(18) level 2 packed packed unaligned dcl 11-10 ref 237 237 list based structure level 1 dcl 4-6 loc_item 030243 automatic varying char(256) dcl 1326 in procedure "print_auto_table" set ref 1343* 1348* loc_item parameter varying char(256) dcl 1463 in procedure "format_items" set ref 1459 1471* loc_item 027623 automatic varying char(256) dcl 1296 in procedure "print_int_static_table" set ref 1308* 1310* local 31(27) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 1058 location 10 027474 automatic char(6) level 2 in structure "sl" packed packed unaligned dcl 754 in procedure "print" set ref 995* 1261 location 1 based fixed bin(18,0) level 2 in structure "symbol" packed packed unsigned unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 995 995 1422 1422 1432 1432 1471 1471 low_bound 3 based fixed bin(17,0) level 2 packed packed unaligned dcl 13-1 ref 840 842 ltrim builtin function dcl 108 in procedure "pl1_symbol_print" ref 567 571 ltrim builtin function dcl 770 in procedure "print" ref 843 848 1041 1047 1229 1234 m 000105 automatic fixed bin(17,0) dcl 75 set ref 416* 417 417 main 13 based pointer level 2 packed packed unaligned dcl 5-5 ref 574 1126 misc_attributes 31(19) based structure level 3 packed packed unaligned dcl 7-3 mod builtin function dcl 108 ref 416 1009 1028 1031 n 000106 automatic fixed bin(17,0) dcl 75 set ref 160* 162 164* 175* 179 183* 186 186* 191 195 289* 292 295 302* 303 305* 377* 384* 384 385 390 394* 399 519* 520 528 529 609 612* 612 613 666 669* 669 670 786 name parameter varying char(256) dcl 547 in procedure "block_name" set ref 544 559* 561* 562* 562 567* 567 568* 568 571* 571 575* 577* 580* name 025035 automatic char(29) level 2 in structure "bline" packed packed unaligned dcl 441 in procedure "prt_block" set ref 465 467* name 027240 automatic varying char(256) dcl 709 in procedure "print" set ref 1128* 1133 1140 name1 024633 automatic varying char(256) dcl 436 set ref 464* 465 465* 467 481* 484* 484 485* 485 487* 487 488 489 name2 024734 automatic varying char(256) dcl 436 set ref 480* 487 name_item parameter varying char(256) dcl 1463 in procedure "format_items" set ref 1459 1472* name_item 027724 automatic varying char(256) dcl 1296 in procedure "print_int_static_table" set ref 1308* 1310* name_item 030344 automatic varying char(256) dcl 1326 in procedure "print_auto_table" set ref 1343* 1348* name_pair based structure level 1 dcl 102 name_ptr 025106 automatic pointer dcl 552 set ref 574* 575 575 577 577 name_width 027132 automatic fixed bin(17,0) dcl 703 set ref 1260* 1261* 1263* 1265 namep based bit(18) array level 3 packed packed unaligned dcl 3-7 set ref 305 names 5 based structure array level 2 dcl 3-7 set ref 298 next 6 based pointer level 2 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 620 677 next 1 based pointer level 2 in structure "cross_reference" packed packed unaligned dcl 14-3 in procedure "print" ref 1160 next_dupl 027464 automatic bit(1) packed unaligned dcl 715 set ref 784* 810 811* 1079 1126 next_k 027134 automatic fixed bin(17,0) dcl 705 set ref 786* 795 811 816* nn 027127 automatic fixed bin(17,0) dcl 703 set ref 1007* 1008 1009 no_object parameter bit(1) dcl 70 ref 67 229 no_stack 24(22) based bit(1) level 2 packed packed unaligned dcl 5-5 ref 471 474 node based structure level 1 dcl 1-27 node_pt parameter pointer dcl 1223 ref 1221 1225 1228 1233 node_type based bit(9) level 2 in structure "reference" packed packed unaligned dcl 8-3 in procedure "pl1_symbol_print" ref 575 node_type based bit(9) level 2 in structure "token" packed packed unaligned dcl 10-3 in procedure "pl1_symbol_print" ref 577 nonquick_reasons 000566 constant varying char(40) initial array dcl 453 ref 500 503 519 528 null builtin function dcl 646 in procedure "sort_on_dcl_type" ref 655 658 672 682 null builtin function dcl 110 in procedure "pl1_symbol_print" ref 257 260 262 266 375 379 382 475 799 879 1005 1068 1073 1126 1153 1340 1427 1430 null builtin function dcl 593 in procedure "select_all_symbols" ref 598 601 615 625 number 027454 automatic varying char(12) dcl 711 set ref 1041* 1045* 1045 1047* 1047 1052 1121 1206 1225* 1229* 1230* 1230 1234* 1234 number_special 4 based fixed bin(17,0) level 2 dcl 3-7 ref 302 object_map based structure level 1 dcl 11-10 offset based fixed bin(18,0) array level 3 in structure "operator_names" dcl 3-7 in procedure "pl1_symbol_print" ref 303 offset 5 based pointer level 2 in structure "reference" packed packed unaligned dcl 8-3 in procedure "pl1_symbol_print" ref 1005 offset 31(06) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 958 on_unit constant bit(9) initial dcl 6-1 ref 482 557 1130 op_names_pt 024174 automatic pointer dcl 3-5 set ref 287* 296 296 298 302 303 305 operator_names based structure level 1 dcl 3-7 owner 54 based pointer level 2 dcl 5-5 ref 475 477 1340 1340 1427 1427 1430 1430 p 000114 automatic pointer dcl 75 in procedure "pl1_symbol_print" set ref 255* 257 258* 260 260* 260 262 262* 262 265* 265 266 266 267* 267 269* 269 298* 305* 312 314* 314 314 316 337* 341* 375 379 380 387* 387 400* 401 411 p 030140 automatic pointer dcl 1324 in procedure "print_auto_table" set ref 1339* 1340 1340* 1340 1342* p 025120 automatic pointer dcl 701 in procedure "print" set ref 1004* 1005 1007 1007 1081* 1081* 1082 1085 1125* 1126 1128* 1148* 1153 1158 1160* 1160 p1 031102 automatic pointer dcl 1400 set ref 1421* 1422 1425 1432 1446 p1_owner 031106 automatic pointer dcl 1401 set ref 1425* 1427 1427* 1427 1432 1436* p1_owner_name 031114 automatic varying char(256) dcl 1405 set ref 1436* 1439 p2 031104 automatic pointer dcl 1400 set ref 1416* 1422 1429 1432 p2_owner 031110 automatic pointer dcl 1402 set ref 1429* 1430 1430* 1430 1432 1438* p2_owner_name 031215 automatic varying char(256) dcl 1406 set ref 1438* 1439 packed 33 based bit(1) level 4 packed packed unaligned dcl 7-3 ref 1091 1098 picture 31(18) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 928 pl1_operator_names_$pl1_operator_names_ 000026 external static fixed bin(17,0) dcl 89 set ref 287 pl1_print$non_varying_nl 000042 constant entry external dcl 121 ref 241 248 323 334 405 422 522 540 pl1_print$varying_nl 000040 constant entry external dcl 121 ref 144 148 150 165 169 199 207 219 232 250 252 281 343 393 425 427 465 1244 1267 1270 1301 1332 1365 1382 pl1_stat_$single_symbol_list 000010 external static bit(1) dcl 87 ref 158 prev_dupl 027463 automatic bit(1) packed unaligned dcl 714 set ref 810* 819* 1079 1126 previous_stack_frame_item 030546 automatic varying char(256) dcl 1326 set ref 1331* 1345 1347* procedure_item 030445 automatic varying char(256) dcl 1326 in procedure "print_auto_table" set ref 1343* 1348* procedure_item parameter varying char(256) dcl 1463 in procedure "format_items" set ref 1459 1473* procedure_item 030025 automatic varying char(256) dcl 1296 in procedure "print_int_static_table" set ref 1308* 1310* pt parameter pointer dcl 642 in procedure "sort_on_dcl_type" ref 639 654 pt parameter pointer dcl 434 in procedure "prt_block" ref 431 461 pt parameter pointer dcl 592 in procedure "select_all_symbols" ref 589 597 ptr 31(05) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 956 ptr builtin function dcl 110 in procedure "pl1_symbol_print" ref 314 q 000116 automatic pointer dcl 75 set ref 235* 237 237 237 237 237 237 237 237 243 243 243 243 243 243 243 243 243 243 ref_list 025122 automatic pointer array packed unaligned dcl 702 set ref 1154 1158* 1180 1180 1182 1182 1185 1187* 1187 1188* 1205 1207 ref_list_length 027135 automatic fixed bin(17,0) dcl 706 set ref 1150* 1154 1157* 1157 1158 1175 1197 1204 ref_too_many 027462 automatic bit(1) packed unaligned dcl 713 set ref 1149* 1154* 1202 ref_type 2 based structure level 2 packed packed unaligned dcl 14-3 reference based structure level 1 dcl 8-3 in procedure "pl1_symbol_print" reference 15 based pointer level 2 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 1004 reference_node constant bit(9) initial dcl 1-5 ref 575 referenced 027544 automatic bit(1) packed unaligned dcl 794 set ref 799* 801 801 801 rel_ptr based bit(18) level 2 packed packed unaligned dcl 102 ref 314 root parameter pointer dcl 70 set ref 67 161* 177* s 000172 automatic varying char(1) dcl 75 set ref 203* 205* 207 215* 217* 219 saved_list parameter pointer array level 2 packed packed unaligned dcl 1393 set ref 1416 1421 1444* 1444 1446* saved_list_length parameter fixed bin(17,0) dcl 1395 ref 1390 1411 1414 saved_list_st parameter structure level 1 dcl 1393 set ref 1390 scale 2(28) based fixed bin(7,0) level 2 packed packed unaligned dcl 7-3 ref 1046 set 33(03) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 1199 set_reference 2 based bit(1) level 3 packed packed unaligned dcl 14-3 ref 1207 six_digits 027470 automatic picture(7) packed unaligned dcl 722 set ref 842* 843 847* 848 size 0(18) based bit(18) level 2 in structure "name_pair" packed packed unaligned dcl 102 in procedure "pl1_symbol_print" ref 312 size 000107 automatic fixed bin(17,0) dcl 75 in procedure "pl1_symbol_print" set ref 191* 195* 199 203 312* 316 316 318 401* 403 411 412 413 413* 413 416 417* 417 419 size 10(09) 025035 automatic picture(6) level 2 in structure "bline" packed packed unaligned dcl 441 in procedure "prt_block" set ref 492* size 3 based fixed bin(9,0) level 2 in structure "token" dcl 10-3 in procedure "pl1_symbol_print" ref 401 411 575 577 811 811 829 1085 1472 sl 027474 automatic structure level 1 packed packed unaligned dcl 754 set ref 780 780 1248 1248 1265 1265 1270 1270 1270 1270 1279* 1279 something_to_print 027466 automatic bit(1) packed unaligned dcl 717 set ref 1213 1252* 1277* son 3 based pointer level 2 packed packed unaligned dcl 5-5 ref 255 260 260 624 681 sorting_field parameter fixed bin(17,0) dcl 1396 ref 1390 1422 source_id 0(09) based structure level 2 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 1117 source_id 0(09) based structure level 2 in structure "cross_reference" packed packed unaligned dcl 14-3 in procedure "print" source_id 0(09) based structure level 2 in structure "block" packed packed unaligned dcl 5-5 in procedure "pl1_symbol_print" special based structure array level 2 dcl 3-7 stack_frame_item 030142 automatic varying char(256) dcl 1326 set ref 1342* 1345 1345* 1347 1348* statement based structure level 1 dcl 9-9 static_length 6(18) based bit(18) level 2 packed packed unaligned dcl 11-10 ref 243 243 static_offset 6 based bit(18) level 2 packed packed unaligned dcl 11-10 ref 237 237 storage_class 32(09) based structure level 3 packed packed unaligned dcl 7-3 ref 965 968 string builtin function dcl 110 in procedure "pl1_symbol_print" set ref 462* 501 509 522 522 522 524* 540 540 540 965 968 1113 1117 string 4 based char level 2 in structure "token" dcl 10-3 in procedure "pl1_symbol_print" ref 411 575 577 811 811 829 1085 1472 structure 31 based bit(1) level 4 packed packed unaligned dcl 7-3 ref 960 substr builtin function dcl 110 set ref 289 316* 411* 501 506* 509 511* 515* 528* 536* 995 999 1013 1015* 1023* 1043 1113 1248* 1265* 1270 1270 1471 sym2 024612 automatic pointer dcl 359 set ref 380* 382 382 385 sym_pt 000106 automatic pointer dcl 646 in procedure "sort_on_dcl_type" set ref 657* 658 660 670 672 672 672 677* 677 681* 682 682* sym_pt 000104 automatic pointer dcl 593 in procedure "select_all_symbols" set ref 600* 601 603 613 615 615 615 620* 620 624* 625 625* sym_pt 027542 automatic pointer dcl 793 in begin block on line 792 set ref 795* 797 799 799 801 sym_pt 025116 automatic pointer dcl 701 in procedure "print" set ref 826* 829 831 836 840 842 847 855 861 867 869 872 879 879 887 894 900 904 907 912 918 922 928 934 940 946 950 956 958 960 962 965 968 968 973 981 990 995 995 1001 1004 1038 1040 1046 1058 1063 1068 1073 1075 1079 1081 1091 1091 1098 1098 1101 1106 1111 1113 1117 1120* 1125 1148 1199 sym_pt parameter pointer dcl 1462 in procedure "format_items" ref 1459 1471 1471 1472 1473 sym_sort_alphabetic 000030 constant entry external dcl 120 ref 164 186 394 symbol 3 based pointer level 2 in structure "reference" packed packed unaligned dcl 8-3 in procedure "pl1_symbol_print" ref 575 symbol based structure level 1 dcl 7-3 in procedure "pl1_symbol_print" symbol_length 7(18) based bit(18) level 2 packed packed unaligned dcl 11-10 ref 243 243 symbol_list 000174 automatic pointer array dcl 113 set ref 164 164 179 181 181 183 186 186 385* 394 394 400 609 613* 666 670* 795 811 811 826 symbol_offset 7 based bit(18) level 2 packed packed unaligned dcl 11-10 ref 237 237 tab parameter fixed bin(17,0) dcl 1372 ref 1369 1377 1377 1383 tabs parameter fixed bin(17,0) array dcl 1355 in procedure "column_print" set ref 1352 1361* 1362* 1363* tabs 000000 constant fixed bin(17,0) initial array dcl 1322 in procedure "print_auto_table" set ref 1335* 1348* tabs 000004 constant fixed bin(17,0) initial array dcl 1294 in procedure "print_int_static_table" set ref 1304* 1310* temp 027554 automatic pointer dcl 1169 in begin block on line 1168 set ref 1185* 1188 temp 027341 automatic varying char(296) dcl 710 in procedure "print" set ref 838* 843* 843 844* 844 848* 848 849* 849 850* 1050* 1051* 1051 1052* 1052 1053* 1053 1054 1075* 1076* 1084* 1085* 1085 1087* 1087 1088* 1121* 1122* 1132* 1133* 1133 1134* 1139* 1140* 1140 1141* 1141 1142* 1206* 1207* 1207 1209* text_length 3(18) based bit(18) level 2 packed packed unaligned dcl 11-10 ref 243 243 token 5 based pointer level 2 in structure "symbol" packed packed unaligned dcl 7-3 in procedure "pl1_symbol_print" ref 400 575 811 811 829 1085 1472 token based structure level 1 dcl 10-3 in procedure "pl1_symbol_print" token_node constant bit(9) initial dcl 1-5 ref 577 type based bit(9) level 2 in structure "node" packed packed unaligned dcl 1-27 in procedure "pl1_symbol_print" ref 831 1001 type 031326 automatic fixed bin(17,0) dcl 1466 in procedure "format_items" set ref 1473* type 12 025035 automatic char(19) level 2 in structure "bline" packed packed unaligned dcl 441 in procedure "prt_block" set ref 469* type parameter fixed bin(17,0) dcl 547 in procedure "block_name" set ref 544 555* units 0(14) based fixed bin(3,0) level 2 packed packed unaligned dcl 8-3 ref 1007 unsigned 31(24) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 1101 unused 000112 automatic fixed bin(17,0) dcl 75 set ref 160* 175* 195 213 215 615* 615 672* 672 unused_members 000113 automatic fixed bin(17,0) dcl 75 set ref 160* 175* 195 618* 618 675* 675 v1 parameter varying char(256) dcl 1356 ref 1352 1360 v2 parameter varying char(256) dcl 1356 set ref 1352 1361* v3 parameter varying char(256) dcl 1356 set ref 1352 1362* v4 parameter varying char(256) dcl 1356 set ref 1352 1363 1363* variable 31(32) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 872 950 varying 31(26) based bit(1) level 4 packed packed unaligned dcl 7-3 ref 922 verify builtin function dcl 770 ref 1015 why_nonquick 42 based structure level 2 dcl 5-5 ref 501 509 wo 027136 automatic fixed bin(18,0) dcl 707 set ref 1008* 1011 1013 1013 1023 word_offset 5(09) 027474 automatic char(6) level 2 packed packed unaligned dcl 754 set ref 1018* 1023* 1263 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. array_node internal static bit(9) initial dcl 1-5 bits_per_char internal static fixed bin(8,0) initial dcl 12-5 bits_per_four_words internal static fixed bin(8,0) initial dcl 12-5 bits_per_half internal static fixed bin(8,0) initial dcl 12-5 bits_per_packed_digit internal static fixed bin(8,1) initial dcl 12-35 bits_per_two_words internal static fixed bin(8,0) initial dcl 12-5 bits_per_words internal static fixed bin(8,0) initial array dcl 12-5 block_node internal static bit(9) initial dcl 1-5 bound_node internal static bit(9) initial dcl 1-5 break_even_bits internal static fixed bin(8,0) initial dcl 12-5 break_even_words internal static fixed bin(8,0) initial dcl 12-5 by_name_agg_node internal static bit(9) initial dcl 1-5 chars_per_word internal static fixed bin(8,0) initial dcl 12-5 context_node internal static bit(9) initial dcl 1-5 convert_size internal static fixed bin(8,0) initial array dcl 12-5 cross_reference_node internal static bit(9) initial dcl 1-5 default_fix_bin_p internal static fixed bin(8,0) initial dcl 12-5 default_node internal static bit(9) initial dcl 1-5 format_value_node internal static bit(9) initial dcl 1-5 internal_procedure internal static bit(9) initial dcl 6-1 label_array_element_node internal static bit(9) initial dcl 1-5 label_size internal static fixed bin(8,0) initial dcl 12-5 list_node internal static bit(9) initial dcl 1-5 machine_state_node internal static bit(9) initial dcl 1-5 map_ptr based bit(18) dcl 11-38 max_block_number internal static fixed bin(17,0) initial dcl 5-74 max_dec_scale internal static fixed bin(8,0) initial dcl 12-5 max_index_register_value internal static fixed bin(31,0) initial dcl 12-38 max_length_p internal static fixed bin(8,0) initial dcl 12-5 max_list_elements internal static fixed bin(17,0) initial dcl 4-12 max_offset internal static fixed bin(8,0) initial array dcl 12-5 max_p_fix_bin_1 internal static fixed bin(8,0) initial dcl 12-5 max_p_fix_dec internal static fixed bin(8,0) initial dcl 12-5 max_p_flt_bin_1 internal static fixed bin(8,0) initial dcl 12-5 max_p_xreg internal static fixed bin(8,0) initial dcl 12-5 max_short_size internal static fixed bin(8,0) initial array dcl 12-5 min_dec_scale internal static fixed bin(8,0) initial dcl 12-5 object_map_version_2 internal static fixed bin(17,0) initial dcl 11-40 operator_node internal static bit(9) initial dcl 1-5 packed_digits_per_char internal static fixed bin(8,0) initial dcl 12-5 packed_digits_per_word internal static fixed bin(8,0) initial dcl 12-5 root_block internal static bit(9) initial dcl 6-1 sf_par_node internal static bit(9) initial dcl 1-5 source_node internal static bit(9) initial dcl 1-5 statement_node internal static bit(9) initial dcl 1-5 symbol_node internal static bit(9) initial dcl 1-5 temporary_node internal static bit(9) initial dcl 1-5 units_per_word internal static fixed bin(8,0) initial array dcl 12-5 NAMES DECLARED BY EXPLICIT CONTEXT. arith 005225 constant label dcl 904 ref 897 attrib 006760 constant entry internal dcl 1238 ref 850 883 1060 1065 1070 1076 1083 1088 1093 1098 1103 1108 1113 1122 1134 1137 1142 1199 1201 1202 1209 block_name 004055 constant entry internal dcl 544 ref 464 480 1128 1342 1436 1438 1473 chk_ext 003146 constant label dcl 337 ref 277 column_print 007433 constant entry internal dcl 1352 ref 1304 1310 1335 1348 cv 005306 constant label dcl 950 ref 937 943 done 006266 constant label dcl 1117 in procedure "print_k" ref 858 864 1001 done 003166 constant label dcl 343 in procedure "pl1_symbol_print" file_line 006644 constant entry internal dcl 1221 ref 1120 1205 format_items 010006 constant entry internal dcl 1459 ref 1308 1343 full 002077 constant label dcl 181 ref 609 666 have_type 005342 constant label dcl 965 ref 875 909 925 931 953 init_attrib 007152 constant entry internal dcl 1275 ref 827 1271 look 002762 constant label dcl 289 ref 331 number_name 004125 constant label dcl 563 ref 581 output_line 007045 constant entry internal dcl 1256 ref 1213 1242 pl1_symbol_print 001615 constant entry external dcl 67 place 003055 constant label dcl 312 set ref 299 306 print 004601 constant entry internal dcl 690 ref 167 210 222 print_auto_table 007267 constant entry internal dcl 1314 ref 275 print_int_static_table 007162 constant entry internal dcl 1284 ref 273 print_item 007526 constant entry internal dcl 1369 ref 1361 1362 1363 print_k 004724 constant entry internal dcl 824 ref 814 820 print_list 003201 constant entry internal dcl 348 ref 339 342 prt_block 003464 constant entry internal dcl 431 ref 258 select_all_symbols 004317 constant entry internal dcl 589 ref 161 625 set_loc 005442 constant label dcl 995 ref 852 884 891 sort_on_dcl_type 004443 constant entry internal dcl 639 ref 177 682 sort_storage_list 007624 constant entry internal dcl 1390 ref 1305 1336 step 004546 constant label dcl 677 in procedure "sort_on_dcl_type" ref 662 step 003126 constant label dcl 329 in procedure "pl1_symbol_print" ref 310 step 004413 constant label dcl 620 in procedure "select_all_symbols" ref 605 str 005252 constant label dcl 922 ref 915 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 10626 10672 10411 10636 Length 11362 10411 44 454 214 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME pl1_symbol_print 13938 external procedure is an external procedure. print_list internal procedure shares stack frame of external procedure pl1_symbol_print. prt_block internal procedure shares stack frame of external procedure pl1_symbol_print. block_name internal procedure shares stack frame of external procedure pl1_symbol_print. select_all_symbols 76 internal procedure calls itself recursively. sort_on_dcl_type 82 internal procedure calls itself recursively. print internal procedure shares stack frame of external procedure pl1_symbol_print. begin block on line 792 begin block shares stack frame of external procedure pl1_symbol_print. print_k internal procedure shares stack frame of external procedure pl1_symbol_print. begin block on line 1168 begin block shares stack frame of external procedure pl1_symbol_print. file_line internal procedure shares stack frame of external procedure pl1_symbol_print. attrib internal procedure shares stack frame of external procedure pl1_symbol_print. output_line internal procedure shares stack frame of external procedure pl1_symbol_print. init_attrib internal procedure shares stack frame of external procedure pl1_symbol_print. print_int_static_table internal procedure shares stack frame of external procedure pl1_symbol_print. print_auto_table internal procedure shares stack frame of external procedure pl1_symbol_print. column_print internal procedure shares stack frame of external procedure pl1_symbol_print. print_item internal procedure shares stack frame of external procedure pl1_symbol_print. sort_storage_list internal procedure shares stack frame of external procedure pl1_symbol_print. format_items internal procedure shares stack frame of external procedure pl1_symbol_print. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME pl1_symbol_print 000100 digits_pic pl1_symbol_print 000102 i pl1_symbol_print 000103 j pl1_symbol_print 000104 k pl1_symbol_print 000105 m pl1_symbol_print 000106 n pl1_symbol_print 000107 size pl1_symbol_print 000110 int_static_list_length pl1_symbol_print 000111 auto_list_length pl1_symbol_print 000112 unused pl1_symbol_print 000113 unused_members pl1_symbol_print 000114 p pl1_symbol_print 000116 q pl1_symbol_print 000120 line pl1_symbol_print 000161 dt1 pl1_symbol_print 000165 dt2 pl1_symbol_print 000172 s pl1_symbol_print 000174 symbol_list pl1_symbol_print 020174 int_static_list_st pl1_symbol_print 022174 auto_list_st pl1_symbol_print 024174 op_names_pt pl1_symbol_print 024210 hder_no_ext print_list 024411 hder_has_ext print_list 024612 sym2 print_list 024624 bp prt_block 024626 fp prt_block 024630 bt1 prt_block 024631 bt2 prt_block 024632 info_len prt_block 024633 name1 prt_block 024734 name2 prt_block 025035 bline prt_block 025104 blk block_name 025106 name_ptr block_name 025116 sym_pt print 025120 p print 025122 ref_list print 027122 k print 027123 ctype print 027124 dtype print 027125 ext print 027126 cur_attrib_col print 027127 nn print 027130 bo print 027131 i print 027132 name_width print 027133 ignore print 027134 next_k print 027135 ref_list_length print 027136 wo print 027137 id print 027240 name print 027341 temp print 027454 number print 027460 c6 print 027462 ref_too_many print 027463 prev_dupl print 027464 next_dupl print 027465 id_printed print 027466 something_to_print print 027467 ignore_symbol print 027470 six_digits print 027472 line_pt print 027474 sl print 027542 sym_pt begin block on line 792 027544 referenced begin block on line 792 027554 temp begin block on line 1168 027556 compare begin block on line 1168 027557 i begin block on line 1168 027560 j1 begin block on line 1168 027561 j2 begin block on line 1168 027622 i print_int_static_table 027623 loc_item print_int_static_table 027724 name_item print_int_static_table 030025 procedure_item print_int_static_table 030136 i print_auto_table 030137 ignored_type print_auto_table 030140 p print_auto_table 030142 stack_frame_item print_auto_table 030243 loc_item print_auto_table 030344 name_item print_auto_table 030445 procedure_item print_auto_table 030546 previous_stack_frame_item print_auto_table 030656 line column_print 031074 d sort_storage_list 031075 i sort_storage_list 031076 j sort_storage_list 031077 k sort_storage_list 031100 ignored_type sort_storage_list 031102 p1 sort_storage_list 031104 p2 sort_storage_list 031106 p1_owner sort_storage_list 031110 p2_owner sort_storage_list 031112 compare sort_storage_list 031113 interchange sort_storage_list 031114 p1_owner_name sort_storage_list 031215 p2_owner_name sort_storage_list 031326 type format_items select_all_symbols 000100 dt select_all_symbols 000102 block_pt select_all_symbols 000104 sym_pt select_all_symbols sort_on_dcl_type 000100 dt sort_on_dcl_type 000101 dt1 sort_on_dcl_type 000102 dt2 sort_on_dcl_type 000104 block_pt sort_on_dcl_type 000106 sym_pt sort_on_dcl_type THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_s r_g_a r_e_as r_ne_as alloc_char_temp realloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_1 mdfx1 shorten_stack ext_entry int_entry trunc_fx1 index_bs_1_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. binoct cg_error ioa_$rsnpnnl pl1_print$non_varying_nl pl1_print$varying_nl sym_sort_alphabetic THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cg_static_$bit_count cg_static_$ext_proc_list cg_static_$ext_var_list cg_static_$objmap_pt cg_static_$root cg_static_$used_operator pl1_operator_names_$pl1_operator_names_ pl1_stat_$single_symbol_list LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 67 001611 75 001622 144 001664 148 001710 150 001727 153 001745 154 001746 158 001747 160 001752 161 001755 162 001764 164 001767 165 002002 167 002014 168 002017 169 002020 170 002036 171 002037 175 002052 177 002055 179 002074 181 002077 183 002114 186 002116 189 002133 191 002136 192 002140 193 002141 195 002142 196 002150 199 002152 202 002211 203 002212 205 002216 207 002222 210 002300 213 002303 215 002310 217 002314 219 002320 222 002361 225 002366 229 002370 232 002374 235 002412 237 002416 241 002473 243 002510 248 002602 250 002617 252 002631 255 002647 257 002654 258 002660 260 002662 262 002671 265 002677 266 002701 267 002713 268 002715 269 002716 271 002720 273 002721 275 002723 277 002725 281 002733 284 002750 285 002753 286 002756 287 002757 289 002762 292 003000 295 003001 296 003004 298 003011 299 003014 302 003015 303 003025 305 003044 306 003051 308 003052 310 003054 312 003055 314 003060 316 003065 318 003072 319 003076 321 003100 323 003103 324 003120 325 003123 326 003125 329 003126 331 003127 334 003130 337 003146 339 003152 341 003156 342 003162 343 003166 346 003200 348 003201 361 003203 363 003206 365 003213 367 003220 369 003221 371 003226 375 003233 377 003237 379 003240 380 003244 382 003247 384 003255 385 003256 387 003261 388 003264 390 003265 393 003267 394 003300 395 003313 396 003316 397 003320 399 003321 400 003331 401 003335 403 003337 405 003342 406 003357 407 003362 408 003364 411 003365 412 003374 413 003400 416 003404 417 003410 419 003414 420 003416 422 003420 424 003437 425 003440 426 003451 427 003452 429 003463 431 003464 461 003466 462 003471 464 003474 465 003476 467 003513 469 003517 471 003526 473 003532 474 003533 475 003540 477 003547 478 003551 480 003552 481 003554 482 003561 484 003577 485 003615 487 003624 488 003636 489 003642 490 003644 492 003645 493 003654 495 003655 497 003664 498 003667 499 003671 500 003672 501 003677 503 003704 506 003711 507 003715 508 003717 509 003720 511 003730 512 003734 513 003736 515 003737 516 003743 519 003745 520 003752 522 003756 524 004001 525 004004 528 004005 529 004015 531 004017 534 004021 536 004025 537 004030 540 004031 542 004054 544 004055 554 004057 555 004062 557 004067 559 004074 561 004105 562 004113 563 004125 566 004132 567 004143 568 004172 570 004201 571 004214 572 004243 574 004244 575 004250 577 004270 580 004306 581 004314 585 004315 589 004316 597 004324 598 004330 600 004334 601 004337 603 004344 605 004351 609 004360 612 004367 613 004371 615 004375 618 004412 620 004413 622 004416 624 004417 625 004422 628 004435 629 004440 631 004441 639 004442 651 004450 652 004454 654 004457 655 004462 657 004466 658 004471 660 004476 662 004503 666 004513 669 004522 670 004524 672 004530 675 004545 677 004546 679 004551 681 004552 682 004555 685 004574 686 004577 688 004600 690 004601 780 004603 781 004605 784 004607 785 004610 786 004611 795 004621 796 004625 797 004626 799 004637 801 004650 806 004667 808 004671 810 004673 811 004675 814 004714 816 004715 818 004717 819 004721 820 004722 821 004723 824 004724 826 004725 827 004731 828 004732 829 004734 830 004746 831 004747 833 004753 834 004755 836 004761 838 004765 840 004771 842 004776 843 005006 844 005033 847 005042 848 005056 849 005103 850 005112 852 005114 855 005115 857 005121 858 005124 861 005125 863 005130 864 005133 867 005134 869 005142 872 005145 874 005150 875 005152 878 005153 879 005155 881 005165 883 005167 884 005201 887 005202 889 005205 890 005207 891 005211 894 005212 896 005215 897 005217 900 005220 902 005223 904 005225 907 005231 909 005236 912 005237 914 005242 915 005244 918 005245 920 005250 922 005252 925 005256 928 005257 930 005262 931 005264 934 005265 936 005270 937 005272 940 005273 942 005276 943 005300 946 005301 948 005304 950 005306 953 005312 956 005313 958 005321 960 005327 962 005335 965 005342 968 005353 973 005363 975 005370 977 005373 980 005412 981 005413 983 005415 984 005416 986 005420 989 005437 990 005440 995 005442 999 005466 1001 005474 1004 005500 1005 005503 1007 005506 1008 005517 1009 005521 1011 005525 1013 005527 1015 005550 1018 005563 1021 005567 1023 005571 1026 005575 1028 005577 1030 005605 1031 005610 1033 005613 1038 005615 1040 005620 1041 005627 1043 005650 1045 005656 1046 005665 1047 005700 1050 005725 1051 005736 1052 005745 1053 005757 1054 005766 1055 005772 1056 005773 1058 006002 1060 006005 1063 006014 1065 006020 1068 006027 1070 006033 1073 006042 1075 006051 1076 006063 1079 006065 1081 006077 1082 006106 1083 006111 1084 006120 1085 006124 1087 006140 1088 006147 1091 006151 1093 006160 1098 006167 1101 006205 1103 006211 1106 006220 1108 006224 1111 006233 1113 006245 1115 006264 1117 006266 1120 006271 1121 006273 1122 006314 1125 006317 1126 006322 1128 006331 1130 006333 1132 006351 1133 006355 1134 006367 1135 006371 1137 006372 1139 006401 1140 006405 1141 006417 1142 006426 1148 006430 1149 006433 1150 006434 1153 006435 1154 006442 1157 006450 1158 006451 1160 006454 1161 006457 1175 006460 1176 006467 1177 006471 1179 006477 1180 006501 1182 006515 1185 006530 1187 006532 1188 006535 1189 006536 1190 006537 1192 006540 1193 006543 1197 006545 1199 006547 1201 006561 1202 006567 1204 006600 1205 006605 1206 006611 1207 006616 1209 006633 1210 006635 1213 006640 1216 006643 1221 006644 1225 006646 1228 006656 1229 006667 1230 006710 1233 006717 1234 006732 1236 006757 1238 006760 1242 006762 1244 006770 1247 007027 1248 007030 1250 007036 1252 007042 1254 007044 1256 007045 1258 007046 1260 007050 1261 007052 1263 007064 1265 007100 1267 007110 1268 007121 1270 007123 1271 007145 1272 007147 1273 007151 1275 007152 1277 007153 1278 007154 1279 007156 1280 007161 1284 007162 1299 007164 1301 007167 1304 007205 1305 007226 1307 007242 1308 007253 1310 007261 1311 007264 1312 007266 1314 007267 1329 007271 1331 007274 1332 007275 1335 007313 1336 007340 1338 007355 1339 007365 1340 007372 1342 007400 1343 007402 1345 007411 1347 007421 1348 007426 1349 007430 1350 007432 1352 007433 1360 007435 1361 007443 1362 007455 1363 007467 1365 007507 1367 007525 1369 007526 1377 007530 1381 007556 1382 007557 1383 007570 1384 007606 1385 007607 1386 007623 1390 007624 1411 007626 1412 007630 1413 007633 1414 007637 1415 007651 1416 007653 1417 007657 1418 007661 1419 007664 1420 007665 1421 007670 1422 007674 1425 007710 1427 007712 1429 007720 1430 007723 1432 007731 1436 007747 1438 007751 1439 007753 1442 007762 1444 007763 1446 007771 1447 007773 1449 007776 1450 007777 1453 010001 1454 010002 1455 010004 1457 010005 1459 010006 1471 010010 1472 010042 1473 010056 1475 010072 ----------------------------------------------------------- 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