COMPILATION LISTING OF SEGMENT context_processor Compiled by: Multics PL/I Compiler, Release 32c, of June 16, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 07/31/89 1400.9 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* Modified 780814 by PG to fix 1771 (incorrectly diagnosing refer-with-like error. 12* Modified: 30 August 1979 by PCK to remove refer-with-like diagnostic 13* Modified: 30 August 1979 by PCK to fix 1804 and 1823 14* Modified: 22 September 1980 by M. N. Davidoff to set symbol.structure after like attribute is expanded. Fixes 2013. 15* Modified: 16 February 1981 by M. N. Davidoff to allow likes to likes and to implement 1952 16* (diagnose dcl 1 a, 2 b like a). 17* Modified: 23 February 1981 by M. N. Davidoff to resolve like references before any like attributes are expanded. 18* Fixes 2057. 19* Modified: 10 June 1981 by PCK to fix bug 2074--faulting on declarations 20* with factored like attributes and qualifed references as like targets 21**/ 22 /* format: style3,ifthenstmt */ 23 context_processor: 24 procedure (P_root, P_abort); 25 26 dcl P_root ptr; /* (Input) */ 27 dcl P_abort label variable; /* (Output) */ 28 29 /* automatic */ 30 31 dcl b ptr; 32 dcl root ptr; 33 dcl s ptr; 34 35 /* builtin */ 36 37 dcl null builtin; 38 39 /* external static */ 40 41 dcl pl1_stat_$check_ansi 42 bit (1) aligned external static; 43 dcl pl1_stat_$cur_statement 44 ptr external static; 45 dcl 1 pl1_stat_$statement_id 46 external static, 47 2 file_number bit (8), 48 2 line_number bit (14), 49 2 statement_number 50 bit (5); 51 1 1 /* BEGIN INCLUDE FILE ... semant.incl.pl1 */ 1 2 1 3 /* Modified: 30 Aug 1979 by PCK to fix 1804 and 1823 */ 1 4 /* Modified: 26 Aug 1979 by PCK to implement by name assignment */ 1 5 1 6 1 7 declare alloc_semantics entry(pointer,pointer,pointer); 1 8 /* parameter 1: (input) block node pointer */ 1 9 /* parameter 2: (input) statement node pointer */ 1 10 /* parameter 3: (in/out) tree pointer */ 1 11 1 12 declare alloc_semantics$init_only entry(pointer,pointer,pointer); 1 13 /* parameter 1: (input) qualifier pointer */ 1 14 /* parameter 2: (input) statement node pointer */ 1 15 /* parameter 3: (input) symbol node pointer */ 1 16 1 17 declare builtin entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned) 1 18 returns(pointer); 1 19 /* parameter 1: (input) block node pointer */ 1 20 /* parameter 2: (input) statement node pointer */ 1 21 /* parameter 3: (input) tree pointer */ 1 22 /* parameter 4: (input) subscript pointer */ 1 23 /* parameter 5: (input) builtin symbol node pointer */ 1 24 /* parameter 6: (in/out) context */ 1 25 /* return: (output) tree pointer */ 1 26 1 27 declare check_star_extents entry(pointer,pointer); 1 28 /* parameter 1: (input) symbol node of procedure */ 1 29 /* parameter 2: (input) argument list pointer */ 1 30 1 31 declare compare_declaration entry(pointer,pointer,bit(1) aligned) reducible 1 32 returns(bit(1) aligned); 1 33 /* parameter 1: (input) reference or symbol node ptr */ 1 34 /* parameter 2: (input) symbol node ptr */ 1 35 /* parameter 3: (input) "1"b if aligned attribute ignored for string */ 1 36 /* return: (output) compare bit */ 1 37 1 38 declare context_processor entry(pointer,label); 1 39 /* parameter 1: (input) root block node pointer */ 1 40 1 41 declare declare entry(pointer); 1 42 /* parameter 1: (input) symbol node pointer */ 1 43 1 44 declare declare_structure entry(pointer); 1 45 /* parameter 1: (input) symbol node pointer */ 1 46 1 47 declare defined_reference entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned) 1 48 returns(pointer); 1 49 /* parameter 1: (input) block node pointer */ 1 50 /* parameter 2: (input) statement node pointer */ 1 51 /* parameter 3: (input) tree pointer */ 1 52 /* parameter 4: (input) subscript list pointer or null*/ 1 53 /* parameter 5: (input) symbol node pointer */ 1 54 /* parameter 6: (in/out) context */ 1 55 /* return: (output) tree pointer */ 1 56 1 57 declare do_semantics entry(pointer,pointer,pointer); 1 58 /* parameter 1: (input) block node pointer */ 1 59 /* parameter 2: (input) statement node pointer */ 1 60 /* parameter 3: (input) tree pointer */ 1 61 1 62 declare expand_assign entry(pointer,pointer,pointer,bit(36) aligned,pointer) 1 63 returns(pointer); 1 64 /* parameter 1: (input) block node pointer */ 1 65 /* parameter 2: (input) statement node pointer */ 1 66 /* parameter 3: (input) tree pointer */ 1 67 /* parameter 4: (in/out) context */ 1 68 /* parameter 5: (input) aggregate reference node ptr */ 1 69 /* return: (output) tree pointer */ 1 70 1 71 declare expand_by_name entry(pointer,pointer,pointer); 1 72 /* parameter 1: (input) block node pointer */ 1 73 /* parameter 2: (input) statement node pointer */ 1 74 /* parameter 3: (input/output) tree pointer */ 1 75 1 76 declare expand_infix entry(pointer,pointer,pointer,bit(36) aligned) 1 77 returns(pointer); 1 78 /* parameter 1: (input) block node pointer */ 1 79 /* parameter 2: (input) statement node pointer */ 1 80 /* parameter 3: (input) tree pointer */ 1 81 /* parameter 4: (in/out) context */ 1 82 /* return: (output) tree pointer */ 1 83 1 84 declare expand_initial entry(pointer,pointer,pointer); 1 85 /* parameter 1: (input) symbol node pointer */ 1 86 /* parameter 2: (input) statement node pointer */ 1 87 /* parameter 3: (input) locator */ 1 88 1 89 declare expand_prefix entry(pointer,pointer,pointer,bit(36) aligned) 1 90 returns(pointer); 1 91 /* parameter 1: (input) block node pointer */ 1 92 /* parameter 2: (input) statement node pointer */ 1 93 /* parameter 3: (input) tree pointer */ 1 94 /* parameter 4: (in/out) context */ 1 95 /* return: (output) tree pointer */ 1 96 1 97 declare expand_primitive entry(pointer,pointer,pointer,bit(36) aligned) 1 98 returns(pointer); 1 99 /* parameter 1: (input) block node pointer */ 1 100 /* parameter 2: (input) statement node pointer */ 1 101 /* parameter 3: (input) tree pointer */ 1 102 /* parameter 4: (input) context */ 1 103 /* return: (output) tree pointer */ 1 104 1 105 declare expression_semantics entry(pointer,pointer,pointer,bit(36) aligned) 1 106 returns(pointer); 1 107 /* parameter 1: (input) block node pointer */ 1 108 /* parameter 2: (input) statement node pointer */ 1 109 /* parameter 3: (input) tree pointer */ 1 110 /* parameter 4: (in/out) context */ 1 111 /* return: (output) tree pointer */ 1 112 1 113 declare fill_refer entry(pointer,pointer,bit(1) aligned) 1 114 returns(pointer); 1 115 /* parameter 1: (input) null,ref node,op node ptr */ 1 116 /* parameter 2: (input) null,ref node,op node ptr */ 1 117 /* parameter 3: (input) copy switch for param 2 */ 1 118 /* return: (output) ptr to processed tree */ 1 119 1 120 declare io_data_list_semantics$format_list_semantics entry(pointer,pointer,pointer); 1 121 /* parameter 1: (input) block node pointer */ 1 122 /* parameter 2: (input) statement node pointer */ 1 123 /* parameter 3: (in/out) tree pointer */ 1 124 1 125 declare function entry(pointer,pointer,pointer,pointer,bit(36) aligned) 1 126 returns(pointer); 1 127 /* parameter 1: (input) block node pointer */ 1 128 /* parameter 2: (input) statement node pointer */ 1 129 /* parameter 3: (input) tree pointer */ 1 130 /* parameter 4: (input) symbol node pointer */ 1 131 /* parameter 5: (in/out) context */ 1 132 /* return: (output) tree pointer */ 1 133 1 134 declare generic_selector entry(pointer,pointer,pointer,pointer,bit(36) aligned) 1 135 returns(pointer); 1 136 /* parameter 1: (input) block node pointer */ 1 137 /* parameter 2: (input) statement node pointer */ 1 138 /* parameter 3: (input) tree pointer */ 1 139 /* parameter 4: (input) pointer to argument list */ 1 140 /* parameter 5: (in/out) context */ 1 141 /* return: (output) tree pointer */ 1 142 1 143 declare io_data_list_semantics entry(pointer,pointer,pointer); 1 144 /* parameter 1: (input) block node pointer */ 1 145 /* parameter 2: (input) statement node pointer */ 1 146 /* parameter 3: (input) operator node pointer */ 1 147 1 148 declare io_semantics entry(pointer,pointer,pointer); 1 149 /* parameter 1: (input) block node pointer */ 1 150 /* parameter 2: (input) statement node pointer */ 1 151 /* parameter 3: (input) tree pointer */ 1 152 1 153 declare lookup entry(pointer,pointer,pointer,pointer,bit(36) aligned) 1 154 returns(bit(1) aligned); 1 155 /* parameter 1: (input) block node pointer */ 1 156 /* parameter 2: (input) stmnt|symbol node pointer */ 1 157 /* parameter 3: (input) token or reference node ptr */ 1 158 /* parameter 4: (output) symbol node pointer */ 1 159 /* parameter 5: (in/out) context */ 1 160 /* return: (output) symbol found bit */ 1 161 1 162 declare make_non_quick entry(pointer, bit (36) aligned); 1 163 /* parameter 1: (input) tree pointer */ 1 164 /* parameter 2: (input) reason why being made nonquick */ 1 165 1 166 declare match_arguments entry(pointer,pointer) reducible 1 167 returns(bit(1) aligned); 1 168 /* parameter 1: (input) reference or symbol node ptr */ 1 169 /* parameter 2: (input) reference or symbol node ptr */ 1 170 /* return: (output) compare bit */ 1 171 1 172 declare offset_adder entry(pointer,fixed binary(31),fixed binary(3),bit(1) aligned, 1 173 pointer,fixed binary(31),fixed binary(3),bit(1) aligned,bit(1)); 1 174 /* parameter 1: (in/out) tree pointer */ 1 175 /* parameter 2: (in/out) constant size */ 1 176 /* parameter 3: (in/out) units */ 1 177 /* parameter 4: (in/out) ON if units ^= word_, but tree in words */ 1 178 /* parameter 5: (input) tree pointer */ 1 179 /* parameter 6: (input) constant size */ 1 180 /* parameter 7: (input) units */ 1 181 /* parameter 8: (input) ON if units ^= word_, but tree in words */ 1 182 /* parameter 9: (input) ON if should not improve units */ 1 183 1 184 declare operator_semantics entry(pointer,pointer,pointer,bit(36) aligned) 1 185 returns(pointer); 1 186 /* parameter 1: (input) block node pointer */ 1 187 /* parameter 2: (input) statement node pointer */ 1 188 /* parameter 3: (input) tree pointer */ 1 189 /* parameter 4: (in/out) context */ 1 190 /* return: (output) tree pointer */ 1 191 1 192 declare propagate_bit entry(pointer,fixed binary(15)); 1 193 /* parameter 1: (input) symbol node pointer */ 1 194 /* parameter 2: (input) attribute number */ 1 195 1 196 declare semantic_translator$call_es entry(pointer,pointer,pointer,label,bit(1) aligned) 1 197 returns(pointer); 1 198 /* parameter 1: (input) block ptr */ 1 199 /* parameter 2: (input) statement ptr */ 1 200 /* parameter 3: (input) tree ptr */ 1 201 /* parameter 4: (input) failure label */ 1 202 /* parameter 5: (input) "1"b -- convert to integer */ 1 203 /* return: (output) tree ptr */ 1 204 1 205 declare simplify_expression entry(pointer,fixed bin,bit(1)aligned); 1 206 /* parameter 1: (in/out) tree pointer */ 1 207 /* parameter 2: (output) value of constant, if the entire tree 1 208* is simplified */ 1 209 /* parameter 3: (output) bit indicating if the tree has 1 210* been simplified */ 1 211 1 212 declare simplify_offset entry(pointer,bit(36) aligned); 1 213 /* parameter 1: (input) reference node pointer */ 1 214 /* parameter 2: (input) context */ 1 215 1 216 declare subscripter entry(pointer,pointer,pointer,pointer,pointer) 1 217 returns(pointer); 1 218 /* parameter 1: (input) block node pointer */ 1 219 /* parameter 2: (input) statement node pointer */ 1 220 /* parameter 3: (input) tree pointer */ 1 221 /* parameter 4: (in/out) subscript list pointer */ 1 222 /* parameter 5: (input) symbol node pointer */ 1 223 /* return: (output) reference node pointer */ 1 224 1 225 declare validate entry(pointer); 1 226 /* parameter 1: (input) symbol node pointer */ 1 227 2 1 /****^ ********************************************************* 2 2* * * 2 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 2 4* * * 2 5* ********************************************************* */ 2 6 2 7 /* BEGIN INCLUDE FILE ... language_utility.incl.pl1 */ 2 8 2 9 2 10 /****^ HISTORY COMMENTS: 2 11* 1) change(89-07-10,RWaters), approve(89-07-10,MCR8118), audit(89-07-19,Vu), 2 12* install(89-07-31,MR12.3-1066): 2 13* Removed the obsolete parameter source_line from the dcl of error_(). 2 14* END HISTORY COMMENTS */ 2 15 2 16 /* Modified: 6 Jun 1979 by PG to add rank and byte 2 17* * Modified: 9 Jul 1989 by RW updated the declaration of error_ 2 18* */ 2 19 2 20 declare adjust_count entry(pointer); 2 21 /* parameter 1: (input) any node pointer */ 2 22 2 23 declare bindec entry(fixed bin(31)) reducible 2 24 returns(character(12) aligned); 2 25 /* parameter 1: (input) bin value */ 2 26 /* return: (output) character value with blanks */ 2 27 2 28 declare bindec$vs entry(fixed bin(31)) reducible 2 29 returns(character(12) aligned varying); 2 30 /* parameter 1: (input) binary value */ 2 31 /* return: (output) char value without blanks */ 2 32 2 33 declare binoct entry(fixed bin(31)) reducible 2 34 returns(char(12) aligned); 2 35 /* parameter 1: (input) binary value */ 2 36 /* return: (output) char value with blanks */ 2 37 2 38 declare binary_to_octal_string entry(fixed bin(31)) reducible 2 39 returns(char(12) aligned); 2 40 /* parameter 1: (input) binary value */ 2 41 /* return: (output) right-aligned char value */ 2 42 2 43 declare binary_to_octal_var_string entry(fixed bin(31)) reducible 2 44 returns(char(12) varying aligned); 2 45 /* parameter 1: (input) binary value */ 2 46 /* returns: (output) char value without blanks */ 2 47 2 48 declare compare_expression entry(pointer,pointer) reducible 2 49 returns(bit(1) aligned); 2 50 /* parameter 1: (input) any node pointer */ 2 51 /* parameter 2: (input) any node pointer */ 2 52 /* return: (output) compare bit */ 2 53 2 54 declare constant_length entry (pointer, fixed bin (71)) 2 55 returns (bit (1) aligned); 2 56 /* parameter 1: (input) reference node pointer */ 2 57 /* parameter 2: (input) value of constant length */ 2 58 /* return: (output) "1"b if constant length */ 2 59 2 60 declare convert entry(pointer,bit(36) aligned) 2 61 returns(pointer); 2 62 /* parameter 1: (input) any node pointer */ 2 63 /* parameter 2: (input) target type */ 2 64 /* return: (output) target value tree pointer */ 2 65 2 66 declare convert$to_integer entry(pointer,bit(36)aligned) 2 67 returns(pointer); 2 68 /* parameter 1: (input) any node pointer */ 2 69 /* parameter 2: (input) target type */ 2 70 /* return: (output) target value tree pointer */ 2 71 2 72 declare convert$from_builtin entry(pointer,bit(36) aligned) 2 73 returns(pointer); 2 74 /* parameter 1: (input) any node pointer */ 2 75 /* parameter 2: (input) target type */ 2 76 /* return: (output) target value tree pointer */ 2 77 2 78 declare convert$validate entry(pointer,pointer); 2 79 /* parameter 1: (input) source value tree pointer */ 2 80 /* parameter 2: (input) target reference node pointer */ 2 81 2 82 declare convert$to_target_fb entry(pointer,pointer) 2 83 returns(pointer); 2 84 /* parameter 1: (input) source value tree pointer */ 2 85 /* parameter 2: (input) target reference node pointer */ 2 86 /* return: (output) target value tree pointer */ 2 87 2 88 declare convert$to_target entry(pointer,pointer) 2 89 returns(pointer); 2 90 /* parameter 1: (input) source value tree pointer */ 2 91 /* parameter 2: (input) target reference node pointer */ 2 92 /* return: (output) target value tree pointer */ 2 93 2 94 declare copy_expression entry(pointer unaligned) 2 95 returns(pointer); 2 96 /* parameter 1: (input) any node pointer */ 2 97 /* return: (output) any node pointer */ 2 98 2 99 declare copy_expression$copy_sons entry(pointer,pointer); 2 100 /* parameter 1: (input) father symbol node pointer */ 2 101 /* parameter 2: (input) stepfather symbol node ptr */ 2 102 2 103 declare copy_unique_expression entry(pointer) 2 104 returns(pointer); 2 105 /* parameter 1: (input) any node pointer */ 2 106 /* return: (output) any node pointer */ 2 107 2 108 declare create_array entry() 2 109 returns(pointer); 2 110 /* return: (output) array node pointer */ 2 111 2 112 declare create_block entry(bit(9) aligned,pointer) 2 113 returns(pointer); 2 114 /* parameter 1: (input) block type */ 2 115 /* parameter 2: (input) father block node pointer */ 2 116 /* return: (output) block node pointer */ 2 117 2 118 declare create_bound entry() 2 119 returns(pointer); 2 120 /* return: (output) bound node pointer */ 2 121 2 122 declare create_context entry(pointer,pointer) 2 123 returns(pointer); 2 124 /* parameter 1: (input) block node pointer */ 2 125 /* parameter 2: (input) token pointer */ 2 126 /* return: (output) context node pointer */ 2 127 2 128 declare create_cross_reference entry() 2 129 returns(pointer); 2 130 /* return: (output) cross reference node pointer */ 2 131 2 132 declare create_default entry 2 133 returns(pointer); 2 134 /* return: (output) default node pointer */ 2 135 2 136 declare create_identifier entry() 2 137 returns(pointer); 2 138 /* return: (output) token node pointer */ 2 139 2 140 declare create_label entry(pointer,pointer,bit(3) aligned) 2 141 returns(pointer); 2 142 /* parameter 1: (input) block node pointer */ 2 143 /* parameter 2: (input) token node pointer */ 2 144 /* parameter 3: (input) declare type */ 2 145 /* return: (output) label node pointer */ 2 146 2 147 declare create_list entry(fixed bin(15)) 2 148 returns(pointer); 2 149 /* parameter 1: (input) number of list elements */ 2 150 /* return: (output) list node pointer */ 2 151 2 152 declare create_operator entry(bit(9) aligned,fixed bin(15)) 2 153 returns(pointer); 2 154 /* parameter 1: (input) operator type */ 2 155 /* parameter 2: (input) number of operands */ 2 156 /* return: (output) operator node pointer */ 2 157 2 158 declare create_reference entry(pointer) 2 159 returns(pointer); 2 160 /* parameter 1: (input) symbol node pointer */ 2 161 /* return: (output) reference node pointer */ 2 162 2 163 declare create_statement entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 2 164 returns(pointer); 2 165 /* parameter 1: (input) statement type */ 2 166 /* parameter 2: (input) block node pointer */ 2 167 /* parameter 3: (input) label node pointer */ 2 168 /* parameter 4: (input) conditions */ 2 169 /* return: (output) statement node pointer */ 2 170 2 171 declare create_statement$prologue entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 2 172 returns(pointer); 2 173 /* parameter 1: (input) statement type */ 2 174 /* parameter 2: (input) block node pointer */ 2 175 /* parameter 3: (input) label node pointer */ 2 176 /* parameter 4: (input) conditions */ 2 177 /* return: (output) statement node pointer */ 2 178 2 179 declare create_storage entry(fixed bin(15)) 2 180 returns(pointer); 2 181 /* parameter 1: (input) number of words */ 2 182 /* return: (output) storage block pointer */ 2 183 2 184 declare create_symbol entry(pointer,pointer,bit(3) aligned) 2 185 returns(pointer); 2 186 /* parameter 1: (input) block node pointer */ 2 187 /* parameter 2: (input) token node pointer */ 2 188 /* parameter 3: (input) declare type */ 2 189 /* return: (output) symbol node pointer */ 2 190 2 191 declare create_token entry (character (*), bit (9) aligned) 2 192 returns (ptr); 2 193 /* parameter 1: (input) token string */ 2 194 /* parameter 2: (input) token type */ 2 195 /* return: (output) token node ptr */ 2 196 2 197 declare create_token$init_hash_table entry (); 2 198 2 199 declare create_token$protected entry (char (*), bit (9) aligned, bit (18) aligned) 2 200 returns (ptr); 2 201 /* parameter 1: (input) token string */ 2 202 /* parameter 2: (input) token type */ 2 203 /* parameter 3: (input) protected flag */ 2 204 /* return: (output) token node ptr */ 2 205 2 206 declare decbin entry(character(*) aligned) reducible 2 207 returns(fixed bin(31)); 2 208 /* parameter 1: (input) decimal character string */ 2 209 /* return: (output) binary value */ 2 210 2 211 declare declare_constant entry(bit(*) aligned,bit(36) aligned,fixed bin(31),fixed bin(15)) 2 212 returns(pointer); 2 213 /* parameter 1: (input) value */ 2 214 /* parameter 2: (input) type */ 2 215 /* parameter 3: (input) size */ 2 216 /* parameter 4: (input) scale */ 2 217 /* return: (output) reference node pointer */ 2 218 2 219 declare declare_constant$bit entry(bit(*) aligned) 2 220 returns(pointer); 2 221 /* parameter 1: (input) bit */ 2 222 /* return: (output) reference node pointer */ 2 223 2 224 declare declare_constant$char entry(character(*) aligned) 2 225 returns(pointer); 2 226 /* parameter 1: (input) character */ 2 227 /* return: (output) reference node pointer */ 2 228 2 229 declare declare_constant$desc entry(bit(*) aligned) 2 230 returns(pointer); 2 231 /* parameter 1: (input) descriptor bit value */ 2 232 /* return: (output) reference node pointer */ 2 233 2 234 declare declare_constant$integer entry(fixed bin(31)) /* note...should really be fixed bin(24) */ 2 235 returns(pointer); 2 236 /* parameter 1: (input) integer */ 2 237 /* return: (output) reference node pointer */ 2 238 2 239 declare declare_descriptor entry(pointer,pointer,pointer,pointer,bit(2) aligned) 2 240 returns(pointer); 2 241 /* parameter 1: (input) block node pointer */ 2 242 /* parameter 2: (input) statement node pointer */ 2 243 /* parameter 3: (input) symbol node pointer */ 2 244 /* parameter 4: (input) loc pointer */ 2 245 /* parameter 5: (input) array descriptor bit 2 246* cross_section bit */ 2 247 /* return: (output) reference node pointer */ 2 248 2 249 declare declare_descriptor$ctl entry(pointer,pointer,pointer,pointer,bit(2) aligned) 2 250 returns(pointer); 2 251 /* parameter 1: (input) block node pointer */ 2 252 /* parameter 2: (input) statement node pointer */ 2 253 /* parameter 3: (input) symbol node pointer */ 2 254 /* parameter 4: (input) loc pointer */ 2 255 /* parameter 5: (input) array descriptor bit 2 256* cross_section bit */ 2 257 /* return: (output) reference node pointer */ 2 258 2 259 declare declare_descriptor$param entry(pointer,pointer,pointer,pointer,bit(2) aligned) 2 260 returns(pointer); 2 261 /* parameter 1: (input) block node pointer */ 2 262 /* parameter 2: (input) statement node pointer */ 2 263 /* parameter 3: (input) symbol node pointer */ 2 264 /* parameter 4: (input) loc pointer */ 2 265 /* parameter 5: (input) array descriptor bit 2 266* cross_section bit */ 2 267 /* return: (output) reference node pointer */ 2 268 2 269 declare declare_integer entry(pointer) 2 270 returns(pointer); 2 271 /* parameter 1: (input) block node pointer */ 2 272 /* return: (output) reference node pointer */ 2 273 2 274 declare declare_picture entry(char(*)aligned,pointer,fixed bin(15)); 2 275 /* parameter 1: (input) picture string */ 2 276 /* parameter 2: (input) symbol node pointer */ 2 277 /* parameter 3: (output) error code, if any */ 2 278 2 279 declare declare_picture_temp entry(char(*) aligned,fixed bin(31),bit(1) aligned,bit(1) aligned) 2 280 returns(pointer); 2 281 /* parameter 1: (input) picture string */ 2 282 /* parameter 2: (input) scalefactor of picture */ 2 283 /* parameter 3: (input) ="1"b => complex picture */ 2 284 /* parameter 4: (input) ="1"b => unaligned temp */ 2 285 /* return: (output) reference node pointer */ 2 286 2 287 declare declare_pointer entry(pointer) 2 288 returns(pointer); 2 289 /* parameter 1: (input) block node pointer */ 2 290 /* return: (output) reference node pointer */ 2 291 2 292 declare declare_temporary entry(bit(36) aligned,fixed bin(31),fixed bin(15),pointer) 2 293 returns(pointer); 2 294 /* parameter 1: (input) type */ 2 295 /* parameter 2: (input) precision */ 2 296 /* parameter 3: (input) scale */ 2 297 /* parameter 4: (input) length */ 2 298 /* return: (output) reference node pointer */ 2 299 2 300 declare decode_node_id entry(pointer,bit(1) aligned) 2 301 returns(char(120) varying); 2 302 /* parameter 1: (input) node pointer */ 2 303 /* parameter 2: (input) ="1"b => capitals */ 2 304 /* return: (output) source line id */ 2 305 2 306 declare decode_source_id entry( 3 1 1 structure unaligned, 3 2 2 /* file_number */ bit(8), 3 3 2 /* line_number */ bit(14), 3 4 2 /* stmt_number */ bit(5), 2 307 2 308 bit(1) aligned) 2 309 returns(char(120) varying); 2 310 /* parameter 1: (input) source id */ 2 311 /* parameter 2: (input) ="1"b => capitals */ 2 312 /* return: (output) source line id */ 2 313 2 314 declare error entry(fixed bin(15),pointer,pointer); 2 315 /* parameter 1: (input) error number */ 2 316 /* parameter 2: (input) statement node pointer or null*/ 2 317 /* parameter 3: (input) token node pointer */ 2 318 2 319 declare error$omit_text entry(fixed bin(15),pointer,pointer); 2 320 /* parameter 1: (input) error number */ 2 321 /* parameter 2: (input) statement node pointer or null*/ 2 322 /* parameter 3: (input) token node pointer */ 2 323 2 324 declare error_ entry(fixed bin(15), 4 1 1 structure unaligned, 4 2 2 /* file_number */ bit(8), 4 3 2 /* line_number */ bit(14), 4 4 2 /* stmt_number */ bit(5), 2 325 2 326 pointer,fixed bin(8),fixed bin(23),fixed bin(11)); 2 327 /* parameter 1: (input) error number */ 2 328 /* parameter 2: (input) statement id */ 2 329 /* parameter 3: (input) any node pointer */ 2 330 /* parameter 4: (input) source segment */ 2 331 /* parameter 5: (input) source starting character */ 2 332 /* parameter 6: (input) source length */ 2 333 2 334 declare error_$no_text entry(fixed bin(15), 5 1 1 structure unaligned, 5 2 2 /* file_number */ bit(8), 5 3 2 /* line_number */ bit(14), 5 4 2 /* stmt_number */ bit(5), 2 335 2 336 pointer); 2 337 /* parameter 1: (input) error number */ 2 338 /* parameter 2: (input) statement id */ 2 339 /* parameter 3: (input) any node pointer */ 2 340 2 341 declare error_$initialize_error entry(); 2 342 2 343 declare error_$finish entry(); 2 344 2 345 declare free_node entry(pointer); 2 346 /* parameter 1: any node pointer */ 2 347 2 348 declare get_array_size entry(pointer,fixed bin(3)); 2 349 /* parameter 1: (input) symbol node pointer */ 2 350 /* parameter 2: (input) units */ 2 351 2 352 declare get_size entry(pointer); 2 353 /* parameter 1: (input) symbol node pointer */ 2 354 2 355 declare merge_attributes external entry(pointer,pointer) 2 356 returns(bit(1) aligned); 2 357 /* parameter 1: (input) target symbol node pointer */ 2 358 /* parameter 2: (input) source symbol node pointer */ 2 359 /* return: (output) "1"b if merge was unsuccessful */ 2 360 2 361 declare optimizer entry(pointer); 2 362 /* parameter 1: (input) root pointer */ 2 363 2 364 declare parse_error entry(fixed bin(15),pointer); 2 365 /* parameter 1: (input) error number */ 2 366 /* parameter 2: (input) any node pointer */ 2 367 2 368 declare parse_error$no_text entry(fixed bin(15),pointer); 2 369 /* parameter 1: (input) error number */ 2 370 /* parameter 2: (input) any node pointer */ 2 371 2 372 declare pl1_error_print$write_out 2 373 entry(fixed bin(15), 6 1 1 structure unaligned, 6 2 2 /* file_number */ bit(8), 6 3 2 /* line_number */ bit(14), 6 4 2 /* stmt_number */ bit(5), 2 374 2 375 pointer,fixed bin(11),fixed bin(31),fixed bin(31),fixed bin(15)); 2 376 /* parameter 1: (input) error number */ 2 377 /* parameter 2: (input) statement identification */ 2 378 /* parameter 3: (input) any node pointer */ 2 379 /* parameter 4: (input) source segment */ 2 380 /* parameter 5: (input) source character index */ 2 381 /* parameter 6: (input) source length */ 2 382 /* parameter 7: (input) source line */ 2 383 2 384 declare pl1_error_print$listing_segment 2 385 entry(fixed bin(15), 7 1 1 structure unaligned, 7 2 2 /* file_number */ bit(8), 7 3 2 /* line_number */ bit(14), 7 4 2 /* stmt_number */ bit(5), 2 386 2 387 pointer); 2 388 /* parameter 1: (input) error number */ 2 389 /* parameter 2: (input) statement identification */ 2 390 /* parameter 3: (input) token node pointer */ 2 391 2 392 declare pl1_print$varying entry(character(*) aligned varying); 2 393 /* parameter 1: (input) string */ 2 394 2 395 declare pl1_print$varying_nl entry(character(*) aligned varying); 2 396 /* parameter 1: (input) string */ 2 397 2 398 declare pl1_print$non_varying entry(character(*) aligned,fixed bin(31)); 2 399 /* parameter 1: (input) string */ 2 400 /* parameter 2: (input) string length or 0 */ 2 401 2 402 declare pl1_print$non_varying_nl entry(character(*) aligned,fixed bin(31)); 2 403 /* parameter 1: (input) string */ 2 404 /* parameter 2: (input) string length or 0 */ 2 405 2 406 declare pl1_print$string_pointer entry(pointer,fixed bin(31)); 2 407 /* parameter 1: (input) string pointer */ 2 408 /* parameter 2: (input) string size */ 2 409 2 410 declare pl1_print$string_pointer_nl entry(pointer,fixed bin(31)); 2 411 /* parameter 1: (input) string pointer */ 2 412 /* parameter 2: (input) string length or 0 */ 2 413 2 414 declare pl1_print$unaligned_nl entry(character(*) unaligned,fixed bin(31)); 2 415 /* parameter 1: (input) string */ 2 416 /* parameter 2: (input) length */ 2 417 2 418 declare pl1_print$for_lex entry (ptr, fixed bin (14), fixed bin (21), fixed bin (21), bit (1) aligned, bit (1) aligned); 2 419 /* parameter 1: (input) ptr to base of source segment */ 2 420 /* parameter 2: (input) line number */ 2 421 /* parameter 3: (input) starting offset in source seg */ 2 422 /* parameter 4: (input) number of chars to copy */ 2 423 /* parameter 5: (input) ON iff shd print line number */ 2 424 /* parameter 6: (input) ON iff line begins in comment */ 2 425 2 426 declare refer_extent entry(pointer,pointer); 2 427 /* parameter 1: (input/output) null,ref node,op node pointer */ 2 428 /* parameter 2: (input) null,ref node,op node pointer */ 2 429 2 430 declare reserve$clear entry() 2 431 returns(pointer); 2 432 /* return: (output) pointer */ 2 433 2 434 declare reserve$declare_lib entry(fixed bin(15)) 2 435 returns(pointer); 2 436 /* parameter 1: (input) builtin function number */ 2 437 /* return: (output) pointer */ 2 438 2 439 declare reserve$read_lib entry(fixed bin(15)) 2 440 returns(pointer); 2 441 /* parameter 1: (input) builtin function number */ 2 442 /* return: (output) pointer */ 2 443 2 444 declare semantic_translator entry(); 2 445 2 446 declare semantic_translator$abort entry(fixed bin(15),pointer); 2 447 /* parameter 1: (input) error number */ 2 448 /* parameter 2: (input) any node pointer */ 2 449 2 450 declare semantic_translator$error entry(fixed bin(15),pointer); 2 451 /* parameter 1: (input) error number */ 2 452 /* parameter 2: (input) any node pointer */ 2 453 2 454 declare share_expression entry(ptr) 2 455 returns(ptr); 2 456 /* parameter 1: (input) usually operator node pointer */ 2 457 /* return: (output) tree pointer or null */ 2 458 2 459 declare token_to_binary entry(ptr) reducible 2 460 returns(fixed bin(31)); 2 461 /* parameter 1: (input) token node pointer */ 2 462 /* return: (output) converted binary value */ 2 463 2 464 /* END INCLUDE FILE ... language_utility.incl.pl1 */ 1 228 1 229 /* END INCLUDE FILE ... semant.incl.pl1 */ 52 8 1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */ 8 2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */ 8 3 /* format: style3,idind30 */ 8 4 8 5 declare 1 block aligned based, 8 6 2 node_type bit (9) unaligned, 8 7 2 source_id structure unaligned, 8 8 3 file_number bit (8), 8 9 3 line_number bit (14), 8 10 3 statement_number bit (5), 8 11 2 father ptr unaligned, 8 12 2 brother ptr unaligned, 8 13 2 son ptr unaligned, 8 14 2 declaration ptr unaligned, 8 15 2 end_declaration ptr unaligned, 8 16 2 default ptr unaligned, 8 17 2 end_default ptr unaligned, 8 18 2 context ptr unaligned, 8 19 2 prologue ptr unaligned, 8 20 2 end_prologue ptr unaligned, 8 21 2 main ptr unaligned, 8 22 2 end_main ptr unaligned, 8 23 2 return_values ptr unaligned, 8 24 2 return_count ptr unaligned, 8 25 2 plio_ps ptr unaligned, 8 26 2 plio_fa ptr unaligned, 8 27 2 plio_ffsb ptr unaligned, 8 28 2 plio_ssl ptr unaligned, 8 29 2 plio_fab2 ptr unaligned, 8 30 2 block_type bit (9) unaligned, 8 31 2 prefix bit (12) unaligned, 8 32 2 like_attribute bit (1) unaligned, 8 33 2 no_stack bit (1) unaligned, 8 34 2 get_data bit (1) unaligned, 8 35 2 flush_at_call bit (1) unaligned, 8 36 2 processed bit (1) unaligned, 8 37 2 text_displayed bit (1) unaligned, 8 38 2 number fixed bin (9) unsigned unaligned, 8 39 2 free_temps dimension (3) ptr, /* these fields are used by the code generator */ 8 40 2 temp_list ptr, 8 41 2 entry_list ptr, 8 42 2 o_and_s ptr, 8 43 2 why_nonquick aligned, 8 44 3 auto_adjustable_storage bit (1) unaligned, 8 45 3 returns_star_extents bit (1) unaligned, 8 46 3 stack_extended_by_args bit (1) unaligned, 8 47 3 invoked_by_format bit (1) unaligned, 8 48 3 format_statement bit (1) unaligned, 8 49 3 io_statements bit (1) unaligned, 8 50 3 assigned_to_entry_var bit (1) unaligned, 8 51 3 condition_statements bit (1) unaligned, 8 52 3 no_owner bit (1) unaligned, 8 53 3 recursive_call bit (1) unaligned, 8 54 3 options_non_quick bit (1) unaligned, 8 55 3 options_variable bit (1) unaligned, 8 56 3 never_referenced bit (1) unaligned, 8 57 3 pad_nonquick bit (5) unaligned, 8 58 2 prologue_flag bit (1) unaligned, 8 59 2 options_main bit (1) unaligned, 8 60 2 pad bit (16) unaligned, 8 61 2 number_of_entries fixed bin (17), 8 62 2 level fixed bin (17), 8 63 2 last_auto_loc fixed bin (17), 8 64 2 symbol_block fixed bin (17), 8 65 2 entry_info fixed bin (18), 8 66 2 enter structure unaligned, 8 67 3 start fixed bin (17), 8 68 3 end fixed bin (17), 8 69 2 leave structure unaligned, 8 70 3 start fixed bin (17), 8 71 3 end fixed bin (17), 8 72 2 owner ptr; 8 73 8 74 declare max_block_number fixed bin internal static options (constant) initial (511); 8 75 8 76 /* END INCLUDE FILE ... block.incl.pl1 */ 53 9 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 9 2 9 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 9 4 9 5 dcl ( block_node initial("000000001"b), 9 6 statement_node initial("000000010"b), 9 7 operator_node initial("000000011"b), 9 8 reference_node initial("000000100"b), 9 9 token_node initial("000000101"b), 9 10 symbol_node initial("000000110"b), 9 11 context_node initial("000000111"b), 9 12 array_node initial("000001000"b), 9 13 bound_node initial("000001001"b), 9 14 format_value_node initial("000001010"b), 9 15 list_node initial("000001011"b), 9 16 default_node initial("000001100"b), 9 17 machine_state_node initial("000001101"b), 9 18 source_node initial("000001110"b), 9 19 label_node initial("000001111"b), 9 20 cross_reference_node initial("000010000"b), 9 21 sf_par_node initial("000010001"b), 9 22 temporary_node initial("000010010"b), 9 23 label_array_element_node initial("000010011"b), 9 24 by_name_agg_node initial("000010100"b)) 9 25 bit(9) internal static aligned options(constant); 9 26 9 27 dcl 1 node based aligned, 9 28 2 type unal bit(9), 9 29 2 source_id unal structure, 9 30 3 file_number bit(8), 9 31 3 line_number bit(14), 9 32 3 statement_number bit(5); 9 33 9 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 54 10 1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */ 10 2 10 3 dcl 1 reference based aligned, 10 4 2 node_type bit(9) unaligned, 10 5 2 array_ref bit(1) unaligned, 10 6 2 varying_ref bit(1) unaligned, 10 7 2 shared bit(1) unaligned, 10 8 2 put_data_sw bit(1) unaligned, 10 9 2 processed bit(1) unaligned, 10 10 2 units fixed(3) unaligned, 10 11 2 ref_count fixed(17) unaligned, 10 12 2 c_offset fixed(24), 10 13 2 c_length fixed(24), 10 14 2 symbol ptr unaligned, 10 15 2 qualifier ptr unaligned, 10 16 2 offset ptr unaligned, 10 17 2 length ptr unaligned, 10 18 2 subscript_list ptr unaligned, 10 19 /* these fields are used by the 645 code generator */ 10 20 2 address structure unaligned, 10 21 3 base bit(3), 10 22 3 offset bit(15), 10 23 3 op bit(9), 10 24 3 no_address bit(1), 10 25 3 inhibit bit(1), 10 26 3 ext_base bit(1), 10 27 3 tag bit(6), 10 28 2 info structure unaligned, 10 29 3 address_in structure, 10 30 4 b dimension(0:7) bit(1), 10 31 4 storage bit(1), 10 32 3 value_in structure, 10 33 4 a bit(1), 10 34 4 q bit(1), 10 35 4 aq bit(1), 10 36 4 string_aq bit(1), 10 37 4 complex_aq bit(1), 10 38 4 decimal_aq bit(1), 10 39 4 b dimension(0:7) bit(1), 10 40 4 storage bit(1), 10 41 4 indicators bit(1), 10 42 4 x dimension(0:7) bit(1), 10 43 3 other structure, 10 44 4 big_offset bit(1), 10 45 4 big_length bit(1), 10 46 4 modword_in_offset bit(1), 10 47 2 data_type fixed(5) unaligned, 10 48 2 bits structure unaligned, 10 49 3 padded_ref bit(1), 10 50 3 aligned_ref bit(1), 10 51 3 long_ref bit(1), 10 52 3 forward_ref bit(1), 10 53 3 ic_ref bit(1), 10 54 3 temp_ref bit(1), 10 55 3 defined_ref bit(1), 10 56 3 evaluated bit(1), 10 57 3 allocate bit(1), 10 58 3 allocated bit(1), 10 59 3 aliasable bit(1), 10 60 3 even bit(1), 10 61 3 perm_address bit(1), 10 62 3 aggregate bit(1), 10 63 3 hit_zero bit(1), 10 64 3 dont_save bit(1), 10 65 3 fo_in_qual bit(1), 10 66 3 hard_to_load bit(1), 10 67 2 relocation bit(12) unaligned, 10 68 2 more_bits structure unaligned, 10 69 3 substr bit(1), 10 70 3 padded_for_store_ref bit(1), 10 71 3 aligned_for_store_ref bit(1), 10 72 3 mbz bit(15), 10 73 2 store_ins bit(18) unaligned; 10 74 10 75 /* END INCLUDE FILE ... reference.incl.pl1 */ 55 11 1 /* BEGIN INCLUDE FILE ... context.incl.pl1 */ 11 2 11 3 dcl 1 context based aligned, 11 4 2 node_type bit(9) unaligned, 11 5 2 bits structure unaligned, 11 6 3 types structure, 11 7 4 structure bit(1), 11 8 4 fixed bit(1), 11 9 4 float bit(1), 11 10 4 bit bit(1), 11 11 4 char bit(1), 11 12 4 ptr bit(1), 11 13 4 offset bit(1), 11 14 4 area bit(1), 11 15 4 label bit(1), 11 16 4 entry bit(1), 11 17 4 file bit(1), 11 18 4 arg_descriptor bit(1), 11 19 4 storage_block bit(1), 11 20 4 unused_1 bit(1), 11 21 4 condition bit(1), 11 22 4 format bit(1), 11 23 4 builtin bit(1), 11 24 4 generic bit(1), 11 25 4 picture bit(1), 11 26 3 parameter bit(1), 11 27 2 reserved bit(7) unaligned, 11 28 2 next ptr unaligned, 11 29 2 token ptr unaligned; 11 30 11 31 /* END INCLUDE FILE ... context.incl.pl1 */ 56 12 1 /* BEGIN INCLUDE FILE ... declare_type.incl.pl1 */ 12 2 12 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 12 4 12 5 dcl ( by_declare initial("001"b), 12 6 by_explicit_context initial("010"b), 12 7 by_context initial("011"b), 12 8 by_implication initial("100"b), 12 9 by_compiler initial("101"b)) int static bit(3) aligned options(constant); 12 10 12 11 /* END INCLUDE FILE ... declare_type.incl.pl1 */ 57 13 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 13 2 13 3 dcl 1 symbol based aligned, 13 4 2 node_type bit(9) unal, 13 5 2 source_id structure unal, 13 6 3 file_number bit(8), 13 7 3 line_number bit(14), 13 8 3 statement_number bit(5), 13 9 2 location fixed(18) unal unsigned, 13 10 2 allocated bit(1) unal, 13 11 2 dcl_type bit(3) unal, 13 12 2 reserved bit(6) unal, 13 13 2 pix unal, 13 14 3 pic_fixed bit(1) unal, 13 15 3 pic_float bit(1) unal, 13 16 3 pic_char bit(1) unal, 13 17 3 pic_scale fixed(7) unal, 13 18 3 pic_size fixed(7) unal, 13 19 2 level fixed(8) unal, 13 20 2 boundary fixed(3) unal, 13 21 2 size_units fixed(3) unal, 13 22 2 scale fixed(7) unal, 13 23 2 runtime bit(18) unal, 13 24 2 runtime_offset bit(18) unal, 13 25 2 block_node ptr unal, 13 26 2 token ptr unal, 13 27 2 next ptr unal, 13 28 2 multi_use ptr unal, 13 29 2 cross_references ptr unal, 13 30 2 initial ptr unal, 13 31 2 array ptr unal, 13 32 2 descriptor ptr unal, 13 33 2 equivalence ptr unal, 13 34 2 reference ptr unal, 13 35 2 general ptr unal, 13 36 2 father ptr unal, 13 37 2 brother ptr unal, 13 38 2 son ptr unal, 13 39 2 word_size ptr unal, 13 40 2 bit_size ptr unal, 13 41 2 dcl_size ptr unal, 13 42 2 symtab_size ptr unal, 13 43 2 c_word_size fixed(24), 13 44 2 c_bit_size fixed(24), 13 45 2 c_dcl_size fixed(24), 13 46 13 47 2 attributes structure aligned, 13 48 3 data_type structure unal, 13 49 4 structure bit(1) , 13 50 4 fixed bit(1), 13 51 4 float bit(1), 13 52 4 bit bit(1), 13 53 4 char bit(1), 13 54 4 ptr bit(1), 13 55 4 offset bit(1), 13 56 4 area bit(1), 13 57 4 label bit(1), 13 58 4 entry bit(1), 13 59 4 file bit(1), 13 60 4 arg_descriptor bit(1), 13 61 4 storage_block bit(1), 13 62 4 explicit_packed bit(1), /* options(packed) */ 13 63 4 condition bit(1), 13 64 4 format bit(1), 13 65 4 builtin bit(1), 13 66 4 generic bit(1), 13 67 4 picture bit(1), 13 68 13 69 3 misc_attributes structure unal, 13 70 4 dimensioned bit(1), 13 71 4 initialed bit(1), 13 72 4 aligned bit(1), 13 73 4 unaligned bit(1), 13 74 4 signed bit(1), 13 75 4 unsigned bit(1), 13 76 4 precision bit(1), 13 77 4 varying bit(1), 13 78 4 local bit(1), 13 79 4 decimal bit(1), 13 80 4 binary bit(1), 13 81 4 real bit(1), 13 82 4 complex bit(1), 13 83 4 variable bit(1), 13 84 4 reducible bit(1), 13 85 4 irreducible bit(1), 13 86 4 returns bit(1), 13 87 4 position bit(1), 13 88 4 internal bit(1), 13 89 4 external bit(1), 13 90 4 like bit(1), 13 91 4 member bit(1), 13 92 4 non_varying bit(1), 13 93 4 options bit(1), 13 94 4 variable_arg_list bit(1), /* options(variable) */ 13 95 4 alloc_in_text bit(1), /* options(constant) */ 13 96 13 97 3 storage_class structure unal, 13 98 4 auto bit(1), 13 99 4 based bit(1), 13 100 4 static bit(1), 13 101 4 controlled bit(1), 13 102 4 defined bit(1), 13 103 4 parameter bit(1), 13 104 4 param_desc bit(1), 13 105 4 constant bit(1), 13 106 4 temporary bit(1), 13 107 4 return_value bit(1), 13 108 13 109 3 file_attributes structure unal, 13 110 4 print bit(1), 13 111 4 input bit(1), 13 112 4 output bit(1), 13 113 4 update bit(1), 13 114 4 stream bit(1), 13 115 4 reserved_1 bit(1), 13 116 4 record bit(1), 13 117 4 sequential bit(1), 13 118 4 direct bit(1), 13 119 4 interactive bit(1), /* env(interactive) */ 13 120 4 reserved_2 bit(1), 13 121 4 reserved_3 bit(1), 13 122 4 stringvalue bit(1), /* env(stringvalue) */ 13 123 4 keyed bit(1), 13 124 4 reserved_4 bit(1), 13 125 4 environment bit(1), 13 126 13 127 3 compiler_developed structure unal, 13 128 4 aliasable bit(1), 13 129 4 packed bit(1), 13 130 4 passed_as_arg bit(1), 13 131 4 allocate bit(1), 13 132 4 set bit(1), 13 133 4 exp_extents bit(1), 13 134 4 refer_extents bit(1), 13 135 4 star_extents bit(1), 13 136 4 isub bit(1), 13 137 4 put_in_symtab bit(1), 13 138 4 contiguous bit(1), 13 139 4 put_data bit(1), 13 140 4 overlayed bit(1), 13 141 4 error bit(1), 13 142 4 symtab_processed bit(1), 13 143 4 overlayed_by_builtin bit(1), 13 144 4 defaulted bit(1), 13 145 4 connected bit(1); 13 146 13 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 58 14 1 /* BEGIN INCLUDE FILE ... token.incl.pl1 */ 14 2 14 3 dcl 1 token based aligned, 14 4 2 node_type bit(9) unaligned, 14 5 2 type bit(9) unaligned, 14 6 2 loc bit(18) unaligned, /* symtab offset for identifiers, "p" flag for constants */ 14 7 2 declaration ptr unaligned, 14 8 2 next ptr unaligned, 14 9 2 size fixed(9), 14 10 2 string char(n refer(token.size)); 14 11 14 12 /* END INCLUDE FILE ... token.incl.pl1 */ 59 60 61 /* program */ 62 63 root = P_root; 64 65 /* Make a prefix walk over the block nodes to process the contextual 66* declarations. */ 67 68 do b = root repeat next_prefix_walk_block_node (b) while (b ^= null); 69 call process_block_context (b); 70 end; 71 72 /* Make a prefix walk over the block nodes to resolve all like references. */ 73 74 P_abort = process_next_block; 75 76 do b = root repeat next_prefix_walk_block_node (b) while (b ^= null); 77 if b -> block.like_attribute 78 then do s = b -> block.declaration repeat s -> symbol.next while (s ^= null); 79 pl1_stat_$cur_statement = s; 80 pl1_stat_$statement_id = s -> symbol.source_id; 81 82 if s -> node.type = symbol_node 83 then if s -> symbol.like then call resolve_like_reference (b, s); 84 end; 85 process_next_block: 86 end; 87 88 /* Make a prefix walk over the block nodes to expand all like attributes. */ 89 90 do b = root repeat next_prefix_walk_block_node (b) while (b ^= null); 91 if b -> block.like_attribute 92 then do s = b -> block.declaration repeat s -> symbol.next while (s ^= null); 93 pl1_stat_$cur_statement = s; 94 pl1_stat_$statement_id = s -> symbol.source_id; 95 96 if s -> node.type = symbol_node 97 then if s -> symbol.like then call expand_like_attribute (s); 98 end; 99 end; 100 101 return; 102 103 /* Find the next block node in a prefix walk of all the block nodes. */ 104 105 next_prefix_walk_block_node: 106 procedure (P_b) returns (ptr); 107 108 dcl P_b ptr; /* (Input) */ 109 110 /* automatic */ 111 112 dcl b ptr; 113 114 /* program */ 115 116 if P_b -> block.son ^= null then return (P_b -> block.son); 117 118 do b = P_b repeat b -> block.father while (b ^= null); 119 if b -> block.brother ^= null then return (b -> block.brother); 120 end; 121 122 return (b); 123 end next_prefix_walk_block_node; 124 125 /* Process the contextual declarations in a block. */ 126 127 process_block_context: 128 procedure (P_b); 129 130 dcl P_b ptr; /* (Input) */ 131 132 /* automatic */ 133 134 dcl b ptr; 135 dcl c ptr; 136 dcl cb ptr; 137 dcl d ptr; 138 dcl found_block ptr; 139 dcl found_context bit (1) aligned; 140 dcl found_declaration ptr; 141 dcl s ptr; 142 143 /* Scan the context chain for this block. For each context, search the block 144* symbol chains from this block out. */ 145 146 b = P_b; 147 do c = b -> block.context repeat c -> context.next while (c ^= null); 148 found_block, found_declaration = null; 149 found_context = "0"b; 150 151 if c -> context.parameter 152 then do; 153 do d = c -> context.token -> token.declaration repeat d -> symbol.multi_use 154 while (d ^= null & ^found_context); 155 156 if d -> symbol.block_node = b /* possible previous declaration */ 157 then if context_matches (c, d) 158 then do; 159 found_context = "1"b; 160 found_block = b; 161 found_declaration = d; 162 end; 163 end; 164 165 /* Undeclared parameters must not have contextually derived attributes added 166* to them, even for strong contexts such as ptr, area, file, since a default 167* statement could still supply proper attributes. */ 168 169 if ^found_context 170 then do; 171 d = create_symbol (b, (c -> context.token), by_context); 172 d -> symbol.parameter = "1"b; 173 call print (214, d); 174 end; 175 end; 176 177 else do; 178 do cb = b repeat cb -> block.father while (cb ^= null & ^found_context); 179 do d = c -> context.token -> token.declaration repeat d -> symbol.multi_use 180 while (d ^= null & ^found_context); 181 182 if d -> symbol.block_node = cb 183 /* possible previous declaration */ 184 then if context_matches (c, d) 185 then do; 186 found_context = "1"b; 187 found_block = cb; 188 found_declaration = d; 189 end; 190 end; 191 end; 192 193 if ^found_context 194 then do; 195 found_declaration = 196 create_symbol ((root -> block.son), (c -> context.token), by_context); 197 found_declaration -> symbol.data_type = c -> context.bits.types; 198 199 if c -> context.ptr then call print (69, found_declaration); 200 if c -> context.area then call print (74, found_declaration); 201 if c -> context.file then call print (75, found_declaration); 202 if c -> context.condition then call print (133, found_declaration); 203 end; 204 end; 205 206 if c -> context.condition 207 then if b ^= root -> block.son & b ^= found_block 208 then do; /* make storage for condition in current block */ 209 s = create_symbol (b, (c -> context.token), by_compiler); 210 s -> symbol.condition = "1"b; 211 s -> symbol.equivalence = found_declaration; 212 end; 213 end; 214 215 return; 216 217 /* Match a context with a previous declaration. */ 218 219 context_matches: 220 procedure (c, d) returns (bit (1) aligned); 221 222 dcl c ptr; /* (Input) */ 223 dcl d ptr; /* (Input) */ 224 225 if c -> context.parameter 226 then if d -> symbol.level > 1 then return ("0"b); 227 else if d -> node.type = symbol_node then d -> symbol.parameter = "1"b; 228 229 if c -> context.condition 230 then if d -> symbol.condition & d -> symbol.dcl_type = by_compiler then return ("0"b); 231 232 return ("1"b); 233 end context_matches; 234 235 end process_block_context; 236 237 /* Resolve the like reference in a like attribute. */ 238 239 resolve_like_reference: 240 procedure (P_b, P_s); 241 242 dcl P_b ptr; /* (Input) */ 243 dcl P_s ptr; /* (Input) */ 244 245 /* automatic */ 246 247 dcl like ptr; 248 dcl s ptr; 249 250 /* program */ 251 252 s = P_s; 253 254 /* There may not be a like reference. The parse already printed a message. */ 255 256 if s -> symbol.general = null then return; 257 258 /* Make sure a structure qualified reference doesn't have subscripts or 259* pointer qualification. The parse should really have caught this. */ 260 261 like = null; 262 263 if s -> symbol.general -> node.type = reference_node 264 then do; 265 if s -> symbol.general -> reference.offset ^= null 266 | s -> symbol.general -> reference.qualifier ^= null 267 then call error_exit (119, s); 268 if s -> symbol.general -> reference.symbol -> node.type = symbol_node 269 then like = s -> symbol.general -> reference.symbol; 270 end; 271 272 if like = null 273 then if ^lookup (P_b, s, (s -> symbol.general), like, ""b) then call error_exit (120, s); 274 275 if like -> node.type ^= symbol_node then call error_exit (120, s); 276 277 s -> symbol.general = like -> symbol.reference; 278 279 return_from_resolve_like_reference: 280 return; 281 282 /* Print an error message and exit resolve_like_reference. */ 283 284 error_exit: 285 procedure (m, s); 286 287 dcl m fixed bin (15); /* (Input) */ 288 dcl s ptr; /* (Input) */ 289 290 s -> symbol.general = null; 291 call print (m, s); 292 goto return_from_resolve_like_reference; 293 end error_exit; 294 295 end resolve_like_reference; 296 297 /* Expand a like attribute. */ 298 299 expand_like_attribute: 300 procedure (P_s); 301 302 dcl P_s ptr; /* (Input) */ 303 304 /* automatic */ 305 306 dcl 1 check_ansi aligned, 307 2 like_to_like bit (1), 308 2 sons_contain_like 309 bit (1); 310 dcl like ptr; 311 dcl like_count fixed bin; 312 dcl p ptr; 313 dcl q ptr; 314 dcl s ptr; 315 316 /* internal static */ 317 318 dcl max_like_loop_count fixed bin internal static options (constant) initial (100); 319 /* Error message 389 must be changed when this limit is 320* changed. */ 321 322 /* program */ 323 324 s = P_s; 325 check_ansi = ""b; 326 327 if s -> symbol.general = null then return; /* already expanded the like attribute */ 328 329 if s -> symbol.son ^= null then call error_exit (189, s); 330 331 /* Find the ultimate like target. */ 332 333 like = s -> symbol.general -> reference.symbol; 334 check_ansi.like_to_like = like -> symbol.like; 335 do like_count = 1 to max_like_loop_count while (like -> symbol.general ^= null); 336 if like = s then call error_exit (388, s); /* recursive like reference */ 337 like = like -> symbol.general -> reference.symbol; 338 end; 339 340 if like_count > max_like_loop_count then call error_exit (389, s); 341 342 /* If the like reference refers to a father of the symbol with the like 343* attribute we are expanding, then the like attribute is recursive. */ 344 345 do p = s -> symbol.father repeat p -> symbol.father while (p ^= null); 346 if like = p then call error_exit (388, s); 347 end; 348 349 /* Expand the like attribtue. */ 350 351 call copy_expression$copy_sons (like, s); 352 353 s -> symbol.general = null; 354 355 if s -> symbol.son = null then call error_exit (120, s); 356 357 s -> symbol.structure = "1"b; 358 359 /* Code for correctly diagnosing misuse of the refer option would go here. */ 360 361 do p = s -> symbol.son repeat p -> symbol.next while (p ^= null); 362 p -> symbol.dcl_type = s -> symbol.dcl_type; 363 p -> symbol.block_node = s -> symbol.block_node; 364 p -> symbol.source_id = s -> symbol.source_id; 365 366 /* The following code for the case in which symbol.param_desc is on is 367* probably never executed. Nothing in the parse sets that bit. It seems 368* like an attempt to make the like attribute in descriptors work by changing 369* the name of the symbol node to something that will never be looked up. See 370* PL/I suggestion 1812. */ 371 372 if s -> symbol.param_desc 373 then p -> symbol.token = s -> symbol.token; 374 else do; 375 p -> symbol.multi_use = p -> symbol.token -> token.declaration; 376 p -> symbol.token -> token.declaration = p; 377 end; 378 379 /* Like attributes in sons are expanded because fathers precede sons in the 380* symbol.next chain. */ 381 382 if p -> symbol.like then check_ansi.sons_contain_like = "1"b; 383 384 q = p; 385 end; 386 387 q -> symbol.next = s -> symbol.next; 388 s -> symbol.next = s -> symbol.son; 389 390 if pl1_stat_$check_ansi 391 then do; 392 if check_ansi.like_to_like then call print (386, s); 393 if check_ansi.sons_contain_like then call print (387, s); 394 end; 395 396 return_from_expand_like_attribute: 397 return; 398 399 /* Print an error message and exit expand_like_attribute. */ 400 401 error_exit: 402 procedure (m, s); 403 404 dcl m fixed bin (15); /* (Input) */ 405 dcl s ptr; /* (Input) */ 406 407 call print (m, s); 408 goto return_from_expand_like_attribute; 409 end error_exit; 410 411 end expand_like_attribute; 412 413 /* Print an error message. */ 414 415 print: 416 procedure (m, s); 417 418 dcl m fixed bin (15); /* (Input) */ 419 dcl s ptr; /* (Input) */ 420 421 call error_$no_text (m, s -> symbol.source_id, s); 422 end print; 423 424 end context_processor; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/31/89 1338.4 context_processor.pl1 >spec>install>MR12.3-1066>context_processor.pl1 52 1 07/21/80 1546.3 semant.incl.pl1 >ldd>include>semant.incl.pl1 1-228 2 07/31/89 1332.6 language_utility.incl.pl1 >spec>install>MR12.3-1066>language_utility.incl.pl1 2-307 3 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 2-325 4 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 2-335 5 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 2-374 6 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 2-386 7 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 53 8 08/13/81 2043.5 block.incl.pl1 >ldd>include>block.incl.pl1 54 9 07/21/80 1546.3 nodes.incl.pl1 >ldd>include>nodes.incl.pl1 55 10 07/21/80 1546.3 reference.incl.pl1 >ldd>include>reference.incl.pl1 56 11 11/30/78 1227.4 context.incl.pl1 >ldd>include>context.incl.pl1 57 12 10/25/79 1645.8 declare_type.incl.pl1 >ldd>include>declare_type.incl.pl1 58 13 12/07/83 1701.7 symbol.incl.pl1 >ldd>include>symbol.incl.pl1 59 14 09/14/77 1705.7 token.incl.pl1 >ldd>include>token.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. P_abort parameter label variable dcl 27 set ref 23 74* P_b parameter pointer dcl 130 in procedure "process_block_context" ref 127 146 P_b parameter pointer dcl 242 in procedure "resolve_like_reference" set ref 239 272* P_b parameter pointer dcl 108 in procedure "next_prefix_walk_block_node" ref 105 116 116 118 P_root parameter pointer dcl 26 ref 23 63 P_s parameter pointer dcl 302 in procedure "expand_like_attribute" ref 299 324 P_s parameter pointer dcl 243 in procedure "resolve_like_reference" ref 239 252 area 0(16) based bit(1) level 4 packed packed unaligned dcl 11-3 ref 200 attributes 31 based structure level 2 dcl 13-3 b 000124 automatic pointer dcl 134 in procedure "process_block_context" set ref 146* 147 156 160 171* 178 206 206 209* b 000114 automatic pointer dcl 112 in procedure "next_prefix_walk_block_node" set ref 118* 118* 119 119* 120 122 b 000100 automatic pointer dcl 31 in procedure "context_processor" set ref 68* 68* 69* 70* 76* 76* 77 77 82* 85* 90* 90* 91 91* 99* bits 0(09) based structure level 2 packed packed unaligned dcl 11-3 block based structure level 1 dcl 8-5 block_node 4 based pointer level 2 packed packed unaligned dcl 13-3 set ref 156 182 363* 363 brother 2 based pointer level 2 packed packed unaligned dcl 8-5 ref 119 119 by_compiler 000000 constant bit(3) initial dcl 12-5 set ref 209* 229 by_context 000001 constant bit(3) initial dcl 12-5 set ref 171* 195* c parameter pointer dcl 222 in procedure "context_matches" ref 219 225 229 c 000126 automatic pointer dcl 135 in procedure "process_block_context" set ref 147* 147* 151 153 156* 171 179 182* 195 197 199 200 201 202 206 209* 213 cb 000130 automatic pointer dcl 136 set ref 178* 178* 182 187* 191 check_ansi 000200 automatic structure level 1 dcl 306 set ref 325* condition 0(23) based bit(1) level 4 in structure "context" packed packed unaligned dcl 11-3 in procedure "context_processor" ref 202 206 229 condition 31(14) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 13-3 in procedure "context_processor" set ref 210* 229 context 10 based pointer level 2 in structure "block" packed packed unaligned dcl 8-5 in procedure "context_processor" ref 147 context based structure level 1 dcl 11-3 in procedure "context_processor" copy_expression$copy_sons 000020 constant entry external dcl 2-99 ref 351 create_symbol 000022 constant entry external dcl 2-184 ref 171 195 209 d parameter pointer dcl 223 in procedure "context_matches" ref 219 225 227 227 229 229 d 000132 automatic pointer dcl 137 in procedure "process_block_context" set ref 153* 153* 156 156* 161* 163 171* 172 173* 179* 179* 182 182* 188* 190 data_type 31 based structure level 3 packed packed unaligned dcl 13-3 set ref 197* dcl_type 1(19) based bit(3) level 2 packed packed unaligned dcl 13-3 set ref 229 362* 362 declaration 1 based pointer level 2 in structure "token" packed packed unaligned dcl 14-3 in procedure "context_processor" set ref 153 179 375 376* declaration 4 based pointer level 2 in structure "block" packed packed unaligned dcl 8-5 in procedure "context_processor" ref 77 91 equivalence 14 based pointer level 2 packed packed unaligned dcl 13-3 set ref 211* error_$no_text 000024 constant entry external dcl 2-334 ref 421 father 17 based pointer level 2 in structure "symbol" packed packed unaligned dcl 13-3 in procedure "context_processor" ref 345 347 father 1 based pointer level 2 in structure "block" packed packed unaligned dcl 8-5 in procedure "context_processor" ref 120 191 file 0(19) based bit(1) level 4 packed packed unaligned dcl 11-3 ref 201 found_block 000134 automatic pointer dcl 138 set ref 148* 160* 187* 206 found_context 000136 automatic bit(1) dcl 139 set ref 149* 153 159* 169 178 179 186* 193 found_declaration 000140 automatic pointer dcl 140 set ref 148* 161* 188* 195* 197 199* 200* 201* 202* 211 general 16 based pointer level 2 packed packed unaligned dcl 13-3 set ref 256 263 265 265 268 268 272 277* 290* 327 333 335 337 353* level 2(11) based fixed bin(8,0) level 2 packed packed unaligned dcl 13-3 ref 225 like 000202 automatic pointer dcl 310 in procedure "expand_like_attribute" set ref 333* 334 335 336 337* 337 346 351* like 32(03) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 13-3 in procedure "context_processor" ref 82 96 334 382 like 000160 automatic pointer dcl 247 in procedure "resolve_like_reference" set ref 261* 268* 272 272* 275 277 like_attribute 24(21) based bit(1) level 2 packed packed unaligned dcl 8-5 ref 77 91 like_count 000204 automatic fixed bin(17,0) dcl 311 set ref 335* 340 like_to_like 000200 automatic bit(1) level 2 dcl 306 set ref 334* 392 lookup 000016 constant entry external dcl 1-153 ref 272 m parameter fixed bin(15,0) dcl 418 in procedure "print" set ref 415 421* m parameter fixed bin(15,0) dcl 404 in procedure "error_exit" set ref 401 407* m parameter fixed bin(15,0) dcl 287 in procedure "error_exit" set ref 284 291* max_like_loop_count constant fixed bin(17,0) initial dcl 318 ref 335 340 misc_attributes 31(19) based structure level 3 packed packed unaligned dcl 13-3 multi_use 7 based pointer level 2 packed packed unaligned dcl 13-3 set ref 163 190 375* next 1 based pointer level 2 in structure "context" packed packed unaligned dcl 11-3 in procedure "context_processor" ref 213 next 6 based pointer level 2 in structure "symbol" packed packed unaligned dcl 13-3 in procedure "context_processor" set ref 84 98 385 387* 387 388* node based structure level 1 dcl 9-27 null builtin function dcl 37 ref 68 76 77 90 91 116 118 119 147 148 153 178 179 256 261 265 265 272 290 327 329 335 345 353 355 361 offset 5 based pointer level 2 packed packed unaligned dcl 10-3 ref 265 p 000206 automatic pointer dcl 312 set ref 345* 345* 346* 347 361* 361* 362 363 364 372 375 375 376 376 382 384* 385 param_desc 32(15) based bit(1) level 4 packed packed unaligned dcl 13-3 ref 372 parameter 0(28) based bit(1) level 3 in structure "context" packed packed unaligned dcl 11-3 in procedure "context_processor" ref 151 225 parameter 32(14) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 13-3 in procedure "context_processor" set ref 172* 227* pl1_stat_$check_ansi 000010 external static bit(1) dcl 41 ref 390 pl1_stat_$cur_statement 000012 external static pointer dcl 43 set ref 79* 93* pl1_stat_$statement_id 000014 external static structure level 1 packed packed unaligned dcl 45 set ref 80* 94* ptr 0(14) based bit(1) level 4 packed packed unaligned dcl 11-3 ref 199 q 000210 automatic pointer dcl 313 set ref 384* 387 qualifier 4 based pointer level 2 packed packed unaligned dcl 10-3 ref 265 reference based structure level 1 dcl 10-3 in procedure "context_processor" reference 15 based pointer level 2 in structure "symbol" packed packed unaligned dcl 13-3 in procedure "context_processor" ref 277 reference_node constant bit(9) initial dcl 9-5 ref 263 root 000102 automatic pointer dcl 32 set ref 63* 68 76 90 195 206 s parameter pointer dcl 405 in procedure "error_exit" set ref 401 407* s 000162 automatic pointer dcl 248 in procedure "resolve_like_reference" set ref 252* 256 263 265 265 265* 268 268 272* 272 272* 275* 277 s parameter pointer dcl 288 in procedure "error_exit" set ref 284 290 291* s 000212 automatic pointer dcl 314 in procedure "expand_like_attribute" set ref 324* 327 329 329* 333 336 336* 340* 345 346* 351* 353 355 355* 357 361 362 363 364 372 372 387 388 388 392* 393* s 000104 automatic pointer dcl 33 in procedure "context_processor" set ref 77* 77* 79 80 82 82 82* 84 91* 91* 93 94 96 96 96* 98 s parameter pointer dcl 419 in procedure "print" set ref 415 421 421* s 000142 automatic pointer dcl 141 in procedure "process_block_context" set ref 209* 210 211 son 3 based pointer level 2 in structure "block" packed packed unaligned dcl 8-5 in procedure "context_processor" ref 116 116 195 206 son 21 based pointer level 2 in structure "symbol" packed packed unaligned dcl 13-3 in procedure "context_processor" ref 329 355 361 388 sons_contain_like 1 000200 automatic bit(1) level 2 dcl 306 set ref 382* 393 source_id 0(09) based structure level 2 packed packed unaligned dcl 13-3 set ref 80 94 364* 364 421* storage_class 32(09) based structure level 3 packed packed unaligned dcl 13-3 structure 31 based bit(1) level 4 packed packed unaligned dcl 13-3 set ref 357* symbol based structure level 1 dcl 13-3 in procedure "context_processor" symbol 3 based pointer level 2 in structure "reference" packed packed unaligned dcl 10-3 in procedure "context_processor" ref 268 268 333 337 symbol_node constant bit(9) initial dcl 9-5 ref 82 96 227 268 275 token based structure level 1 dcl 14-3 in procedure "context_processor" token 2 based pointer level 2 in structure "context" packed packed unaligned dcl 11-3 in procedure "context_processor" ref 153 171 179 195 209 token 5 based pointer level 2 in structure "symbol" packed packed unaligned dcl 13-3 in procedure "context_processor" set ref 372* 372 375 376 type based bit(9) level 2 packed packed unaligned dcl 9-27 ref 82 96 227 263 268 275 types 0(09) based structure level 3 packed packed unaligned dcl 11-3 ref 197 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. adjust_count 000000 constant entry external dcl 2-20 alloc_semantics 000000 constant entry external dcl 1-7 alloc_semantics$init_only 000000 constant entry external dcl 1-12 array_node internal static bit(9) initial dcl 9-5 binary_to_octal_string 000000 constant entry external dcl 2-38 binary_to_octal_var_string 000000 constant entry external dcl 2-43 bindec 000000 constant entry external dcl 2-23 bindec$vs 000000 constant entry external dcl 2-28 binoct 000000 constant entry external dcl 2-33 block_node internal static bit(9) initial dcl 9-5 bound_node internal static bit(9) initial dcl 9-5 builtin 000000 constant entry external dcl 1-17 by_declare internal static bit(3) initial dcl 12-5 by_explicit_context internal static bit(3) initial dcl 12-5 by_implication internal static bit(3) initial dcl 12-5 by_name_agg_node internal static bit(9) initial dcl 9-5 check_star_extents 000000 constant entry external dcl 1-27 compare_declaration 000000 constant entry external dcl 1-31 compare_expression 000000 constant entry external dcl 2-48 constant_length 000000 constant entry external dcl 2-54 context_node internal static bit(9) initial dcl 9-5 context_processor 000000 constant entry external dcl 1-38 convert 000000 constant entry external dcl 2-60 convert$from_builtin 000000 constant entry external dcl 2-72 convert$to_integer 000000 constant entry external dcl 2-66 convert$to_target 000000 constant entry external dcl 2-88 convert$to_target_fb 000000 constant entry external dcl 2-82 convert$validate 000000 constant entry external dcl 2-78 copy_expression 000000 constant entry external dcl 2-94 copy_unique_expression 000000 constant entry external dcl 2-103 create_array 000000 constant entry external dcl 2-108 create_block 000000 constant entry external dcl 2-112 create_bound 000000 constant entry external dcl 2-118 create_context 000000 constant entry external dcl 2-122 create_cross_reference 000000 constant entry external dcl 2-128 create_default 000000 constant entry external dcl 2-132 create_identifier 000000 constant entry external dcl 2-136 create_label 000000 constant entry external dcl 2-140 create_list 000000 constant entry external dcl 2-147 create_operator 000000 constant entry external dcl 2-152 create_reference 000000 constant entry external dcl 2-158 create_statement 000000 constant entry external dcl 2-163 create_statement$prologue 000000 constant entry external dcl 2-171 create_storage 000000 constant entry external dcl 2-179 create_token 000000 constant entry external dcl 2-191 create_token$init_hash_table 000000 constant entry external dcl 2-197 create_token$protected 000000 constant entry external dcl 2-199 cross_reference_node internal static bit(9) initial dcl 9-5 decbin 000000 constant entry external dcl 2-206 declare 000000 constant entry external dcl 1-41 declare_constant 000000 constant entry external dcl 2-211 declare_constant$bit 000000 constant entry external dcl 2-219 declare_constant$char 000000 constant entry external dcl 2-224 declare_constant$desc 000000 constant entry external dcl 2-229 declare_constant$integer 000000 constant entry external dcl 2-234 declare_descriptor 000000 constant entry external dcl 2-239 declare_descriptor$ctl 000000 constant entry external dcl 2-249 declare_descriptor$param 000000 constant entry external dcl 2-259 declare_integer 000000 constant entry external dcl 2-269 declare_picture 000000 constant entry external dcl 2-274 declare_picture_temp 000000 constant entry external dcl 2-279 declare_pointer 000000 constant entry external dcl 2-287 declare_structure 000000 constant entry external dcl 1-44 declare_temporary 000000 constant entry external dcl 2-292 decode_node_id 000000 constant entry external dcl 2-300 decode_source_id 000000 constant entry external dcl 2-306 default_node internal static bit(9) initial dcl 9-5 defined_reference 000000 constant entry external dcl 1-47 do_semantics 000000 constant entry external dcl 1-57 error 000000 constant entry external dcl 2-314 error$omit_text 000000 constant entry external dcl 2-319 error_ 000000 constant entry external dcl 2-324 error_$finish 000000 constant entry external dcl 2-343 error_$initialize_error 000000 constant entry external dcl 2-341 expand_assign 000000 constant entry external dcl 1-62 expand_by_name 000000 constant entry external dcl 1-71 expand_infix 000000 constant entry external dcl 1-76 expand_initial 000000 constant entry external dcl 1-84 expand_prefix 000000 constant entry external dcl 1-89 expand_primitive 000000 constant entry external dcl 1-97 expression_semantics 000000 constant entry external dcl 1-105 fill_refer 000000 constant entry external dcl 1-113 format_value_node internal static bit(9) initial dcl 9-5 free_node 000000 constant entry external dcl 2-345 function 000000 constant entry external dcl 1-125 generic_selector 000000 constant entry external dcl 1-134 get_array_size 000000 constant entry external dcl 2-348 get_size 000000 constant entry external dcl 2-352 io_data_list_semantics 000000 constant entry external dcl 1-143 io_data_list_semantics$format_list_semantics 000000 constant entry external dcl 1-120 io_semantics 000000 constant entry external dcl 1-148 label_array_element_node internal static bit(9) initial dcl 9-5 label_node internal static bit(9) initial dcl 9-5 list_node internal static bit(9) initial dcl 9-5 machine_state_node internal static bit(9) initial dcl 9-5 make_non_quick 000000 constant entry external dcl 1-162 match_arguments 000000 constant entry external dcl 1-166 max_block_number internal static fixed bin(17,0) initial dcl 8-74 merge_attributes 000000 constant entry external dcl 2-355 offset_adder 000000 constant entry external dcl 1-172 operator_node internal static bit(9) initial dcl 9-5 operator_semantics 000000 constant entry external dcl 1-184 optimizer 000000 constant entry external dcl 2-361 parse_error 000000 constant entry external dcl 2-364 parse_error$no_text 000000 constant entry external dcl 2-368 pl1_error_print$listing_segment 000000 constant entry external dcl 2-384 pl1_error_print$write_out 000000 constant entry external dcl 2-372 pl1_print$for_lex 000000 constant entry external dcl 2-418 pl1_print$non_varying 000000 constant entry external dcl 2-398 pl1_print$non_varying_nl 000000 constant entry external dcl 2-402 pl1_print$string_pointer 000000 constant entry external dcl 2-406 pl1_print$string_pointer_nl 000000 constant entry external dcl 2-410 pl1_print$unaligned_nl 000000 constant entry external dcl 2-414 pl1_print$varying 000000 constant entry external dcl 2-392 pl1_print$varying_nl 000000 constant entry external dcl 2-395 propagate_bit 000000 constant entry external dcl 1-192 refer_extent 000000 constant entry external dcl 2-426 reserve$clear 000000 constant entry external dcl 2-430 reserve$declare_lib 000000 constant entry external dcl 2-434 reserve$read_lib 000000 constant entry external dcl 2-439 semantic_translator 000000 constant entry external dcl 2-444 semantic_translator$abort 000000 constant entry external dcl 2-446 semantic_translator$call_es 000000 constant entry external dcl 1-196 semantic_translator$error 000000 constant entry external dcl 2-450 sf_par_node internal static bit(9) initial dcl 9-5 share_expression 000000 constant entry external dcl 2-454 simplify_expression 000000 constant entry external dcl 1-205 simplify_offset 000000 constant entry external dcl 1-212 source_node internal static bit(9) initial dcl 9-5 statement_node internal static bit(9) initial dcl 9-5 subscripter 000000 constant entry external dcl 1-216 temporary_node internal static bit(9) initial dcl 9-5 token_node internal static bit(9) initial dcl 9-5 token_to_binary 000000 constant entry external dcl 2-459 validate 000000 constant entry external dcl 1-225 NAMES DECLARED BY EXPLICIT CONTEXT. context_matches 000570 constant entry internal dcl 219 ref 156 182 context_processor 000020 constant entry external dcl 23 error_exit 000763 constant entry internal dcl 284 in procedure "resolve_like_reference" ref 265 272 275 error_exit 001247 constant entry internal dcl 401 in procedure "expand_like_attribute" ref 329 336 340 346 355 expand_like_attribute 001003 constant entry internal dcl 299 ref 96 next_prefix_walk_block_node 000200 constant entry internal dcl 105 ref 70 85 99 print 001263 constant entry internal dcl 415 ref 173 199 200 201 202 291 392 393 407 process_block_context 000237 constant entry internal dcl 127 ref 69 process_next_block 000120 constant label dcl 85 ref 74 resolve_like_reference 000637 constant entry internal dcl 239 ref 82 return_from_expand_like_attribute 001246 constant label dcl 396 ref 408 return_from_resolve_like_reference 000762 constant label dcl 279 ref 292 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1532 1560 1420 1542 Length 2232 1420 26 436 112 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME context_processor 222 external procedure is an external procedure. next_prefix_walk_block_node internal procedure shares stack frame of external procedure context_processor. process_block_context internal procedure shares stack frame of external procedure context_processor. context_matches internal procedure shares stack frame of external procedure context_processor. resolve_like_reference internal procedure shares stack frame of external procedure context_processor. error_exit internal procedure shares stack frame of external procedure context_processor. expand_like_attribute internal procedure shares stack frame of external procedure context_processor. error_exit internal procedure shares stack frame of external procedure context_processor. print internal procedure shares stack frame of external procedure context_processor. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME context_processor 000100 b context_processor 000102 root context_processor 000104 s context_processor 000114 b next_prefix_walk_block_node 000124 b process_block_context 000126 c process_block_context 000130 cb process_block_context 000132 d process_block_context 000134 found_block process_block_context 000136 found_context process_block_context 000140 found_declaration process_block_context 000142 s process_block_context 000160 like resolve_like_reference 000162 s resolve_like_reference 000200 check_ansi expand_like_attribute 000202 like expand_like_attribute 000204 like_count expand_like_attribute 000206 p expand_like_attribute 000210 q expand_like_attribute 000212 s expand_like_attribute THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. unpk_to_pk call_ext_out return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. copy_expression$copy_sons create_symbol error_$no_text lookup THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. pl1_stat_$check_ansi pl1_stat_$cur_statement pl1_stat_$statement_id LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 23 000014 63 000025 68 000031 69 000036 70 000040 74 000043 76 000050 77 000056 79 000070 80 000073 82 000103 84 000114 85 000120 90 000123 91 000132 93 000144 94 000147 96 000157 98 000170 99 000174 101 000177 105 000200 116 000202 118 000212 119 000220 120 000230 122 000233 127 000237 146 000241 147 000244 148 000252 149 000255 151 000256 153 000261 156 000276 159 000310 160 000312 161 000314 163 000316 169 000322 171 000324 172 000344 173 000347 175 000353 178 000354 179 000366 182 000400 186 000412 187 000414 188 000416 190 000420 191 000424 193 000430 195 000432 197 000455 199 000466 200 000475 201 000504 202 000513 206 000522 209 000536 210 000556 211 000561 213 000563 215 000567 219 000570 225 000572 227 000607 229 000615 232 000634 239 000637 252 000641 256 000644 261 000650 263 000652 265 000657 268 000672 272 000704 275 000746 277 000756 279 000762 284 000763 290 000765 291 000771 292 001002 299 001003 324 001005 325 001010 327 001012 329 001016 333 001025 334 001031 335 001035 336 001051 337 001061 338 001065 340 001067 345 001076 346 001106 347 001116 351 001122 353 001133 355 001136 357 001144 361 001147 362 001156 363 001164 364 001166 372 001175 375 001203 376 001206 382 001210 384 001215 385 001216 387 001221 388 001225 390 001227 392 001232 393 001240 396 001246 401 001247 407 001251 408 001262 415 001263 421 001265 422 001304 ----------------------------------------------------------- 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