COMPILATION LISTING OF SEGMENT statement_parse Compiled by: Multics PL/I Compiler, Release 33c, of October 25, 1990 Compiled at: ACTC Technologies Inc. Compiled on: 92-04-24_1114.97_Fri_mdt 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 statement_parse: proc(k,label_ptr,conditions,cblock,type); 12 13 /* Rewritten: 28 September 1970 by P. Green for Version II 14* Modified: 15 Feb 1978 to implement options(main) and the stop statement 15* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 16 17 dcl (i,j,k,libe_no,n initial(0),type) fixed bin(15); 18 dcl (addr,bit,fixed,null,binary) builtin; 19 dcl conditions bit(12) aligned; 20 dcl (p,q,r,s,cblock,label_ptr,stmnt) ptr; 21 dcl stack(128) ptr; 22 dcl op_code bit(9) aligned; 23 24 dcl pl1_stat_$cur_statement ptr ext static; 25 26 dcl action_index(0:37) fixed bin(15) int static initial( 27 28 0,1,2,0,3, 10,0,10,10,10, 0,9,0,0,10, 10,4,10,5,0, 29 10,6,0,10,0, 10,10,7,8,10, 8,11,0,10,10, 10,0,0); 30 1 1 /* BEGIN INCLUDE FILE parse.incl.pl1 */ 1 2 1 3 1 4 /****^ HISTORY COMMENTS: 1 5* 1) change(91-01-09,Blackmore), approve(91-01-09,MCR8234), 1 6* audit(91-12-05,Huen), install(92-04-24,MR12.5-1011): 1 7* Change entry points for 'lex', 'lex$write_last_line', and 1 8* 'statement_type', for constant reference resolution fix. 1 9* END HISTORY COMMENTS */ 1 10 1 11 declare attribute_parse entry(ptr,ptr,fixed bin(15),bit(1) aligned); 1 12 /* parameter 1: (input) block node ptr */ 1 13 /* parameter 2: (input) symbol node ptr */ 1 14 /* parameter 3: (in/out) token index */ 1 15 /* parameter 4: (input) called while doing generic */ 1 16 1 17 declare context entry(ptr,ptr,fixed bin(15)); 1 18 /* parameter 1: (input) usually token node ptr */ 1 19 /* parameter 2: (input) block node ptr */ 1 20 /* parameter 3: (input) context type */ 1 21 1 22 declare data_list_parse entry(fixed bin(15),ptr,ptr) 1 23 returns(bit(1) aligned); 1 24 /* parameter 1: (in/out) token index */ 1 25 /* parameter 2: (input) block node ptr */ 1 26 /* parameter 3: (output) data list parse tree ptr */ 1 27 /* return: (output) valid parse bit */ 1 28 1 29 declare declare_label entry(ptr,ptr,ptr,bit(3) aligned); 1 30 /* parameter 1: (input) block node ptr */ 1 31 /* parameter 2: (input) statement node ptr */ 1 32 /* parameter 3: (input) label list ptr or null */ 1 33 /* parameter 4: (input) declare type */ 1 34 1 35 declare declare_parse entry(fixed bin(15),ptr,ptr); 1 36 /* parameter 1: (input) token index */ 1 37 /* parameter 2: (input) block node ptr */ 1 38 /* parameter 3: (input) label list ptr or null */ 1 39 1 40 declare declare_parse$abort entry(fixed bin(15),ptr); 1 41 /* parameter 1: (input) error number */ 1 42 /* parameter 2: (input) any node ptr */ 1 43 1 44 declare default_parse entry(fixed bin(15),ptr,ptr); 1 45 /* parameter 1: (input) token index */ 1 46 /* parameter 2: (input) block node ptr */ 1 47 /* parameter 3: (input) label list ptr or null */ 1 48 1 49 declare descriptor_parse entry(ptr,ptr,fixed bin(15)) 1 50 returns(ptr); 1 51 /* parameter 1: (input) block node ptr */ 1 52 /* parameter 2: (input) token node ptr or null */ 1 53 /* parameter 3: (in/out) token index */ 1 54 /* return: (output) symbol node ptr */ 1 55 1 56 declare do_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr, 1 57 bit(1) aligned,bit(1) aligned,bit(1) aligned); 1 58 /* parameter 1: (in/out) token index */ 1 59 /* parameter 2: (input) label list ptr or null */ 1 60 /* parameter 3: (input) conditions */ 1 61 /* parameter 4: (input) father block node ptr */ 1 62 /* parameter 5: (output) end ptr */ 1 63 /* parameter 6: (input) entry bit */ 1 64 /* parameter 7: (input) return bit */ 1 65 /* parameter 8: (input) iterative do bit */ 1 66 1 67 declare evaluate entry(bit(9) aligned,ptr,ptr) returns(ptr); 1 68 /* parameter 1: (input) opcode */ 1 69 /* parameter 2: (input) left operand (token ptr) */ 1 70 /* parameter 3: (input) right operand (token ptr) */ 1 71 /* return: (output) ptr to result node */ 1 72 1 73 declare expression_parse entry(fixed bin(15),ptr) 1 74 returns(ptr); 1 75 /* parameter 1: (in/out) token index */ 1 76 /* parameter 2: (input) block node ptr */ 1 77 /* return: (output) expression parse tree ptr */ 1 78 1 79 declare format_list_parse entry(fixed bin(15),ptr,ptr,ptr) 1 80 returns(bit(1) aligned); 1 81 /* parameter 1: (in/out) token index */ 1 82 /* parameter 2: (input) block node ptr */ 1 83 /* parameter 3: (input) statement node ptr */ 1 84 /* parameter 4: (output) format list parse tree ptr */ 1 85 /* return: (output) valid parse bit */ 1 86 1 87 declare if_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr, 1 88 bit(1) aligned); 1 89 /* parameter 1: (in/out) token index */ 1 90 /* parameter 2: (input) label list ptr or null */ 1 91 /* parameter 3: (input) conditions */ 1 92 /* parameter 4: (input) father block node ptr */ 1 93 /* parameter 5: (input) end ptr */ 1 94 /* parameter 6: (output) valid parse bit */ 1 95 1 96 declare io_statement_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr, 1 97 bit(1) aligned,bit(9) aligned); 1 98 /* parameter 1: (in/out) token index */ 1 99 /* parameter 2: (input) label list ptr or null */ 1 100 /* parameter 3: (input) conditions */ 1 101 /* parameter 4: (input) father block node ptr */ 1 102 /* parameter 5: (output) end ptr */ 1 103 /* parameter 6: (output) valid parse bit */ 1 104 /* parameter 7: (output) statement type */ 1 105 1 106 declare lex entry(ptr); 1 107 /* parameter 1: (input) block node ptr */ 1 108 1 109 declare lex$write_last_line entry(ptr); 1 110 /* parameter 1: (input) block node ptr */ 1 111 1 112 declare lex$initialize_lex entry(ptr,fixed bin(15)); 1 113 /* parameter 1: (input) ptr to source */ 1 114 /* parameter 2: (input) length of source (chars) */ 1 115 1 116 declare on_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr); 1 117 /* parameter 1: (in/out) token index */ 1 118 /* parameter 2: (input) label list ptr or null */ 1 119 /* parameter 3: (input) conditions */ 1 120 /* parameter 4: (input) father block node ptr */ 1 121 /* parameter 5: (output) end ptr (set to null) */ 1 122 1 123 declare on_parse$revert entry(fixed bin(15),ptr,ptr); 1 124 /* parameter 1: (input) token index */ 1 125 /* parameter 2: (input) statement node ptr */ 1 126 /* parameter 3: (input) block node ptr */ 1 127 1 128 declare parse entry(ptr,ptr,fixed bin(15)); 1 129 /* parameter 1: (output) root ptr */ 1 130 /* parameter 2 (input) source ptr */ 1 131 /* parameter 3: (input) source length */ 1 132 1 133 declare procedure_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr, 1 134 bit(9) aligned,bit(1) aligned); 1 135 /* parameter 1: (in/out) token index */ 1 136 /* parameter 2: (input) label list ptr or null */ 1 137 /* parameter 3: (input) conditions */ 1 138 /* parameter 4: (input) father block node ptr */ 1 139 /* parameter 5: (output) end ptr */ 1 140 /* parameter 6: (input) block type */ 1 141 /* parameter 7: (input) no return statement bit */ 1 142 1 143 declare process_entry entry(fixed bin(15),bit(9) aligned,ptr,ptr,bit(12) aligned); 1 144 /* parameter 1: (in/out) token index */ 1 145 /* parameter 2: (input) statement type */ 1 146 /* parameter 3: (input) block node ptr */ 1 147 /* parameter 4: (input) label list ptr or null */ 1 148 /* parameter 5: (input) conditions */ 1 149 1 150 declare reference_parse entry(fixed bin(15),ptr) 1 151 returns(ptr); 1 152 /* parameter 1: (in/out) token index */ 1 153 /* parameter 2: (input) block node ptr */ 1 154 /* return: (output) reference parse tree ptr */ 1 155 1 156 declare reserve$rename_parse entry(fixed bin(15)) returns(bit(1) aligned); 1 157 /* parameter 1: (in/out) token index */ 1 158 /* return: (output) success bit */ 1 159 1 160 declare statement_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,fixed bin(15)); 1 161 /* parameter 1: (in/out) token index */ 1 162 /* parameter 2: (input) label list ptr or null */ 1 163 /* parameter 3: (input) conditions */ 1 164 /* parameter 4: (input) block node ptr */ 1 165 /* parameter 5: (input) statement type */ 1 166 1 167 declare statement_type entry(ptr,fixed bin(15),ptr,bit(12) aligned) 1 168 returns(fixed bin(15)); 1 169 /* parameter 1: (input) block node ptr */ 1 170 /* parameter 2: (in/out) token index */ 1 171 /* parameter 3: (output) label list ptr or null */ 1 172 /* parameter 4: (output) conditions */ 1 173 /* return: (output) statement type */ 1 174 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 175 1 176 /* END INCLUDE FILE parse.incl.pl1 */ 31 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 */ 32 9 1 /* BEGIN INCLUDE FILE ... declare_type.incl.pl1 */ 9 2 9 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 9 4 9 5 dcl ( by_declare initial("001"b), 9 6 by_explicit_context initial("010"b), 9 7 by_context initial("011"b), 9 8 by_implication initial("100"b), 9 9 by_compiler initial("101"b)) int static bit(3) aligned options(constant); 9 10 9 11 /* END INCLUDE FILE ... declare_type.incl.pl1 */ 33 10 1 dcl ( pointer_context initial(6), 10 2 area_context initial(8), 10 3 file_name_context initial(11), 10 4 condition_context initial(15), 10 5 parameter_context initial(20)) fixed bin(15) internal static options(constant); 34 11 1 dcl 1 label based aligned, 11 2 2 node_type bit(9) unaligned, 11 3 2 source_id structure unaligned, 11 4 3 file_number bit(8), 11 5 3 line_number bit(14), 11 6 3 statement_number bit(5), 11 7 2 location fixed(17) unaligned, 11 8 2 allocated bit(1) unaligned, 11 9 2 dcl_type bit(3) unaligned, 11 10 2 reserved bit(29) unaligned, 11 11 2 array bit(1) unaligned, 11 12 2 used_as_format bit(1) unaligned, 11 13 2 used_in_goto bit(1) unaligned, 11 14 2 symbol_table bit(18) unaligned, 11 15 2 low_bound fixed(17) unaligned, 11 16 2 high_bound fixed(17) unaligned, 11 17 2 block_node ptr unaligned, 11 18 2 token ptr unaligned, 11 19 2 next ptr unaligned, 11 20 2 multi_use ptr unaligned, 11 21 2 cross_reference ptr unaligned, 11 22 2 statement ptr unaligned; 35 12 1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */ 12 2 12 3 /* Modified 26 June 81 by EBush to add max_list_elements */ 12 4 12 5 12 6 dcl 1 list based aligned, 12 7 2 node_type bit(9) unaligned, 12 8 2 reserved bit(12) unaligned, 12 9 2 number fixed(14) unaligned, 12 10 2 element dimension(n refer(list.number)) ptr unaligned; 12 11 12 12 dcl max_list_elements fixed bin(17) internal static options (constant) 12 13 init(16383); 12 14 12 15 /* END INCLUDE FILE ... list.incl.pl1 */ 36 13 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 13 2 13 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 13 4 13 5 dcl ( block_node initial("000000001"b), 13 6 statement_node initial("000000010"b), 13 7 operator_node initial("000000011"b), 13 8 reference_node initial("000000100"b), 13 9 token_node initial("000000101"b), 13 10 symbol_node initial("000000110"b), 13 11 context_node initial("000000111"b), 13 12 array_node initial("000001000"b), 13 13 bound_node initial("000001001"b), 13 14 format_value_node initial("000001010"b), 13 15 list_node initial("000001011"b), 13 16 default_node initial("000001100"b), 13 17 machine_state_node initial("000001101"b), 13 18 source_node initial("000001110"b), 13 19 label_node initial("000001111"b), 13 20 cross_reference_node initial("000010000"b), 13 21 sf_par_node initial("000010001"b), 13 22 temporary_node initial("000010010"b), 13 23 label_array_element_node initial("000010011"b), 13 24 by_name_agg_node initial("000010100"b)) 13 25 bit(9) internal static aligned options(constant); 13 26 13 27 dcl 1 node based aligned, 13 28 2 type unal bit(9), 13 29 2 source_id unal structure, 13 30 3 file_number bit(8), 13 31 3 line_number bit(14), 13 32 3 statement_number bit(5); 13 33 13 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 37 14 1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */ 14 2 14 3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */ 14 4 /* Modified: 6 Jun 1979 by PG to add rank and byte */ 14 5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */ 14 6 /* Modified: 26 July 82 BIM wordno, segno */ 14 7 14 8 dcl ( add initial("000010001"b), /* opnd(1) <- opnd(2)+opnd(3) */ 14 9 sub initial("000010010"b), /* opnd(1) <- opnd(2)-opnd(3) */ 14 10 mult initial("000010011"b), /* opnd(1) <- opnd(2)*opnd(3) */ 14 11 div initial("000010100"b), /* opnd(1) <- opnd(2)/opnd(3) */ 14 12 negate initial("000010101"b), /* opnd(1) <- -opnd(2) */ 14 13 exp initial("000010110"b), /* opnd(1) <- opnd(2) ** opnd(3) */ 14 14 14 15 and_bits initial("000100001"b), /* opnd(1) <- opnd(2) & opnd(3) */ 14 16 or_bits initial("000100010"b), /* opnd(1) <- opnd(2)|opnd(3) */ 14 17 xor_bits initial("000100011"b), /* opnd(1) <- opnd(2) xor opnd(3) */ 14 18 not_bits initial("000100100"b), /* opnd(1) <- ^opnd(2) */ 14 19 cat_string initial("000100101"b), /* opnd(1) <- opnd(2)||opnd(3) */ 14 20 bool_fun initial("000100110"b), /* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */ 14 21 14 22 assign initial("000110001"b), /* opnd(1) <- opnd(2) */ 14 23 assign_size_ck initial("000110010"b), /* opnd(1) <- opnd(2) */ 14 24 assign_zero initial("000110011"b), /* opnd(1) <- 0 */ 14 25 copy_words initial("000110100"b), /* move opnd(2) to opnd(1) by opnd(3) words */ 14 26 copy_string initial("000110101"b), /* move opnd(2) to opnd(1) by opnd(3) units */ 14 27 make_desc initial("000110110"b), /* opnd(1) <- descriptor(opnd(2),opnd(3)) */ 14 28 assign_round initial("000110111"b), /* opnd(1) <- opnd(2) rounded */ 14 29 pack initial("000111000"b), /* opnd(1) <- encode to picture opnd(2) */ 14 30 unpack initial("000111001"b), /* opnd(1) <- decode from picture opnd(2) */ 14 31 14 32 less_than initial("001000100"b), /* opnd(1) <- opnd(2) < opnd(3) */ 14 33 greater_than initial("001000101"b), /* opnd(1) <- opnd(2) > opnd(3) */ 14 34 equal initial("001000110"b), /* opnd(1) <- opnd(2) = opnd(3) */ 14 35 not_equal initial("001000111"b), /* opnd(1) <- opnd(2) ^= opnd(3) */ 14 36 less_or_equal initial("001001000"b), /* opnd(1) <- opnd(2) <= opnd(3) */ 14 37 greater_or_equal initial("001001001"b), /* opnd(1) <- opnd(2) >= opnd(3) */ 14 38 14 39 jump initial("001010001"b), /* go to opnd(1) unconditionally */ 14 40 jump_true initial("001010010"b), /* go to opnd(1) if opnd(2) is not 0 */ 14 41 jump_false initial("001010011"b), /* go to opnd(1) if opnd(2) is all 0 */ 14 42 jump_if_lt initial("001010100"b), /* go to opnd(1) if opnd(2) < opnd(3) */ 14 43 jump_if_gt initial("001010101"b), /* go to opnd(1) if opnd(2) > opnd(3) */ 14 44 jump_if_eq initial("001010110"b), /* go to opnd(1) if opnd(2) = opnd(3) */ 14 45 jump_if_ne initial("001010111"b), /* go to opnd(1) if opnd(2) ^= opnd(3) */ 14 46 jump_if_le initial("001011000"b), /* go to opnd(1) if opnd(2) <= opnd(3) */ 14 47 jump_if_ge initial("001011001"b), /* go to opnd(1) if opnd(2) >= opnd(3) */ 14 48 14 49 std_arg_list initial("001100001"b), /* opnd(1) <- arglist(opnd(2) desclist(opnd(3))) */ 14 50 return_words initial("001100010"b), /* return aggregate opnd(1), opnd(2) is length in words */ 14 51 std_call initial("001100011"b), /* opnd(1) <- call opnd(2) with opnd(3) */ 14 52 return_bits initial("001100100"b), /* return aggregate opnd(1), opnd(2) is length in bits */ 14 53 std_entry initial("001100101"b), /* entry(opnd(1)... opnd(n)) */ 14 54 return_string initial("001100110"b), /* return string opnd(1) */ 14 55 ex_prologue initial("001100111"b), /* execute the prologue -no operands- */ 14 56 allot_auto initial("001101000"b), /* opnd(1) <- addrel(stack,opnd(2)) */ 14 57 param_ptr initial("001101001"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 14 58 param_desc_ptr initial("001101010"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 14 59 std_return initial("001101011"b), /* return -no arguments- */ 14 60 allot_ctl initial("001101100"b), /* allocate opnd(1) , length in words is opnd(2) */ 14 61 free_ctl initial("001101101"b), /* free opnd(1) */ 14 62 stop initial("001101110"b), /* stop - terminate run unit */ 14 63 14 64 mod_bit initial("001110000"b), /* opnd(1) <- mod(opnd(3),36), 14 65* opnd(2) <- opnd(3) / 36 */ 14 66 mod_byte initial("001110001"b), /* opnd(1) <- mod(opnd(3),4), 14 67* opnd(2) <- opnd(3) / 4 */ 14 68 mod_half initial("001110010"b), /* opnd(1) <- mod(opnd(3),2), 14 69* opnd(2) <- opnd(3) / 2 */ 14 70 mod_word initial("001110011"b), /* TO BE DEFINED BY BLW */ 14 71 14 72 bit_to_char initial("010000000"b), /* opnd(1) <- (opnd(2)+8)/9 */ 14 73 bit_to_word initial("010000001"b), /* opnd(1) <- (opnd(2)+35)/36 */ 14 74 char_to_word initial("010000010"b), /* opnd(1) <- (opnd(2)+3)/4 */ 14 75 half_to_word initial("010000011"b), /* opnd(1) <- (opnd(2)+1)/2 */ 14 76 word_to_mod2 initial("010000100"b), /* opnd(1) <- (opnd(2)+1)/2*2 */ 14 77 word_to_mod4 initial("010000101"b), /* opnd(1) <- (opnd(2)+3)/4*4 */ 14 78 word_to_mod8 initial("010000110"b), /* opnd(1) <- (opnd(2)+7)/8*8 */ 14 79 rel_fun initial("010000111"b), /* opnd(1) <- rel(opnd(2)) */ 14 80 baseno_fun initial("010001000"b), /* opnd(1) <- baseno(opnd(2)) */ 14 81 desc_size initial("010001001"b), /* opnd(1) <- substr(opnd(2),13,24) */ 14 82 bit_pointer initial("010001010"b), /* opnd(1) <- bit offset of opnd(2) */ 14 83 index_before_fun initial("010001011"b), /* opnd(1) <- length of before(opnd(2),opnd(3)) */ 14 84 index_after_fun initial("010001100"b), /* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */ 14 85 verify_ltrim_fun initial("010001101"b), /* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */ 14 86 verify_rtrim_fun initial("010001110"b), /* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */ 14 87 digit_to_bit initial("010001111"b), /* opnd(1) <- 9*opnd(2)/2 */ 14 88 14 89 ceil_fun initial("010010000"b), /* opnd(1) <- ceil(opnd(2)) */ 14 90 floor_fun initial("010010001"b), /* opnd(1) <- floor(opnd(2)) */ 14 91 round_fun initial("010010010"b), /* opnd(1) <- round(opnd(2)) */ 14 92 sign_fun initial("010010011"b), /* opnd(1) <- sign(opnd(2)) */ 14 93 abs_fun initial("010010100"b), /* opnd(1) <- abs(opnd(2)) */ 14 94 trunc_fun initial("010010101"b), /* opnd(1) <- trunc(opnd(2)) */ 14 95 byte_fun initial("010010110"b), /* opnd(1) <- byte(opnd(2)) */ 14 96 rank_fun initial("010010111"b), /* opnd(1) <- rank(opnd(2)) */ 14 97 index_rev_fun initial("010011000"b), /* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */ 14 98 search_rev_fun initial("010011001"b), /* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */ 14 99 verify_rev_fun initial("010011010"b), /* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */ 14 100 wordno_fun initial("010011011"b), /* opnd(1) <- wordno (opnd(2)) */ 14 101 segno_fun initial("010011100"b), /* opnd(1) <- segno (opnd(2)) */ 14 102 bitno_fun initial("010011101"b), /* opnd(1) <- bitno (opnd(2)) */ 14 103 charno_fun initial("010011110"b), /* opnd(1) <- charno (opnd(2)) */ 14 104 14 105 index_fun initial("010100000"b), /* opnd(1) <- index(opnd(2),opnd(3)) */ 14 106 off_fun initial("010100001"b), /* opnd(1) <- offset(opnd(2),opnd(3)) */ 14 107 complex_fun initial("010100010"b), /* opnd(1) <- complex(opnd(2),opnd(3)) */ 14 108 conjg_fun initial("010100011"b), /* opnd(1) <- conjg(opnd(2),opnd(3)) */ 14 109 mod_fun initial("010100100"b), /* opnd(1) <- mod(opnd(2),opnd(3)) */ 14 110 repeat_fun initial("010100101"b), /* opnd(1) <- repeat(opnd(2),opnd(3)) */ 14 111 verify_fun initial("010100110"b), /* opnd(1) <- verify(opnd(2),opnd(3)) */ 14 112 translate_fun initial("010100111"b), /* opnd(1) <- translate(opnd(2),opnd(3))*/ 14 113 real_fun initial("010101001"b), /* opnd(1) <- real(opnd(2)) */ 14 114 imag_fun initial("010101010"b), /* opnd(1) <- imag(opnd(2)) */ 14 115 length_fun initial("010101011"b), /* opnd(1) <- length(opnd(2)) */ 14 116 pl1_mod_fun initial("010101100"b), /* opnd(1) <- mod(opnd(2)) */ 14 117 search_fun initial("010101101"b), /* opnd(1) <- search(opnd(2),opnd(3)) */ 14 118 allocation_fun initial("010101110"b), /* opnd(1) <- allocation(opnd(2)) */ 14 119 reverse_fun initial("010101111"b), /* opnd(1) <- reverse(opnd(2)) */ 14 120 14 121 addr_fun initial("010110000"b), /* opnd(1) <- addr(opnd(2)) */ 14 122 addr_fun_bits initial("010110001"b), /* opnd(1) <- addr(opnd(2)) */ 14 123 ptr_fun initial("010110010"b), /* opnd(1) <- ptr(opnd(2),opnd(3)) */ 14 124 baseptr_fun initial("010110011"b), /* opnd(1) <- baseptr(opnd(2)) */ 14 125 addrel_fun initial("010110100"b), /* opnd(1) <- addrel(opnd(2),opnd(3)) */ 14 126 codeptr_fun initial("010110101"b), /* opnd(1) <- codeptr(opnd(2)) */ 14 127 environmentptr_fun initial("010110110"b), /* opnd(1) <- environmentptr(opnd(2)) */ 14 128 stackbaseptr_fun initial("010110111"b), /* opnd(1) is ptr to base of current stack */ 14 129 stackframeptr_fun initial("010111000"b), /* opnd(1) is ptr to current block's stack frame */ 14 130 setcharno_fun initial("010111001"b), /* opnd(1) <- opnd(2) with charno opnd(3) */ 14 131 addcharno_fun initial("010111010"b), /* opnd(1) <- opnd(2) with charno = charno + opnd(3) */ 14 132 setbitno_fun initial("010111011"b), /* setcharno for bitsno */ 14 133 addbitno_fun initial("010111100"b), /* addcharno for bitno */ 14 134 14 135 min_fun initial("011000000"b), /* opnd(1) <- min(opnd(1),opnd(2),...) */ 14 136 max_fun initial("011000001"b), /* opnd(1) <- max(opnd(1),opnd(2),...) */ 14 137 14 138 stack_ptr initial("011010001"b), /* opnd(1) <- stack frame ptr */ 14 139 empty_area initial("011010010"b), /* empty opnd(1), length in words is opnd(2) */ 14 140 enable_on initial("011010100"b), /* opnd(1) is the cond name 14 141* opnd(2) is the file name 14 142* opnd(3) is the block */ 14 143 revert_on initial("011010101"b), /* opnd(1) is the cond name, 14 144* opnd(2) is the file name */ 14 145 signal_on initial("011010110"b), /* opnd(1) is the cond name 14 146* opnd(2) is the file name */ 14 147 14 148 lock_fun initial("011010111"b), /* opnd(1) <- stac(opnd(2),opnd(3)) */ 14 149 stacq_fun initial("011011000"b), /* opnd(1) is result, opnd(2) is ptr to lock word, 14 150* opnd(3) is old value, (4) is new value. */ 14 151 clock_fun initial("011011001"b), /* opnd(1) is the clock time */ 14 152 vclock_fun initial("011011010"b), /* opnd(1) is the virtual clock time */ 14 153 14 154 bound_ck initial("011100000"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 14 155 range_ck initial("011100001"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 14 156 loop initial("011100010"b), /* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1, 14 157* opnd(5) is the list */ 14 158 join initial("011100011"b), /* do opnd(1), opnd(2) ... opnd(n) */ 14 159 allot_based initial("011100100"b), /* allocate opnd(2) words in opnd(3), set opnd(1) */ 14 160 free_based initial("011100101"b), /* free opnd(1) in opnd(3), length is opnd(2) words */ 14 161 14 162 r_parn initial("011110001"b), /* format op code */ 14 163 l_parn initial("011110010"b), 14 164 r_format initial("011110011"b), 14 165 c_format initial("011110100"b), 14 166 f_format initial("011110101"b), 14 167 e_format initial("011110110"b), 14 168 b_format initial("011110111"b), 14 169 a_format initial("011111000"b), 14 170 x_format initial("011111001"b), 14 171 skip_format initial("011111010"b), 14 172 column_format initial("011111011"b), 14 173 page_format initial("011111100"b), 14 174 line_format initial("011111101"b), 14 175 picture_format initial("011111110"b), 14 176 bn_format initial("011111111"b), /* bit format, length(opnd(2)), radix factor(opnd(3)) */ 14 177 14 178 get_list_trans initial("100000000"b), /* getlist(opnd(2) with desc(opnd(1))) */ 14 179 get_edit_trans initial("100000001"b), /* getedit(opnd(2) with desc(opnd(1))) */ 14 180 get_data_trans initial("100000010"b), /* getdata(opnd(1) to opnd(n)) */ 14 181 put_list_trans initial("100000011"b), /* putlist(opnd(2) with desc(opnd(1))) */ 14 182 put_edit_trans initial("100000100"b), /* putedit(opnd(2) with desc(opnd(1))) */ 14 183 put_data_trans initial("100000101"b), /* putdata(opnd(2)) with subscript-list opnd(1) */ 14 184 terminate_trans initial("100000110"b), /* terminate stream transmission */ 14 185 stream_prep initial("100000111"b), /* initiate stream transmission */ 14 186 record_io initial("100001000"b), /* perform record io operation */ 14 187 fortran_read initial("100001001"b), /* A complete read statement */ 14 188 fortran_write initial("100001010"b), /* A complete write statement */ 14 189 ftn_file_manip initial("100001011"b), /* endfile,backspace,rewind,etc. */ 14 190 ftn_trans_loop initial("100001100"b), /* An implied do in i/o list */ 14 191 put_control initial("100001101"b), /* put control opnd(1) opnd(2) times */ 14 192 put_field initial("100001110"b), /* putlist(opnd(2)) of length(opnd(1)) */ 14 193 put_field_chk initial("100001111"b), /* putlist(op(2)) of len(op(1)) check char index(op(3)) */ 14 194 14 195 /* These operators are produced by the parse but are not used as input to the code generator. */ 14 196 /* They are processed by the semantic translator. */ 14 197 14 198 return_value initial("100010010"b), /* return(opnd(1)) */ 14 199 allot_var initial("100010011"b), /* allot opnd(1) in opnd(2) */ 14 200 free_var initial("100010100"b), /* free opnd(1) out of opnd(2) */ 14 201 get_file initial("100010101"b), /* opnd(1) is filename,opnd(2) is copy */ 14 202 /* opnd(3) is skip, opnd(4) is list */ 14 203 get_string initial("100010110"b), /* opnd(1) is string,opnd(2) is list */ 14 204 put_file initial("100010111"b), /* opnd(1) is filename,opnd(2) is page */ 14 205 /* opnd(3) is skip,opnd(4) is line */ 14 206 put_string initial("100011000"b), /* opnd(1) is string,opnd(2) is list */ 14 207 open_file initial("100011001"b), 14 208 close_file initial("100011010"b), 14 209 read_file initial("100011011"b), 14 210 write_file initial("100011100"b), 14 211 locate_file initial("100011101"b), 14 212 do_fun initial("100011110"b), /* opnd(1) is join of a list */ 14 213 /* opnd(2) is control variable ref */ 14 214 /* opnd(3) is specification operator */ 14 215 do_spec initial("100011111"b), /* opnd(1) to opnd(2) by opnd(3) */ 14 216 /* repeat opnd(4) while opnd(5) */ 14 217 /* opnd(6) is next specification */ 14 218 14 219 rewrite_file initial("100100000"b), 14 220 delete_file initial("100100001"b), 14 221 unlock_file initial("100100010"b), 14 222 lock_file initial("100100011"b), 14 223 refer initial("100100101"b), /* opnd(1) refer(opnd(2)) */ 14 224 prefix_plus initial("100100110"b), /* opnd(1) <- +opnd(2) */ 14 225 nop initial("100100111"b), /* no-op */ 14 226 assign_by_name initial("100101000"b), /* opnd(1) <- opnd(2),by name */ 14 227 14 228 /* These operators are produced by the semantic translator in processing the math 14 229* builtin functions and are used as input to the code generator */ 14 230 14 231 sqrt_fun initial("100110000"b), /* opnd(1) <- sqrt(opnd(2)) */ 14 232 sin_fun initial("100110001"b), /* opnd(1) <- sin(opnd(2)) */ 14 233 sind_fun initial("100110010"b), /* opnd(1) <- sind(opnd(2)) */ 14 234 cos_fun initial("100110011"b), /* opnd(1) <- cos(opnd(2)) */ 14 235 cosd_fun initial("100110100"b), /* opnd(1) <- cosd(opnd(2)) */ 14 236 tan_fun initial("100110101"b), /* opnd(1) <- tan(opnd(2)) */ 14 237 tand_fun initial("100110110"b), /* opnd(1) <- tand(opnd(2)) */ 14 238 asin_fun initial("100110111"b), /* opnd(1) <- asin(opnd(2)) */ 14 239 asind_fun initial("100111000"b), /* opnd(1) <- asind(opnd(2)) */ 14 240 acos_fun initial("100111001"b), /* opnd(1) <- acos(opnd(2)) */ 14 241 acosd_fun initial("100111010"b), /* opnd(1) <- acosd(opnd(2)) */ 14 242 atan_fun initial("100111011"b), /* opnd(1) <- atan(opnd(2)[,opnd(3)]) */ 14 243 atand_fun initial("100111100"b), /* opnd(1) <- atand(opnd(2)[,opnd(3)]) */ 14 244 log2_fun initial("100111101"b), /* opnd(1) <- log2(opnd(2)) */ 14 245 log_fun initial("100111110"b), /* opnd(1) <- log(opnd(2)) */ 14 246 log10_fun initial("100111111"b), /* opnd(1) <- log10(opnd(2)) */ 14 247 14 248 exp_fun initial("101000000"b)) /* opnd(1) <- exp(opnd(2)) */ 14 249 14 250 bit(9) aligned internal static options(constant); 14 251 14 252 /* END INCLUDE FILE ... op_codes.incl.pl1 */ 38 15 1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */ 15 2 15 3 /* Modified: 2 Apr 1980 by PCK to add max_number_of_operands */ 15 4 15 5 /* format: style3 */ 15 6 dcl 1 operator based aligned, 15 7 2 node_type bit (9) unaligned, 15 8 2 op_code bit (9) unaligned, 15 9 2 shared bit (1) unaligned, 15 10 2 processed bit (1) unaligned, 15 11 2 optimized bit (1) unaligned, 15 12 2 number fixed (14) unaligned, 15 13 2 operand dimension (n refer (operator.number)) ptr unaligned; 15 14 15 15 dcl max_number_of_operands 15 16 fixed bin (15) int static options (constant) initial (32767); 15 17 15 18 /* END INCLUDE FILE ... operator.incl.pl1 */ 39 16 1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */ 16 2 16 3 dcl 1 reference based aligned, 16 4 2 node_type bit(9) unaligned, 16 5 2 array_ref bit(1) unaligned, 16 6 2 varying_ref bit(1) unaligned, 16 7 2 shared bit(1) unaligned, 16 8 2 put_data_sw bit(1) unaligned, 16 9 2 processed bit(1) unaligned, 16 10 2 units fixed(3) unaligned, 16 11 2 ref_count fixed(17) unaligned, 16 12 2 c_offset fixed(24), 16 13 2 c_length fixed(24), 16 14 2 symbol ptr unaligned, 16 15 2 qualifier ptr unaligned, 16 16 2 offset ptr unaligned, 16 17 2 length ptr unaligned, 16 18 2 subscript_list ptr unaligned, 16 19 /* these fields are used by the 645 code generator */ 16 20 2 address structure unaligned, 16 21 3 base bit(3), 16 22 3 offset bit(15), 16 23 3 op bit(9), 16 24 3 no_address bit(1), 16 25 3 inhibit bit(1), 16 26 3 ext_base bit(1), 16 27 3 tag bit(6), 16 28 2 info structure unaligned, 16 29 3 address_in structure, 16 30 4 b dimension(0:7) bit(1), 16 31 4 storage bit(1), 16 32 3 value_in structure, 16 33 4 a bit(1), 16 34 4 q bit(1), 16 35 4 aq bit(1), 16 36 4 string_aq bit(1), 16 37 4 complex_aq bit(1), 16 38 4 decimal_aq bit(1), 16 39 4 b dimension(0:7) bit(1), 16 40 4 storage bit(1), 16 41 4 indicators bit(1), 16 42 4 x dimension(0:7) bit(1), 16 43 3 other structure, 16 44 4 big_offset bit(1), 16 45 4 big_length bit(1), 16 46 4 modword_in_offset bit(1), 16 47 2 data_type fixed(5) unaligned, 16 48 2 bits structure unaligned, 16 49 3 padded_ref bit(1), 16 50 3 aligned_ref bit(1), 16 51 3 long_ref bit(1), 16 52 3 forward_ref bit(1), 16 53 3 ic_ref bit(1), 16 54 3 temp_ref bit(1), 16 55 3 defined_ref bit(1), 16 56 3 evaluated bit(1), 16 57 3 allocate bit(1), 16 58 3 allocated bit(1), 16 59 3 aliasable bit(1), 16 60 3 even bit(1), 16 61 3 perm_address bit(1), 16 62 3 aggregate bit(1), 16 63 3 hit_zero bit(1), 16 64 3 dont_save bit(1), 16 65 3 fo_in_qual bit(1), 16 66 3 hard_to_load bit(1), 16 67 2 relocation bit(12) unaligned, 16 68 2 more_bits structure unaligned, 16 69 3 substr bit(1), 16 70 3 padded_for_store_ref bit(1), 16 71 3 aligned_for_store_ref bit(1), 16 72 3 mbz bit(15), 16 73 2 store_ins bit(18) unaligned; 16 74 16 75 /* END INCLUDE FILE ... reference.incl.pl1 */ 40 17 1 /* *********************************************************** 17 2* * * 17 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 17 4* * * 17 5* *********************************************************** */ 17 6 /* BEGIN INCLUDE FILE ... statement.incl.pl1 */ 17 7 /* Internal interface of the PL/I compiler */ 17 8 17 9 dcl 1 statement based aligned, 17 10 2 node_type bit(9) unaligned, 17 11 2 source_id structure unaligned, 17 12 3 file_number bit(8), 17 13 3 line_number bit(14), 17 14 3 statement_number bit(5), 17 15 2 next ptr unaligned, 17 16 2 back ptr unaligned, 17 17 2 root ptr unaligned, 17 18 2 labels ptr unaligned, 17 19 2 reference_list ptr unaligned, 17 20 2 state_list ptr unaligned, 17 21 2 reference_count fixed(17) unaligned, 17 22 2 ref_count_copy fixed(17) unaligned, 17 23 2 object structure unaligned, 17 24 3 start fixed(17), 17 25 3 finish fixed(17), 17 26 2 source structure unaligned, 17 27 3 segment fixed(11), 17 28 3 start fixed(23), 17 29 3 length fixed(11), 17 30 2 prefix bit(12) unaligned, 17 31 2 optimized bit(1) unaligned, 17 32 2 free_temps bit(1) unaligned, 17 33 2 LHS_in_RHS bit(1) unaligned, 17 34 2 statement_type bit(9) unaligned, 17 35 2 bits structure unaligned, 17 36 3 processed bit(1) unaligned, 17 37 3 put_in_profile bit(1) unaligned, 17 38 3 generated bit(1) unaligned, 17 39 3 snap bit(1) unaligned, 17 40 3 system bit(1) unaligned, 17 41 3 irreducible bit(1) unaligned, 17 42 3 checked bit(1) unaligned, 17 43 3 save_temps bit(1) unaligned, 17 44 3 suppress_warnings bit(1) unaligned, 17 45 3 force_nonquick bit(1) unaligned, 17 46 3 expanded_by_name bit(1) unaligned, 17 47 3 begins_loop bit(1) unaligned, 17 48 3 pad bit(24) unaligned; 17 49 17 50 /* END INCLUDE FILE ... statement.incl.pl1 */ 41 18 1 /* statement types */ 18 2 18 3 dcl ( unknown_statement initial("000000000"b), 18 4 allocate_statement initial("000000001"b), 18 5 assignment_statement initial("000000010"b), 18 6 begin_statement initial("000000011"b), 18 7 call_statement initial("000000100"b), 18 8 close_statement initial("000000101"b), 18 9 declare_statement initial("000000110"b), 18 10 lock_statement initial("000000111"b), 18 11 delete_statement initial("000001000"b), 18 12 display_statement initial("000001001"b), 18 13 do_statement initial("000001010"b), 18 14 else_clause initial("000001011"b), 18 15 end_statement initial("000001100"b), 18 16 entry_statement initial("000001101"b), 18 17 exit_statement initial("000001110"b), 18 18 format_statement initial("000001111"b), 18 19 free_statement initial("000010000"b), 18 20 get_statement initial("000010001"b), 18 21 goto_statement initial("000010010"b), 18 22 if_statement initial("000010011"b), 18 23 locate_statement initial("000010100"b), 18 24 null_statement initial("000010101"b), 18 25 on_statement initial("000010110"b), 18 26 open_statement initial("000010111"b), 18 27 procedure_statement initial("000011000"b), 18 28 put_statement initial("000011001"b), 18 29 read_statement initial("000011010"b), 18 30 return_statement initial("000011011"b), 18 31 revert_statement initial("000011100"b), 18 32 rewrite_statement initial("000011101"b), 18 33 signal_statement initial("000011110"b), 18 34 stop_statement initial("000011111"b), 18 35 system_on_unit initial("000100000"b), 18 36 unlock_statement initial("000100001"b), 18 37 wait_statement initial("000100010"b), 18 38 write_statement initial("000100011"b), 18 39 default_statement initial("000100100"b), 18 40 continue_statement initial("000100101"b)) bit(9) internal static aligned options(constant); 42 19 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 19 2 19 3 dcl 1 symbol based aligned, 19 4 2 node_type bit(9) unal, 19 5 2 source_id structure unal, 19 6 3 file_number bit(8), 19 7 3 line_number bit(14), 19 8 3 statement_number bit(5), 19 9 2 location fixed(18) unal unsigned, 19 10 2 allocated bit(1) unal, 19 11 2 dcl_type bit(3) unal, 19 12 2 reserved bit(6) unal, 19 13 2 pix unal, 19 14 3 pic_fixed bit(1) unal, 19 15 3 pic_float bit(1) unal, 19 16 3 pic_char bit(1) unal, 19 17 3 pic_scale fixed(7) unal, 19 18 3 pic_size fixed(7) unal, 19 19 2 level fixed(8) unal, 19 20 2 boundary fixed(3) unal, 19 21 2 size_units fixed(3) unal, 19 22 2 scale fixed(7) unal, 19 23 2 runtime bit(18) unal, 19 24 2 runtime_offset bit(18) unal, 19 25 2 block_node ptr unal, 19 26 2 token ptr unal, 19 27 2 next ptr unal, 19 28 2 multi_use ptr unal, 19 29 2 cross_references ptr unal, 19 30 2 initial ptr unal, 19 31 2 array ptr unal, 19 32 2 descriptor ptr unal, 19 33 2 equivalence ptr unal, 19 34 2 reference ptr unal, 19 35 2 general ptr unal, 19 36 2 father ptr unal, 19 37 2 brother ptr unal, 19 38 2 son ptr unal, 19 39 2 word_size ptr unal, 19 40 2 bit_size ptr unal, 19 41 2 dcl_size ptr unal, 19 42 2 symtab_size ptr unal, 19 43 2 c_word_size fixed(24), 19 44 2 c_bit_size fixed(24), 19 45 2 c_dcl_size fixed(24), 19 46 19 47 2 attributes structure aligned, 19 48 3 data_type structure unal, 19 49 4 structure bit(1) , 19 50 4 fixed bit(1), 19 51 4 float bit(1), 19 52 4 bit bit(1), 19 53 4 char bit(1), 19 54 4 ptr bit(1), 19 55 4 offset bit(1), 19 56 4 area bit(1), 19 57 4 label bit(1), 19 58 4 entry bit(1), 19 59 4 file bit(1), 19 60 4 arg_descriptor bit(1), 19 61 4 storage_block bit(1), 19 62 4 explicit_packed bit(1), /* options(packed) */ 19 63 4 condition bit(1), 19 64 4 format bit(1), 19 65 4 builtin bit(1), 19 66 4 generic bit(1), 19 67 4 picture bit(1), 19 68 19 69 3 misc_attributes structure unal, 19 70 4 dimensioned bit(1), 19 71 4 initialed bit(1), 19 72 4 aligned bit(1), 19 73 4 unaligned bit(1), 19 74 4 signed bit(1), 19 75 4 unsigned bit(1), 19 76 4 precision bit(1), 19 77 4 varying bit(1), 19 78 4 local bit(1), 19 79 4 decimal bit(1), 19 80 4 binary bit(1), 19 81 4 real bit(1), 19 82 4 complex bit(1), 19 83 4 variable bit(1), 19 84 4 reducible bit(1), 19 85 4 irreducible bit(1), 19 86 4 returns bit(1), 19 87 4 position bit(1), 19 88 4 internal bit(1), 19 89 4 external bit(1), 19 90 4 like bit(1), 19 91 4 member bit(1), 19 92 4 non_varying bit(1), 19 93 4 options bit(1), 19 94 4 variable_arg_list bit(1), /* options(variable) */ 19 95 4 alloc_in_text bit(1), /* options(constant) */ 19 96 19 97 3 storage_class structure unal, 19 98 4 auto bit(1), 19 99 4 based bit(1), 19 100 4 static bit(1), 19 101 4 controlled bit(1), 19 102 4 defined bit(1), 19 103 4 parameter bit(1), 19 104 4 param_desc bit(1), 19 105 4 constant bit(1), 19 106 4 temporary bit(1), 19 107 4 return_value bit(1), 19 108 19 109 3 file_attributes structure unal, 19 110 4 print bit(1), 19 111 4 input bit(1), 19 112 4 output bit(1), 19 113 4 update bit(1), 19 114 4 stream bit(1), 19 115 4 reserved_1 bit(1), 19 116 4 record bit(1), 19 117 4 sequential bit(1), 19 118 4 direct bit(1), 19 119 4 interactive bit(1), /* env(interactive) */ 19 120 4 reserved_2 bit(1), 19 121 4 reserved_3 bit(1), 19 122 4 stringvalue bit(1), /* env(stringvalue) */ 19 123 4 keyed bit(1), 19 124 4 reserved_4 bit(1), 19 125 4 environment bit(1), 19 126 19 127 3 compiler_developed structure unal, 19 128 4 aliasable bit(1), 19 129 4 packed bit(1), 19 130 4 passed_as_arg bit(1), 19 131 4 allocate bit(1), 19 132 4 set bit(1), 19 133 4 exp_extents bit(1), 19 134 4 refer_extents bit(1), 19 135 4 star_extents bit(1), 19 136 4 isub bit(1), 19 137 4 put_in_symtab bit(1), 19 138 4 contiguous bit(1), 19 139 4 put_data bit(1), 19 140 4 overlayed bit(1), 19 141 4 error bit(1), 19 142 4 symtab_processed bit(1), 19 143 4 overlayed_by_builtin bit(1), 19 144 4 defaulted bit(1), 19 145 4 connected bit(1); 19 146 19 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 43 20 1 /* BEGIN INCLUDE FILE ... token.incl.pl1 */ 20 2 20 3 dcl 1 token based aligned, 20 4 2 node_type bit(9) unaligned, 20 5 2 type bit(9) unaligned, 20 6 2 loc bit(18) unaligned, /* symtab offset for identifiers, "p" flag for constants */ 20 7 2 declaration ptr unaligned, 20 8 2 next ptr unaligned, 20 9 2 size fixed(9), 20 10 2 string char(n refer(token.size)); 20 11 20 12 /* END INCLUDE FILE ... token.incl.pl1 */ 44 21 1 dcl pl1_stat_$token_list_ptr ptr external static; /* pointer to token list */ 21 2 dcl token_list(token_list_length) ptr based(token_list_pointer); 21 3 dcl token_list_pointer ptr initial(pl1_stat_$token_list_ptr); /* for efficiency only */ 21 4 dcl token_list_length fixed(15) internal static initial(3000) options(constant); 21 5 21 6 dcl 1 pl1_stat_$statement_id external static, 21 7 2 file_number bit(8), 21 8 2 line_number bit(14), 21 9 2 statement_number bit(5); 21 10 21 11 dcl 1 t_table based(token_list(k)) aligned, 21 12 2 node_type bit(9) unaligned, 21 13 2 type bit(9) unaligned, 21 14 2 loc bit(18) unaligned, 21 15 2 declaration ptr unaligned, 21 16 2 next ptr unaligned, 21 17 2 size fixed(9), 21 18 2 string char(n refer(t_table.size)); 45 22 1 /* BEGIN INCLUDE FILE ... token_types.incl.pl1 */ 22 2 22 3 dcl ( no_token initial("000000000"b), /* token types */ 22 4 identifier initial("100000000"b), 22 5 isub initial("010000000"b), 22 6 plus initial("001000001"b), 22 7 minus initial("001000010"b), 22 8 asterisk initial("001000011"b), 22 9 slash initial("001000100"b), 22 10 expon initial("001000101"b), 22 11 not initial("001000110"b), 22 12 and initial("001000111"b), 22 13 or initial("001001000"b), 22 14 cat initial("001001001"b), 22 15 eq initial("001001010"b), 22 16 ne initial("001001011"b), 22 17 lt initial("001001100"b), 22 18 gt initial("001001101"b), 22 19 le initial("001001110"b), 22 20 ge initial("001001111"b), 22 21 ngt initial("001010000"b), 22 22 nlt initial("001010001"b), 22 23 assignment initial("001010010"b), 22 24 colon initial("001010011"b), 22 25 semi_colon initial("001010100"b), 22 26 comma initial("001010101"b), 22 27 period initial("001010110"b), 22 28 arrow initial("001010111"b), 22 29 left_parn initial("001011000"b), 22 30 right_parn initial("001011001"b), 22 31 percent initial("001011100"b), 22 32 bit_string initial("000100001"b), 22 33 char_string initial("000100010"b), 22 34 bin_integer initial("000110001"b), 22 35 dec_integer initial("000110011"b), 22 36 fixed_bin initial("000110000"b), 22 37 fixed_dec initial("000110010"b), 22 38 float_bin initial("000110100"b), 22 39 float_dec initial("000110110"b), 22 40 i_bin_integer initial("000111001"b), 22 41 i_dec_integer initial("000111011"b), 22 42 i_fixed_bin initial("000111000"b), 22 43 i_fixed_dec initial("000111010"b), 22 44 i_float_bin initial("000111100"b), 22 45 i_float_dec initial("000111110"b)) bit (9) aligned internal static options (constant); 22 46 22 47 dcl ( is_identifier initial ("100000000"b), /* token type masks */ 22 48 is_isub initial ("010000000"b), 22 49 is_delimiter initial ("001000000"b), 22 50 is_constant initial ("000100000"b), 22 51 is_arith_constant initial ("000010000"b), /* N.B. not really a mask...s/b "000110000"b */ 22 52 is_arithmetic_constant initial ("000110000"b), 22 53 is_imaginary_constant initial ("000111000"b), 22 54 is_float_constant initial ("000110100"b), 22 55 is_decimal_constant initial ("000110010"b), 22 56 is_integral_constant initial ("000110001"b) 22 57 ) bit(9) internal static aligned options(constant); 22 58 22 59 /* END INCLUDE FILE ... token_types.incl.pl1 */ 46 23 1 dcl ( root_block initial("000000001"b), 23 2 external_procedure initial("000000010"b), 23 3 internal_procedure initial("000000011"b), 23 4 begin_block initial("000000100"b), 23 5 on_unit initial("000000101"b)) internal static bit(9) aligned options(constant); 47 48 49 /* */ 50 begin: 51 52 make_statement: 53 pl1_stat_$cur_statement , 54 stmnt=create_statement(bit(fixed(type,9),9),cblock,label_ptr,conditions); 55 if label_ptr^=null 56 then call declare_label(cblock,stmnt,label_ptr,by_explicit_context); 57 label_ptr=null; 58 go to action(action_index(type)); 59 60 action(0): /* unknown statement */ 61 return; /* print(400) not needed - statement_type has already complained */ 62 63 action(1): /* allocate statement */ 64 q,stmnt->statement.root=create_operator(allot_var,2); 65 k=k+1; 66 if t_table.type ^= identifier then call print(454); 67 q->operand(1)=token_list(k); 68 69 alloc_loop: 70 k=k+1; 71 if t_table.string = "set" 72 then do; 73 k=k+1; 74 if q->operand(1)->node.type^=token_node then call print(450); 75 if t_table.type ^= left_parn then call print(451); 76 k=k+1; 77 p = reference_parse(k,cblock); 78 if p = null then call print(454); 79 call context(p,cblock,pointer_context); 80 r = create_reference((q->operand(1))); 81 r->reference.qualifier = p; 82 q->operand(1) = r; 83 if t_table.type ^= right_parn then call print(454); 84 go to alloc_loop; 85 end; 86 if t_table.string ="in" 87 then do; 88 k=k+1; 89 if q->operand(2) ^= null then call print(452); 90 if t_table.type ^= left_parn then call print(453); 91 k=k+1; 92 q -> operand(2) = reference_parse(k,cblock); 93 if q -> operand(2) = null then call print(454); 94 call context((q->operand(2)),cblock,area_context); 95 if t_table.type ^= right_parn then call print(454); 96 go to alloc_loop; 97 end; 98 if t_table.type = comma then go to make_statement; 99 go to check_semi_colon; 100 101 action(2): /* assignment statement */ 102 p = reference_parse(k,cblock); 103 if p = null then call print(1); 104 n=n+1; 105 if n>128 then call print(5); 106 stack(n)=p; 107 if t_table.type = assignment then go to make_op; 108 if t_table.type ^= comma then call print(1); 109 k=k+1; 110 go to action(2); 111 112 make_op: 113 k=k+1; 114 p = expression_parse(k,cblock); 115 if p = null then call print(49); 116 if t_table.type = comma then go to make_assign_by_name; 117 stmnt->statement.root,q=create_operator(assign,2); 118 if n=1 then do; 119 q->operand(1)=stack(1); 120 q->operand(2)=p; 121 go to check_semi_colon; 122 end; 123 if p->node.type = token_node 124 then if p->token.type & is_constant 125 then do; 126 s = p; 127 q->operand(1) = stack(1); 128 q->operand(2) = s; 129 j = 2; 130 go to make_assignment; 131 end; 132 133 s = create_symbol(null,null,by_compiler); 134 s->symbol.temporary = "1"b; 135 s = s->symbol.reference; 136 s->reference.shared="0"b; 137 s->reference.ref_count = n+1; 138 q->operand(1) = s; 139 q->operand(2) = p; 140 j = 1; 141 142 make_assignment: 143 do i = j to n; 144 stmnt = create_statement(assignment_statement,cblock,null,conditions); 145 stmnt->statement.root, q = create_operator(assign,2); 146 stmnt->statement.generated = "1"b; /* to suppress the free_temps bit */ 147 q->operand(1) = stack(i); 148 q->operand(2) = s; 149 end; 150 go to check_semi_colon; 151 152 make_assign_by_name: 153 k=k+1; 154 if t_table.string ^= "by" 155 then call print(371); 156 k=k+1; 157 if t_table.string ^= "name" 158 then call print(371); 159 stmnt->statement.root,q=create_operator(assign_by_name,2); 160 q->operand(2) = p; 161 r = create_list(n); 162 do i=1 to n; 163 r -> list.element(i) = stack(i); 164 end; 165 q->operand(1) = r; 166 k=k+1; 167 go to check_semi_colon; 168 169 action(3): /* call statement */ 170 k=k+1; 171 stmnt -> statement.root = reference_parse(k,cblock); 172 if stmnt -> statement.root = null then call print(444); 173 q = stmnt->statement.root; 174 if q->node.type = token_node 175 then do; 176 q = create_reference(q); 177 q->reference.offset = create_list(0); 178 stmnt->statement.root = q; 179 end; 180 else if q->node.type = reference_node 181 then if q->reference.offset = null 182 then q->reference.offset = create_list(0); 183 go to check_semi_colon; 184 185 action(4): /* free statement */ 186 k=k+1; 187 q,stmnt->statement.root=create_operator(free_var,2); 188 q -> operand(1) = reference_parse(k,cblock); 189 if q -> operand(1) = null then call print(456); 190 if t_table.string = "in" 191 then do; 192 k=k+1; 193 if t_table.type ^= left_parn then call print(455); 194 k=k+1; 195 q -> operand(2) = reference_parse(k,cblock); 196 if q -> operand(2) = null then call print(456); 197 call context((q->operand(2)),cblock,area_context); 198 if t_table.type ^= right_parn then call print(456); 199 k=k+1; 200 end; 201 if t_table.type = comma then go to make_statement; 202 go to check_semi_colon; 203 204 action(5): /* go to statement */ 205 if t_table.string ="goto" 206 then k = k + 1; 207 else do; 208 k = k + 1; 209 if t_table.string ^= "to" then call print(446); /* syntax error in goto statement */ 210 k = k + 1; 211 end; 212 q,stmnt->statement.root=create_operator(jump,1); 213 q -> operand(1) = reference_parse(k,cblock); 214 if q -> operand(1) = null then call print(446); 215 go to check_semi_colon; 216 217 action(6): /* null statement */ 218 if stmnt->statement.labels^=null 219 then stmnt->statement.root = create_operator(nop,0); 220 go to check_semi_colon; 221 222 action(7): /* return statement */ 223 k=k+1; 224 if t_table.type = semi_colon 225 then do; 226 q,stmnt->statement.root=create_operator(std_return,0); 227 return; 228 end; 229 if t_table.type ^= left_parn then call print(447); 230 k=k+1; 231 q,stmnt->statement.root=create_operator(return_value,1); 232 q -> operand(1) = expression_parse(k,cblock); 233 if q -> operand(1) = null then call print(447); 234 if t_table.type ^= right_parn then call print(447); 235 k=k+1; 236 237 check_semi_colon: 238 if t_table.type^=semi_colon then call print(1); 239 return; 240 241 action(8): /* revert and signal statements */ 242 call on_parse$revert(k,stmnt,cblock); 243 if t_table.type = comma 244 then if type = fixed(revert_statement,15) /* revert statements may mention more than one */ 245 then go to make_statement; /* signal statements must have only one. */ 246 go to check_semi_colon; 247 248 action(9): /* singleton else clause */ 249 call print(150); 250 return; 251 252 action(10): /* unimplemented statements */ 253 call print(460); 254 return; 255 256 action(11): /* stop statement */ 257 k=k+1; 258 stmnt->statement.root=create_operator(stop,0); 259 go to check_semi_colon; 260 261 print: proc(m); 262 263 dcl m fixed bin(15); 264 265 call parse_error(m,null); 266 stmnt->statement.root=null; 267 stmnt->statement.statement_type=null_statement; 268 go to ret; 269 end; 270 271 ret: 272 end statement_parse; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/24/92 1101.4 statement_parse.pl1 >spec>install>MR12.5-1011>statement_parse.pl1 31 1 04/24/92 1056.9 parse.incl.pl1 >spec>install>MR12.5-1011>parse.incl.pl1 1-175 2 08/01/89 1339.9 language_utility.incl.pl1 >ldd>incl>language_utility.incl.pl1 2-307 3 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-325 4 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-335 5 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-374 6 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-386 7 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 32 8 08/13/81 2143.5 block.incl.pl1 >ldd>incl>block.incl.pl1 33 9 10/25/79 1745.8 declare_type.incl.pl1 >ldd>incl>declare_type.incl.pl1 34 10 05/03/76 1420.8 context_codes.incl.pl1 >ldd>incl>context_codes.incl.pl1 35 11 05/06/74 1842.1 label.incl.pl1 >ldd>incl>label.incl.pl1 36 12 08/13/81 2311.5 list.incl.pl1 >ldd>incl>list.incl.pl1 37 13 07/21/80 1646.3 nodes.incl.pl1 >ldd>incl>nodes.incl.pl1 38 14 04/07/83 1735.0 op_codes.incl.pl1 >ldd>incl>op_codes.incl.pl1 39 15 07/21/80 1646.3 operator.incl.pl1 >ldd>incl>operator.incl.pl1 40 16 07/21/80 1646.3 reference.incl.pl1 >ldd>incl>reference.incl.pl1 41 17 04/07/83 1735.0 statement.incl.pl1 >ldd>incl>statement.incl.pl1 42 18 05/03/76 1420.4 statement_types.incl.pl1 >ldd>incl>statement_types.incl.pl1 43 19 12/07/83 1801.7 symbol.incl.pl1 >ldd>incl>symbol.incl.pl1 44 20 09/14/77 1805.7 token.incl.pl1 >ldd>incl>token.incl.pl1 45 21 09/14/77 1805.7 token_list.incl.pl1 >ldd>incl>token_list.incl.pl1 46 22 11/30/78 1327.4 token_types.incl.pl1 >ldd>incl>token_types.incl.pl1 47 23 05/03/76 1420.8 block_types.incl.pl1 >ldd>incl>block_types.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. action_index 000032 constant fixed bin(15,0) initial array dcl 26 ref 58 allot_var 000020 constant bit(9) initial dcl 14-8 set ref 63* area_context 000026 constant fixed bin(15,0) initial dcl 10-1 set ref 94* 197* assign 000025 constant bit(9) initial dcl 14-8 set ref 117* 145* assign_by_name 000015 constant bit(9) initial dcl 14-8 set ref 159* assignment constant bit(9) initial dcl 22-3 ref 107 assignment_statement 000014 constant bit(9) initial dcl 18-3 set ref 144* attributes 31 based structure level 2 dcl 19-3 bit builtin function dcl 18 ref 50 50 bits 13 based structure level 2 packed packed unaligned dcl 17-9 by_compiler 000030 constant bit(3) initial dcl 9-5 set ref 133* by_explicit_context 000031 constant bit(3) initial dcl 9-5 set ref 55* cblock parameter pointer dcl 20 set ref 11 50* 55* 77* 79* 92* 94* 101* 114* 144* 171* 188* 195* 197* 213* 232* 241* comma constant bit(9) initial dcl 22-3 ref 98 108 116 201 243 conditions parameter bit(12) dcl 19 set ref 11 50* 144* context 000012 constant entry external dcl 1-17 ref 79 94 197 create_list 000024 constant entry external dcl 2-147 ref 161 177 180 create_operator 000026 constant entry external dcl 2-152 ref 63 117 145 159 187 212 217 226 231 258 create_reference 000030 constant entry external dcl 2-158 ref 80 176 create_statement 000032 constant entry external dcl 2-163 ref 50 144 create_symbol 000034 constant entry external dcl 2-184 ref 133 declare_label 000014 constant entry external dcl 1-29 ref 55 element 1 based pointer array level 2 packed packed unaligned dcl 12-6 set ref 163* expression_parse 000016 constant entry external dcl 1-73 ref 114 232 fixed builtin function dcl 18 ref 50 50 243 free_var 000017 constant bit(9) initial dcl 14-8 set ref 187* generated 13(02) based bit(1) level 3 packed packed unaligned dcl 17-9 set ref 146* i 000100 automatic fixed bin(15,0) dcl 17 set ref 142* 147* 162* 163 163* identifier constant bit(9) initial dcl 22-3 ref 66 is_constant constant bit(9) initial dcl 22-47 ref 123 j 000101 automatic fixed bin(15,0) dcl 17 set ref 129* 140* 142 jump 000024 constant bit(9) initial dcl 14-8 set ref 212* k parameter fixed bin(15,0) dcl 17 set ref 11 65* 65 66 67 69* 69 71 73* 73 75 76* 76 77* 83 86 88* 88 90 91* 91 92* 95 98 101* 107 108 109* 109 112* 112 114* 116 152* 152 154 156* 156 157 166* 166 169* 169 171* 185* 185 188* 190 192* 192 193 194* 194 195* 198 199* 199 201 204 204* 204 208* 208 209 210* 210 213* 222* 222 224 229 230* 230 232* 234 235* 235 237 241* 243 256* 256 label_ptr parameter pointer dcl 20 set ref 11 50* 55 55* 57* labels 4 based pointer level 2 packed packed unaligned dcl 17-9 ref 217 left_parn constant bit(9) initial dcl 22-3 ref 75 90 193 229 list based structure level 1 dcl 12-6 m parameter fixed bin(15,0) dcl 263 set ref 261 265* n 000102 automatic fixed bin(15,0) initial dcl 17 set ref 17* 104* 104 105 106 118 137 142 161* 162 node based structure level 1 dcl 13-27 nop 000016 constant bit(9) initial dcl 14-8 set ref 217* null builtin function dcl 18 ref 55 57 78 89 93 103 115 133 133 133 133 144 144 172 180 189 196 214 217 233 265 265 266 null_statement constant bit(9) initial dcl 18-3 ref 267 offset 5 based pointer level 2 packed packed unaligned dcl 16-3 set ref 177* 180 180* on_parse$revert 000020 constant entry external dcl 1-123 ref 241 operand 1 based pointer array level 2 packed packed unaligned dcl 15-6 set ref 67* 74 80 82* 89 92* 93 94 119* 120* 127* 128* 138* 139* 147* 148* 160* 165* 188* 189 195* 196 197 213* 214 232* 233 operator based structure level 1 dcl 15-6 p 000104 automatic pointer dcl 20 set ref 77* 78 79* 81 101* 103 106 114* 115 120 123 123 126 139 160 parse_error 000036 constant entry external dcl 2-364 ref 265 pl1_stat_$cur_statement 000010 external static pointer dcl 24 set ref 50* pl1_stat_$token_list_ptr 000040 external static pointer dcl 21-1 ref 21-3 pointer_context 000027 constant fixed bin(15,0) initial dcl 10-1 set ref 79* q 000106 automatic pointer dcl 20 set ref 63* 67 74 80 82 89 92 93 94 117* 119 120 127 128 138 139 145* 147 148 159* 160 165 173* 174 176* 176* 177 178 180 180 180 187* 188 189 195 196 197 212* 213 214 226* 231* 232 233 qualifier 4 based pointer level 2 packed packed unaligned dcl 16-3 set ref 81* r 000110 automatic pointer dcl 20 set ref 80* 81 82 161* 163 165 ref_count 0(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 16-3 set ref 137* reference 15 based pointer level 2 in structure "symbol" packed packed unaligned dcl 19-3 in procedure "statement_parse" ref 135 reference based structure level 1 dcl 16-3 in procedure "statement_parse" reference_node constant bit(9) initial dcl 13-5 ref 180 reference_parse 000022 constant entry external dcl 1-150 ref 77 92 101 171 188 195 213 return_value 000021 constant bit(9) initial dcl 14-8 set ref 231* revert_statement constant bit(9) initial dcl 18-3 ref 243 right_parn constant bit(9) initial dcl 22-3 ref 83 95 198 234 root 3 based pointer level 2 packed packed unaligned dcl 17-9 set ref 63* 117* 145* 159* 171* 172 173 178* 187* 212* 217* 226* 231* 258* 266* s 000112 automatic pointer dcl 20 set ref 126* 128 133* 134 135* 135 136 137 138 148 semi_colon constant bit(9) initial dcl 22-3 ref 224 237 shared 0(11) based bit(1) level 2 packed packed unaligned dcl 16-3 set ref 136* size 3 based fixed bin(9,0) level 2 dcl 21-11 ref 71 86 154 157 190 204 209 stack 000116 automatic pointer array dcl 21 set ref 106* 119 127 147 163 statement based structure level 1 dcl 17-9 statement_type 12(27) based bit(9) level 2 packed packed unaligned dcl 17-9 set ref 267* std_return 000023 constant bit(9) initial dcl 14-8 set ref 226* stmnt 000114 automatic pointer dcl 20 set ref 50* 55* 63 117 144* 145 146 159 171 172 173 178 187 212 217 217 226 231 241* 258 266 267 stop 000022 constant bit(9) initial dcl 14-8 set ref 258* storage_class 32(09) based structure level 3 packed packed unaligned dcl 19-3 string 4 based char level 2 dcl 21-11 ref 71 86 154 157 190 204 209 symbol based structure level 1 dcl 19-3 t_table based structure level 1 dcl 21-11 temporary 32(17) based bit(1) level 4 packed packed unaligned dcl 19-3 set ref 134* token based structure level 1 dcl 20-3 token_list based pointer array dcl 21-2 ref 66 67 71 75 83 86 90 95 98 107 108 116 154 157 190 193 198 201 204 209 224 229 234 237 243 token_list_pointer 000516 automatic pointer initial dcl 21-3 set ref 66 67 71 75 83 86 90 95 98 107 108 116 154 157 190 193 198 201 204 209 224 229 234 237 243 21-3* token_node constant bit(9) initial dcl 13-5 ref 74 123 174 type 0(09) based bit(9) level 2 in structure "token" packed packed unaligned dcl 20-3 in procedure "statement_parse" ref 123 type parameter fixed bin(15,0) dcl 17 in procedure "statement_parse" ref 11 50 50 58 243 type based bit(9) level 2 in structure "node" packed packed unaligned dcl 13-27 in procedure "statement_parse" ref 74 123 174 180 type 0(09) based bit(9) level 2 in structure "t_table" packed packed unaligned dcl 21-11 in procedure "statement_parse" ref 66 75 83 90 95 98 107 108 116 193 198 201 224 229 234 237 243 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. a_format internal static bit(9) initial dcl 14-8 abs_fun internal static bit(9) initial dcl 14-8 acos_fun internal static bit(9) initial dcl 14-8 acosd_fun internal static bit(9) initial dcl 14-8 add internal static bit(9) initial dcl 14-8 addbitno_fun internal static bit(9) initial dcl 14-8 addcharno_fun internal static bit(9) initial dcl 14-8 addr builtin function dcl 18 addr_fun internal static bit(9) initial dcl 14-8 addr_fun_bits internal static bit(9) initial dcl 14-8 addrel_fun internal static bit(9) initial dcl 14-8 adjust_count 000000 constant entry external dcl 2-20 allocate_statement internal static bit(9) initial dcl 18-3 allocation_fun internal static bit(9) initial dcl 14-8 allot_auto internal static bit(9) initial dcl 14-8 allot_based internal static bit(9) initial dcl 14-8 allot_ctl internal static bit(9) initial dcl 14-8 and internal static bit(9) initial dcl 22-3 and_bits internal static bit(9) initial dcl 14-8 array_node internal static bit(9) initial dcl 13-5 arrow internal static bit(9) initial dcl 22-3 asin_fun internal static bit(9) initial dcl 14-8 asind_fun internal static bit(9) initial dcl 14-8 assign_round internal static bit(9) initial dcl 14-8 assign_size_ck internal static bit(9) initial dcl 14-8 assign_zero internal static bit(9) initial dcl 14-8 asterisk internal static bit(9) initial dcl 22-3 atan_fun internal static bit(9) initial dcl 14-8 atand_fun internal static bit(9) initial dcl 14-8 attribute_parse 000000 constant entry external dcl 1-11 b_format internal static bit(9) initial dcl 14-8 baseno_fun internal static bit(9) initial dcl 14-8 baseptr_fun internal static bit(9) initial dcl 14-8 begin_block internal static bit(9) initial dcl 23-1 begin_statement internal static bit(9) initial dcl 18-3 bin_integer internal static bit(9) initial dcl 22-3 binary builtin function dcl 18 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 bit_pointer internal static bit(9) initial dcl 14-8 bit_string internal static bit(9) initial dcl 22-3 bit_to_char internal static bit(9) initial dcl 14-8 bit_to_word internal static bit(9) initial dcl 14-8 bitno_fun internal static bit(9) initial dcl 14-8 block based structure level 1 dcl 8-5 block_node internal static bit(9) initial dcl 13-5 bn_format internal static bit(9) initial dcl 14-8 bool_fun internal static bit(9) initial dcl 14-8 bound_ck internal static bit(9) initial dcl 14-8 bound_node internal static bit(9) initial dcl 13-5 by_context internal static bit(3) initial dcl 9-5 by_declare internal static bit(3) initial dcl 9-5 by_implication internal static bit(3) initial dcl 9-5 by_name_agg_node internal static bit(9) initial dcl 13-5 byte_fun internal static bit(9) initial dcl 14-8 c_format internal static bit(9) initial dcl 14-8 call_statement internal static bit(9) initial dcl 18-3 cat internal static bit(9) initial dcl 22-3 cat_string internal static bit(9) initial dcl 14-8 ceil_fun internal static bit(9) initial dcl 14-8 char_string internal static bit(9) initial dcl 22-3 char_to_word internal static bit(9) initial dcl 14-8 charno_fun internal static bit(9) initial dcl 14-8 clock_fun internal static bit(9) initial dcl 14-8 close_file internal static bit(9) initial dcl 14-8 close_statement internal static bit(9) initial dcl 18-3 codeptr_fun internal static bit(9) initial dcl 14-8 colon internal static bit(9) initial dcl 22-3 column_format internal static bit(9) initial dcl 14-8 compare_expression 000000 constant entry external dcl 2-48 complex_fun internal static bit(9) initial dcl 14-8 condition_context internal static fixed bin(15,0) initial dcl 10-1 conjg_fun internal static bit(9) initial dcl 14-8 constant_length 000000 constant entry external dcl 2-54 context_node internal static bit(9) initial dcl 13-5 continue_statement internal static bit(9) initial dcl 18-3 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_expression$copy_sons 000000 constant entry external dcl 2-99 copy_string internal static bit(9) initial dcl 14-8 copy_unique_expression 000000 constant entry external dcl 2-103 copy_words internal static bit(9) initial dcl 14-8 cos_fun internal static bit(9) initial dcl 14-8 cosd_fun internal static bit(9) initial dcl 14-8 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_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 13-5 data_list_parse 000000 constant entry external dcl 1-22 dec_integer internal static bit(9) initial dcl 22-3 decbin 000000 constant entry external dcl 2-206 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_parse 000000 constant entry external dcl 1-35 declare_parse$abort 000000 constant entry external dcl 1-40 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_statement internal static bit(9) initial dcl 18-3 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 13-5 default_parse 000000 constant entry external dcl 1-44 default_statement internal static bit(9) initial dcl 18-3 delete_file internal static bit(9) initial dcl 14-8 delete_statement internal static bit(9) initial dcl 18-3 desc_size internal static bit(9) initial dcl 14-8 descriptor_parse 000000 constant entry external dcl 1-49 digit_to_bit internal static bit(9) initial dcl 14-8 display_statement internal static bit(9) initial dcl 18-3 div internal static bit(9) initial dcl 14-8 do_fun internal static bit(9) initial dcl 14-8 do_parse 000000 constant entry external dcl 1-56 do_spec internal static bit(9) initial dcl 14-8 do_statement internal static bit(9) initial dcl 18-3 e_format internal static bit(9) initial dcl 14-8 else_clause internal static bit(9) initial dcl 18-3 empty_area internal static bit(9) initial dcl 14-8 enable_on internal static bit(9) initial dcl 14-8 end_statement internal static bit(9) initial dcl 18-3 entry_statement internal static bit(9) initial dcl 18-3 environmentptr_fun internal static bit(9) initial dcl 14-8 eq internal static bit(9) initial dcl 22-3 equal internal static bit(9) initial dcl 14-8 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 error_$no_text 000000 constant entry external dcl 2-334 evaluate 000000 constant entry external dcl 1-67 ex_prologue internal static bit(9) initial dcl 14-8 exit_statement internal static bit(9) initial dcl 18-3 exp internal static bit(9) initial dcl 14-8 exp_fun internal static bit(9) initial dcl 14-8 expon internal static bit(9) initial dcl 22-3 external_procedure internal static bit(9) initial dcl 23-1 f_format internal static bit(9) initial dcl 14-8 file_name_context internal static fixed bin(15,0) initial dcl 10-1 fixed_bin internal static bit(9) initial dcl 22-3 fixed_dec internal static bit(9) initial dcl 22-3 float_bin internal static bit(9) initial dcl 22-3 float_dec internal static bit(9) initial dcl 22-3 floor_fun internal static bit(9) initial dcl 14-8 format_list_parse 000000 constant entry external dcl 1-79 format_statement internal static bit(9) initial dcl 18-3 format_value_node internal static bit(9) initial dcl 13-5 fortran_read internal static bit(9) initial dcl 14-8 fortran_write internal static bit(9) initial dcl 14-8 free_based internal static bit(9) initial dcl 14-8 free_ctl internal static bit(9) initial dcl 14-8 free_node 000000 constant entry external dcl 2-345 free_statement internal static bit(9) initial dcl 18-3 ftn_file_manip internal static bit(9) initial dcl 14-8 ftn_trans_loop internal static bit(9) initial dcl 14-8 ge internal static bit(9) initial dcl 22-3 get_array_size 000000 constant entry external dcl 2-348 get_data_trans internal static bit(9) initial dcl 14-8 get_edit_trans internal static bit(9) initial dcl 14-8 get_file internal static bit(9) initial dcl 14-8 get_list_trans internal static bit(9) initial dcl 14-8 get_size 000000 constant entry external dcl 2-352 get_statement internal static bit(9) initial dcl 18-3 get_string internal static bit(9) initial dcl 14-8 goto_statement internal static bit(9) initial dcl 18-3 greater_or_equal internal static bit(9) initial dcl 14-8 greater_than internal static bit(9) initial dcl 14-8 gt internal static bit(9) initial dcl 22-3 half_to_word internal static bit(9) initial dcl 14-8 i_bin_integer internal static bit(9) initial dcl 22-3 i_dec_integer internal static bit(9) initial dcl 22-3 i_fixed_bin internal static bit(9) initial dcl 22-3 i_fixed_dec internal static bit(9) initial dcl 22-3 i_float_bin internal static bit(9) initial dcl 22-3 i_float_dec internal static bit(9) initial dcl 22-3 if_parse 000000 constant entry external dcl 1-87 if_statement internal static bit(9) initial dcl 18-3 imag_fun internal static bit(9) initial dcl 14-8 index_after_fun internal static bit(9) initial dcl 14-8 index_before_fun internal static bit(9) initial dcl 14-8 index_fun internal static bit(9) initial dcl 14-8 index_rev_fun internal static bit(9) initial dcl 14-8 internal_procedure internal static bit(9) initial dcl 23-1 io_statement_parse 000000 constant entry external dcl 1-96 is_arith_constant internal static bit(9) initial dcl 22-47 is_arithmetic_constant internal static bit(9) initial dcl 22-47 is_decimal_constant internal static bit(9) initial dcl 22-47 is_delimiter internal static bit(9) initial dcl 22-47 is_float_constant internal static bit(9) initial dcl 22-47 is_identifier internal static bit(9) initial dcl 22-47 is_imaginary_constant internal static bit(9) initial dcl 22-47 is_integral_constant internal static bit(9) initial dcl 22-47 is_isub internal static bit(9) initial dcl 22-47 isub internal static bit(9) initial dcl 22-3 join internal static bit(9) initial dcl 14-8 jump_false internal static bit(9) initial dcl 14-8 jump_if_eq internal static bit(9) initial dcl 14-8 jump_if_ge internal static bit(9) initial dcl 14-8 jump_if_gt internal static bit(9) initial dcl 14-8 jump_if_le internal static bit(9) initial dcl 14-8 jump_if_lt internal static bit(9) initial dcl 14-8 jump_if_ne internal static bit(9) initial dcl 14-8 jump_true internal static bit(9) initial dcl 14-8 l_parn internal static bit(9) initial dcl 14-8 label based structure level 1 dcl 11-1 label_array_element_node internal static bit(9) initial dcl 13-5 label_node internal static bit(9) initial dcl 13-5 le internal static bit(9) initial dcl 22-3 length_fun internal static bit(9) initial dcl 14-8 less_or_equal internal static bit(9) initial dcl 14-8 less_than internal static bit(9) initial dcl 14-8 lex 000000 constant entry external dcl 1-106 lex$initialize_lex 000000 constant entry external dcl 1-112 lex$write_last_line 000000 constant entry external dcl 1-109 libe_no automatic fixed bin(15,0) dcl 17 line_format internal static bit(9) initial dcl 14-8 list_node internal static bit(9) initial dcl 13-5 locate_file internal static bit(9) initial dcl 14-8 locate_statement internal static bit(9) initial dcl 18-3 lock_file internal static bit(9) initial dcl 14-8 lock_fun internal static bit(9) initial dcl 14-8 lock_statement internal static bit(9) initial dcl 18-3 log10_fun internal static bit(9) initial dcl 14-8 log2_fun internal static bit(9) initial dcl 14-8 log_fun internal static bit(9) initial dcl 14-8 loop internal static bit(9) initial dcl 14-8 lt internal static bit(9) initial dcl 22-3 machine_state_node internal static bit(9) initial dcl 13-5 make_desc internal static bit(9) initial dcl 14-8 max_block_number internal static fixed bin(17,0) initial dcl 8-74 max_fun internal static bit(9) initial dcl 14-8 max_list_elements internal static fixed bin(17,0) initial dcl 12-12 max_number_of_operands internal static fixed bin(15,0) initial dcl 15-15 merge_attributes 000000 constant entry external dcl 2-355 min_fun internal static bit(9) initial dcl 14-8 minus internal static bit(9) initial dcl 22-3 mod_bit internal static bit(9) initial dcl 14-8 mod_byte internal static bit(9) initial dcl 14-8 mod_fun internal static bit(9) initial dcl 14-8 mod_half internal static bit(9) initial dcl 14-8 mod_word internal static bit(9) initial dcl 14-8 mult internal static bit(9) initial dcl 14-8 ne internal static bit(9) initial dcl 22-3 negate internal static bit(9) initial dcl 14-8 ngt internal static bit(9) initial dcl 22-3 nlt internal static bit(9) initial dcl 22-3 no_token internal static bit(9) initial dcl 22-3 not internal static bit(9) initial dcl 22-3 not_bits internal static bit(9) initial dcl 14-8 not_equal internal static bit(9) initial dcl 14-8 off_fun internal static bit(9) initial dcl 14-8 on_parse 000000 constant entry external dcl 1-116 on_statement internal static bit(9) initial dcl 18-3 on_unit internal static bit(9) initial dcl 23-1 op_code automatic bit(9) dcl 22 open_file internal static bit(9) initial dcl 14-8 open_statement internal static bit(9) initial dcl 18-3 operator_node internal static bit(9) initial dcl 13-5 optimizer 000000 constant entry external dcl 2-361 or internal static bit(9) initial dcl 22-3 or_bits internal static bit(9) initial dcl 14-8 pack internal static bit(9) initial dcl 14-8 page_format internal static bit(9) initial dcl 14-8 param_desc_ptr internal static bit(9) initial dcl 14-8 param_ptr internal static bit(9) initial dcl 14-8 parameter_context internal static fixed bin(15,0) initial dcl 10-1 parse 000000 constant entry external dcl 1-128 parse_error$no_text 000000 constant entry external dcl 2-368 percent internal static bit(9) initial dcl 22-3 period internal static bit(9) initial dcl 22-3 picture_format internal static bit(9) initial dcl 14-8 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_mod_fun internal static bit(9) initial dcl 14-8 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 pl1_stat_$statement_id external static structure level 1 packed packed unaligned dcl 21-6 plus internal static bit(9) initial dcl 22-3 prefix_plus internal static bit(9) initial dcl 14-8 procedure_parse 000000 constant entry external dcl 1-133 procedure_statement internal static bit(9) initial dcl 18-3 process_entry 000000 constant entry external dcl 1-143 ptr_fun internal static bit(9) initial dcl 14-8 put_control internal static bit(9) initial dcl 14-8 put_data_trans internal static bit(9) initial dcl 14-8 put_edit_trans internal static bit(9) initial dcl 14-8 put_field internal static bit(9) initial dcl 14-8 put_field_chk internal static bit(9) initial dcl 14-8 put_file internal static bit(9) initial dcl 14-8 put_list_trans internal static bit(9) initial dcl 14-8 put_statement internal static bit(9) initial dcl 18-3 put_string internal static bit(9) initial dcl 14-8 r_format internal static bit(9) initial dcl 14-8 r_parn internal static bit(9) initial dcl 14-8 range_ck internal static bit(9) initial dcl 14-8 rank_fun internal static bit(9) initial dcl 14-8 read_file internal static bit(9) initial dcl 14-8 read_statement internal static bit(9) initial dcl 18-3 real_fun internal static bit(9) initial dcl 14-8 record_io internal static bit(9) initial dcl 14-8 refer internal static bit(9) initial dcl 14-8 refer_extent 000000 constant entry external dcl 2-426 rel_fun internal static bit(9) initial dcl 14-8 repeat_fun internal static bit(9) initial dcl 14-8 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 reserve$rename_parse 000000 constant entry external dcl 1-156 return_bits internal static bit(9) initial dcl 14-8 return_statement internal static bit(9) initial dcl 18-3 return_string internal static bit(9) initial dcl 14-8 return_words internal static bit(9) initial dcl 14-8 reverse_fun internal static bit(9) initial dcl 14-8 revert_on internal static bit(9) initial dcl 14-8 rewrite_file internal static bit(9) initial dcl 14-8 rewrite_statement internal static bit(9) initial dcl 18-3 root_block internal static bit(9) initial dcl 23-1 round_fun internal static bit(9) initial dcl 14-8 search_fun internal static bit(9) initial dcl 14-8 search_rev_fun internal static bit(9) initial dcl 14-8 segno_fun internal static bit(9) initial dcl 14-8 semantic_translator 000000 constant entry external dcl 2-444 semantic_translator$abort 000000 constant entry external dcl 2-446 semantic_translator$error 000000 constant entry external dcl 2-450 setbitno_fun internal static bit(9) initial dcl 14-8 setcharno_fun internal static bit(9) initial dcl 14-8 sf_par_node internal static bit(9) initial dcl 13-5 share_expression 000000 constant entry external dcl 2-454 sign_fun internal static bit(9) initial dcl 14-8 signal_on internal static bit(9) initial dcl 14-8 signal_statement internal static bit(9) initial dcl 18-3 sin_fun internal static bit(9) initial dcl 14-8 sind_fun internal static bit(9) initial dcl 14-8 skip_format internal static bit(9) initial dcl 14-8 slash internal static bit(9) initial dcl 22-3 source_node internal static bit(9) initial dcl 13-5 sqrt_fun internal static bit(9) initial dcl 14-8 stack_ptr internal static bit(9) initial dcl 14-8 stackbaseptr_fun internal static bit(9) initial dcl 14-8 stackframeptr_fun internal static bit(9) initial dcl 14-8 stacq_fun internal static bit(9) initial dcl 14-8 statement_node internal static bit(9) initial dcl 13-5 statement_parse 000000 constant entry external dcl 1-160 statement_type 000000 constant entry external dcl 1-167 std_arg_list internal static bit(9) initial dcl 14-8 std_call internal static bit(9) initial dcl 14-8 std_entry internal static bit(9) initial dcl 14-8 stop_statement internal static bit(9) initial dcl 18-3 stream_prep internal static bit(9) initial dcl 14-8 sub internal static bit(9) initial dcl 14-8 symbol_node internal static bit(9) initial dcl 13-5 system_on_unit internal static bit(9) initial dcl 18-3 tan_fun internal static bit(9) initial dcl 14-8 tand_fun internal static bit(9) initial dcl 14-8 temporary_node internal static bit(9) initial dcl 13-5 terminate_trans internal static bit(9) initial dcl 14-8 token_list_length internal static fixed bin(15,0) initial dcl 21-4 token_to_binary 000000 constant entry external dcl 2-459 translate_fun internal static bit(9) initial dcl 14-8 trunc_fun internal static bit(9) initial dcl 14-8 unknown_statement internal static bit(9) initial dcl 18-3 unlock_file internal static bit(9) initial dcl 14-8 unlock_statement internal static bit(9) initial dcl 18-3 unpack internal static bit(9) initial dcl 14-8 vclock_fun internal static bit(9) initial dcl 14-8 verify_fun internal static bit(9) initial dcl 14-8 verify_ltrim_fun internal static bit(9) initial dcl 14-8 verify_rev_fun internal static bit(9) initial dcl 14-8 verify_rtrim_fun internal static bit(9) initial dcl 14-8 wait_statement internal static bit(9) initial dcl 18-3 word_to_mod2 internal static bit(9) initial dcl 14-8 word_to_mod4 internal static bit(9) initial dcl 14-8 word_to_mod8 internal static bit(9) initial dcl 14-8 wordno_fun internal static bit(9) initial dcl 14-8 write_file internal static bit(9) initial dcl 14-8 write_statement internal static bit(9) initial dcl 18-3 x_format internal static bit(9) initial dcl 14-8 xor_bits internal static bit(9) initial dcl 14-8 NAMES DECLARED BY EXPLICIT CONTEXT. action 000000 constant label array(0:11) dcl 60 ref 58 110 alloc_loop 000263 constant label dcl 69 ref 84 96 begin 000134 constant label dcl 50 check_semi_colon 002003 constant label dcl 237 ref 99 121 150 167 183 202 215 220 246 259 make_assign_by_name 001100 constant label dcl 152 set ref 116 make_assignment 001012 constant label dcl 142 ref 130 make_op 000637 constant label dcl 112 ref 107 make_statement 000134 constant label dcl 50 ref 98 201 243 print 002106 constant entry internal dcl 261 ref 66 74 75 78 83 89 90 93 95 103 105 108 115 154 157 172 189 193 196 198 209 214 229 233 234 237 248 252 ret 002105 constant label dcl 271 ref 268 statement_parse 000123 constant entry external dcl 11 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2332 2374 2147 2342 Length 3224 2147 42 614 163 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME statement_parse 404 external procedure is an external procedure. print internal procedure shares stack frame of external procedure statement_parse. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME statement_parse 000100 i statement_parse 000101 j statement_parse 000102 n statement_parse 000104 p statement_parse 000106 q statement_parse 000110 r statement_parse 000112 s statement_parse 000114 stmnt statement_parse 000116 stack statement_parse 000516 token_list_pointer statement_parse THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. context create_list create_operator create_reference create_statement create_symbol declare_label expression_parse on_parse$revert parse_error reference_parse THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. pl1_stat_$cur_statement pl1_stat_$token_list_ptr LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000116 17 000130 21 3 000131 50 000134 55 000165 57 000206 58 000211 60 000214 63 000215 65 000236 66 000240 67 000254 69 000263 71 000265 73 000277 74 000300 75 000312 76 000327 77 000331 78 000344 79 000354 80 000370 81 000404 82 000407 83 000411 84 000426 86 000427 88 000433 89 000434 90 000444 91 000461 92 000463 93 000501 94 000510 95 000527 96 000544 98 000545 99 000552 101 000553 103 000567 104 000577 105 000600 106 000607 107 000613 108 000626 109 000634 110 000636 112 000637 114 000640 115 000653 116 000663 117 000675 118 000716 119 000721 120 000724 121 000726 123 000727 126 000740 127 000742 128 000745 129 000747 130 000751 133 000752 134 000772 135 000775 136 000777 137 001001 138 001004 139 001006 140 001010 142 001012 144 001021 145 001043 146 001064 147 001066 148 001073 149 001075 150 001077 152 001100 154 001101 156 001115 157 001117 159 001134 160 001155 161 001160 162 001171 163 001201 164 001205 165 001207 166 001212 167 001214 169 001215 171 001216 172 001234 173 001243 174 001246 176 001253 177 001263 178 001300 179 001302 180 001303 183 001325 185 001326 187 001327 188 001350 189 001367 190 001376 192 001410 193 001411 194 001424 195 001426 196 001444 197 001453 198 001472 199 001507 201 001511 202 001521 204 001522 208 001536 209 001537 210 001553 212 001555 213 001576 214 001615 215 001624 217 001625 220 001650 222 001651 224 001652 226 001664 227 001704 229 001705 230 001713 231 001715 232 001736 233 001755 234 001764 235 002001 237 002003 239 002020 241 002021 243 002034 246 002051 248 002052 250 002056 252 002057 254 002063 256 002064 258 002065 259 002104 271 002105 261 002106 265 002110 266 002123 267 002126 268 002130 ----------------------------------------------------------- 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