COMPILATION LISTING OF SEGMENT decode_runtime_value Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/12/86 1652.8 mst Wed Options: optimize map 1 /****^ ****************************************************** 2* * * 3* * Copyright (c) 1986 by Massachusetts Institute of * 4* * Technology and Honeywell Information Systems, Inc. * 5* * * 6* * Copyright (c) 1972 by Massachusetts Institute of * 7* * Technology and Honeywell Information Systems, Inc. * 8* * * 9* ****************************************************** */ 10 11 12 /****^ HISTORY COMMENTS: 13* 1) change(86-09-05,JMAthane), approve(86-09-05,MCR7525), 14* audit(86-09-11,Martinson), install(86-11-12,MR12.0-1212): 15* Fixed bug in code 16 value decoding. 16* END HISTORY COMMENTS */ 17 18 /* procedure to decode the values stored in a PL/1 symbol table */ 19 20 /* Modified: 8 December 1978 by RAB to fix PL/I bug 1790 (can't decode value from internal controlled desc) 21* Modified: 3 Mar 79 by James R. Davis MCR 3735, and overhaull for beauty and legality 22* Modified June 83 JMAthane to add decode_runtime_value_extended entry point 23* and code 16 interpretation. 24* Modified August 1983 W. Olin Sibert to use attempt_thunk 25* Modified June 86 JMAthane. fixed bug in code 16 decoding 26**/ 27 28 decode_runtime_value: proc (v, blk, sp, lp, tp, refp, code) returns (fixed bin (35)); 29 30 dcl v fixed bin (35), /* value to decode */ 31 blk ptr, /* ptr to runtime block node */ 32 sp ptr, /* stack frame pointer */ 33 lp ptr, /* linkage pointer */ 34 tp ptr, /* object pointer */ 35 refp ptr, /* based reference pointer */ 36 code fixed bin (35); /* completion code */ 37 dcl arg_list_arg_count fixed bin; /* used to be in include file */ 38 39 dcl attempt_thunk entry (fixed bin (35), pointer, pointer, pointer, fixed bin (35)) 40 returns (fixed bin (35)); 41 42 dcl 1 a_value aligned like encoded_value; 43 44 dcl (n, n1, n2, n3) fixed bin; /* values extracted from encode_value */ 45 dcl temp ptr; /* just a temp */ 46 dcl (addr, addrel, baseno, bin, fixed, hbound, null, ptr, stackbaseptr, string, substr, unspec) builtin; 47 dcl ptr_var ptr based; 48 dcl based_fixed_bin fixed bin based; 49 50 string (a_value) = unspec (v); /* convert to internal form */ 51 52 if (a_value.flag = "11"b) | (a_value.flag = "00"b) then do; 53 code = 0; 54 return (v); 55 end; 56 57 n = fixed (a_value.code, 4); 58 59 if n > 16 then go to fail; 60 61 go to join; 62 63 decode_runtime_value_extended: entry (v, blk, sp, lp, tp, refp, symb, code) returns (fixed bin (35)); 64 65 /* This entry assumes that the value IS encoded and that code is on 6 bits */ 66 67 dcl symb ptr; /* ptr to runtime symbol node */ 68 69 string (a_value) = unspec (v); 70 n = fixed (addr (a_value) -> pascal_encoded_value.code, 6); 71 72 join: 73 if n > hbound (sw, 1) 74 then do; 75 fail: code = 1; 76 return (0); 77 end; 78 79 n1 = fixed (a_value.n1, 6); 80 n2 = fixed (a_value.n2, 6); 81 n3 = fixed (a_value.n3, 18); 82 83 code = 0; 84 85 goto sw (n); 86 87 sw (0): /* automatic variable */ 88 return (addrel (get_stack_ptr (sp, n1), n3) -> based_fixed_bin); 89 90 sw (1): /* internal static variable */ 91 return (addrel (get_static_ptr (), n3) -> based_fixed_bin); 92 93 sw (2): /* external static */ 94 return (addrel (addrel (get_linkage_ptr (), n3) -> ptr_var, n1) -> based_fixed_bin); 95 96 sw (3): /* bit offset of reference pointer */ 97 begin; /* used by pre-EIS compilers only */ 98 dcl 1 an_its_ptr aligned like its; 99 if refp = null then goto fail; 100 string (an_its_ptr) = unspec (refp); 101 return (fixed (an_its_ptr.bit_offset, 6) + n3); 102 end; /* type 3 begin block */ 103 104 sw (4): /* based on automatic pointer */ 105 return (addrel (addrel (get_stack_ptr (sp, n1), n3) -> ptr_var, n2) -> based_fixed_bin); 106 107 sw (5): /* based on internal static pointer */ 108 return (addrel (addrel (get_static_ptr (), n3) -> ptr_var, n2) -> based_fixed_bin); 109 110 sw (6): /* based on external static pointer */ 111 return (addrel (addrel (addrel (get_linkage_ptr (), n3) -> ptr_var, n1) -> ptr_var, n2) -> based_fixed_bin); 112 113 sw (7): /* based on reference pointer (refer) */ 114 if refp = null then goto fail; 115 return (addrel (refp, n2) -> based_fixed_bin); 116 117 sw (8): /* value given by procedure (thunk) */ 118 return (attempt_thunk (v, blk, sp, refp, code)); /* Do the best we can */ 119 120 sw (9): /* value given by argument n2 of procedure */ 121 122 temp = get_arglist_ptr (sp, n1, ("0"b)); 123 if n2 > arg_list_arg_count then goto fail; 124 return (addrel (convert_ptr (temp -> arg_list.arg_ptrs (n2)), n3) -> based_fixed_bin); 125 126 sw (10): /* value based on argument n2 of procedure */ 127 temp = get_arglist_ptr (sp, n1, ("0"b)); 128 if n2 > arg_list_arg_count then goto fail; 129 return (addrel (convert_ptr (temp -> arg_list.arg_ptrs (n2)) -> ptr_var, n3) -> based_fixed_bin); 130 131 sw (11): /* value given by size field at offset n3 in descriptor n2 */ 132 temp = addrel (get_desc_ptr (sp, n1, n2), n3); 133 if temp -> arg_descriptor.flag 134 then return (temp -> arg_descriptor.size); /* version II arg descriptor */ 135 else return (fixed (substr (unspec (temp -> arg_descriptor.size), 7, 18), 18)); /* version I (kludge ) */ 136 137 sw (12): /* value given by field at offset n3 in descriptor of arg n2 of 138* block n1 steps along display chain */ 139 return (addrel (get_desc_ptr (sp, n1, n2), n3) -> based_fixed_bin); 140 141 142 143 sw (13): /* value given by size in descriptor of controlled variable */ 144 return (fixed (get_ctl_descriptor () -> arg_descriptor.size, 24)); 145 146 147 sw (14): /* value given by word ,offset from ctl dec */ 148 return (get_ctl_descriptor () -> based_fixed_bin); 149 150 151 sw (15): /* value given by word at offset n2 from ctl var */ 152 return (addrel (get_ctl_block_ptr () -> ctl_block.data, n2) -> based_fixed_bin); 153 154 155 sw (16): /* value given by corresponding symbol block, on n2 bits, signed if n1 =1 */ 156 157 begin; 158 dcl (symbol_ptr, block_ptr, loc) ptr; 159 dcl block_dcld_in entry (ptr) returns (ptr); 160 dcl display_count fixed bin; 161 dcl get_runtime_address entry (ptr, ptr, ptr, ptr, ptr, ptr, ptr) returns (ptr); 162 dcl value fixed bin (35); 163 dcl 1 signed_value based, 164 2 s bit (1) unal, 165 2 v bit (n2) unal; 166 dcl unsigned_value bit (n2) unal based; 167 dcl v_36b bit (36) based; 168 dcl this_sp ptr; 169 dcl this_block ptr; 170 dcl i fixed bin; 171 172 get_linkage_ptr: proc () returns (ptr); 173 174 /* The same as below, but returns null when faulty ptr */ 175 176 dcl ilp ptr unal; 177 178 if lp ^= null then return (lp); 179 else do; /* must find it ourselves */ 180 ilp = stackbaseptr () -> stack_header.lot_ptr -> lot.lp (fixed (baseno (get_text_ptr ()), 18)); 181 if faulty_ptr (ilp) then return (null); 182 return (ilp); 183 end; 184 end get_linkage_ptr; 185 symbol_ptr = addrel (symb, n3); 186 this_block = block_dcld_in (symbol_ptr); 187 block_ptr = blk; 188 display_count = 0; 189 do while (this_block ^= block_ptr); 190 block_ptr = runtime_symbol_info_$father (block_ptr); 191 if block_ptr = null then go to fail; 192 display_count = display_count + 1; 193 end; 194 this_sp = sp; 195 if sp ^= null then 196 do i = 1 to display_count; 197 this_sp = this_sp -> frame.display; 198 end; 199 loc = get_runtime_address (block_ptr, symbol_ptr, this_sp, get_linkage_ptr (), get_text_ptr (), null, null); 200 if loc = null then go to fail; 201 if n2 > 36 then go to fail; 202 if n1 > 1 then go to fail; 203 n2 = n2 - n1; 204 if n1 = 1 then 205 addr (value) -> v_36b = copy (loc -> signed_value.s, 36 - n2) || loc -> signed_value.v; 206 if n1 = 0 then 207 addr (value) -> v_36b = copy ("0"b, 36 - n2) || loc -> unsigned_value; 208 return (value); 209 end; 210 211 get_stack_ptr: proc (stack, display_ct) returns (ptr); 212 dcl stack ptr parameter; 213 dcl display_ct fixed bin parameter; 214 dcl q ptr; 215 dcl i fixed bin; 216 q = stack; 217 if q = null then goto fail; 218 219 do i = 1 to display_ct; 220 q = q -> frame.display; 221 end; 222 return (q); 223 end get_stack_ptr; 224 225 get_linkage_ptr: proc () returns (ptr); 226 227 /* global inputs lp */ 228 229 dcl ilp ptr unal; 230 231 if lp ^= null then return (lp); 232 else do; /* must find it ourselves */ 233 ilp = stackbaseptr () -> stack_header.lot_ptr -> lot.lp (fixed (baseno (get_text_ptr ()), 18)); 234 if faulty_ptr (ilp) then goto fail; 235 return (ilp); 236 end; 237 end get_linkage_ptr; 238 239 240 get_text_ptr: proc () returns (ptr); 241 242 /* global inputs: tp, sp, blk */ 243 if tp ^= null then return (tp); 244 if sp ^= null then return (sp -> frame.entry); 245 if blk ^= null then return (ptr (blk, 0)); 246 goto fail; 247 end get_text_ptr; 248 249 250 get_static_ptr: proc () returns (ptr); 251 dcl isp ptr unal; 252 253 isp = stackbaseptr () -> stack_header.isot_ptr -> isot.isp (fixed (baseno (get_text_ptr ()), 18)); 254 if faulty_ptr (isp) then goto fail; 255 return (isp); 256 end get_static_ptr; 257 258 259 get_arglist_ptr: proc (stack, display_ct, quick) returns (ptr); 260 dcl stack ptr parameter; 261 dcl display_ct fixed bin parameter; 262 dcl quick bit (1) aligned parameter; /* (output) caller: pass me ("0"b) if you don't care */ 263 dcl q ptr; 264 q = get_stack_ptr (stack, display_ct); 265 quick = "0"b; 266 267 if blk = null 268 then q = q -> frame.argptr; 269 else if blk -> runtime_block.quick 270 then do; 271 quick = "1"b; 272 if blk -> runtime_block.entry_info = "0"b then goto fail; 273 q = (addrel (q, blk -> runtime_block.entry_info) -> quick_entry.argptr); 274 end; 275 else q = q -> frame.argptr; 276 277 arg_list_arg_count = q -> arg_list.arg_count; /* set globally for our callers */ 278 return (q); 279 end get_arglist_ptr; 280 281 282 283 get_desc_ptr: proc (stack, display_ct, narg) returns (ptr); 284 dcl stack ptr parameter; 285 dcl display_ct fixed bin parameter; 286 dcl narg fixed bin parameter; 287 dcl quick bit (1) aligned; 288 dcl q ptr; 289 290 q = get_arglist_ptr (stack, display_ct, quick); 291 292 if ^quick /* don't know why, but ignore for quick */ 293 then if q -> arg_list.header.desc_count < narg then goto fail; 294 295 if q -> arg_list.header.call_type = Envptr_supplied_call_type 296 then return (convert_ptr (q -> arg_list_with_envptr.desc_ptrs (narg))); 297 else return (convert_ptr (q -> arg_list.desc_ptrs (narg))); 298 end get_desc_ptr; 299 300 301 302 get_ctl_block_ptr: proc () returns (ptr); 303 304 /* returns ptr to the controlled variable control block - 305* GLOBAL input n1 (0 for internal, 1 for external) 306* n3 offset in linkage or static of the ctl block */ 307 if n1 = 0 308 then return (addrel (get_static_ptr (), n3)); 309 else return (addrel (get_linkage_ptr (), n3) -> ptr_var); 310 end get_ctl_block_ptr; 311 312 get_ctl_descriptor: proc () returns (ptr); 313 314 /* Il Kludge: due to bug in PL/I, for internal controlled encoding 315* where the descriptor is desired (Type 13 and 14)(NOT 15!!) 316* n3 is the offset in the static section of the descriptor ptr itself, not the ctl block 317* n2 is offset from descriptor of the field wanted 318* n1 is 0 for internal, 1 for external */ 319 320 dcl dp ptr; 321 if n1 = 0 322 then dp = addrel (get_static_ptr (), n3) -> ptr_var; /* pt to descriptor */ 323 else dp = addrel (get_linkage_ptr (), n3) -> ptr_var -> ctl_block.descriptor; 324 return (addrel (dp, n2)); /* offset from the descriptor */ 325 end get_ctl_descriptor; 326 327 328 329 convert_ptr: proc (P_ptr) returns (ptr); 330 331 /* given a ptr, which may be an ITS, ITP, or text embedded ptr, convert to ITS so we can use it 332* For certain constructs, clever ptrs like ITP are used, and these can be eval'd only by knowing 333* the value of a users pointer reg. */ 334 335 dcl P_ptr ptr parameter; 336 dcl 1 an_itp_ptr aligned like itp; 337 dcl reg fixed bin; 338 dcl basep ptr; 339 dcl 1 text_embedded_ptr aligned, 340 2 offset bit (18) unal, 341 2 pad bit (18) unal; 342 dcl (string, unspec) builtin; 343 344 string (an_itp_ptr) = unspec (P_ptr); 345 346 if an_itp_ptr.itp_mod = "43"b3 /* ITS */ 347 then return (P_ptr); 348 349 if an_itp_ptr.itp_mod = "00"b3 /* text relative to base of seg */ 350 then do; 351 string (text_embedded_ptr) = unspec (P_ptr); 352 return (ptr (get_text_ptr (), text_embedded_ptr.offset)); 353 end; 354 355 if an_itp_ptr.itp_mod = "41"b3 /* ITP */ 356 then do; 357 reg = bin (an_itp_ptr.pr_no, 3); 358 if reg = 6 then basep = sp; 359 else if reg = 4 then basep = get_static_ptr (); 360 else goto fail; 361 return (bitrel (addrel (basep, an_itp_ptr.offset), bin (an_itp_ptr.bit_offset, 6))); 362 end; /* ITP */ 363 364 goto fail; /* fell through -no of the above */ 365 366 367 end convert_ptr; 368 369 bitrel: proc (P_ptr, P_bit_offset) returns (ptr); 370 dcl P_ptr ptr parameter; 371 dcl P_bit_offset fixed bin (24) parameter; 372 373 dcl 1 str aligned based (P_ptr), 374 2 filler unal bit (P_bit_offset), 375 2 target unal bit (1); 376 377 if P_bit_offset < 0 then goto fail; 378 return (addr (str.target)); 379 end bitrel; 380 381 faulty_ptr: proc (P_unal_ptr) returns (bit (1) aligned); 382 dcl P_unal_ptr ptr unal parameter; 383 dcl baseno builtin; 384 return (baseno (P_unal_ptr) = "0"b); 385 end faulty_ptr; 386 1 1 dcl 1 frame aligned based, 1 2 2 pointers(0:7) ptr, 1 3 2 back ptr, 1 4 2 next ptr, 1 5 2 return ptr, 1 6 2 entry ptr, 1 7 2 operator ptr, 1 8 2 argptr ptr, 1 9 2 skip1(2) fixed bin, 1 10 2 on_unit_info(2) bit(18) unaligned, 1 11 2 translator_id bit(18) unaligned, 1 12 2 operator_return bit(18) unaligned, 1 13 2 display ptr, 1 14 2 skip2(2) fixed bin, 1 15 2 linkage ptr; 387 388 2 1 /* BEGIN INCLUDE FILE ... runtime_symbol.incl.pl1 ... Modified 07/79 */ 2 2 2 3 dcl 1 runtime_symbol aligned based, 2 4 2 flag unal bit(1), /* always "1"b for Version II */ 2 5 2 use_digit unal bit(1), /* if "1"b and units are half words units are really digits */ 2 6 2 array_units unal bit(2), 2 7 2 units unal bit(2), /* addressing units */ 2 8 2 type unal bit(6), /* data type */ 2 9 2 level unal bit(6), /* structure level */ 2 10 2 ndims unal bit(6), /* number of dimensions */ 2 11 2 bits unal, 2 12 3 aligned bit(1), 2 13 3 packed bit(1), 2 14 3 simple bit(1), 2 15 2 skip unal bit(1), 2 16 2 scale unal bit(8), /* arithmetic scale factor */ 2 17 2 name unal bit(18), /* rel ptr to acc name */ 2 18 2 brother unal bit(18), /* rel ptr to brother entry */ 2 19 2 father unal bit(18), /* rel ptr to father entry */ 2 20 2 son unal bit(18), /* rel ptr to son entry */ 2 21 2 address unal, 2 22 3 location bit(18), /* location in storage class */ 2 23 3 class bit(4), /* storage class */ 2 24 3 next bit(14), /* rel ptr to next of same class */ 2 25 2 size fixed bin(35), /* encoded string|arith size */ 2 26 2 offset fixed bin(35), /* encoded offset from address */ 2 27 2 virtual_org fixed bin(35), 2 28 2 bounds(1), 2 29 3 lower fixed bin(35), /* encoded lower bound */ 2 30 3 upper fixed bin(35), /* encoded upper bound */ 2 31 3 multiplier fixed bin(35); /* encoded multiplier */ 2 32 2 33 dcl 1 runtime_bound based, 2 34 2 lower fixed bin(35), 2 35 2 upper fixed bin(35), 2 36 2 multiplier fixed bin(35); 2 37 2 38 dcl 1 runtime_block aligned based, 2 39 2 flag unal bit(1), /* always "1"b for Version II */ 2 40 2 quick unal bit(1), /* "1"b if quick block */ 2 41 2 fortran unal bit(1), /* "1"b if fortran program */ 2 42 2 standard unal bit(1), /* "1"b if program has std obj segment */ 2 43 2 owner_flag unal bit(1), /* "1"b if block has valid owner field */ 2 44 2 skip unal bit(1), 2 45 2 type unal bit(6), /* = 0 for a block node */ 2 46 2 number unal bit(6), /* begin block number */ 2 47 2 start unal bit(18), /* rel ptr to start of symbols */ 2 48 2 name unal bit(18), /* rel ptr to name of proc */ 2 49 2 brother unal bit(18), /* rel ptr to brother block */ 2 50 2 father unal bit(18), /* rel ptr to father block */ 2 51 2 son unal bit(18), /* rel ptr to son block */ 2 52 2 map unal, 2 53 3 first bit(18), /* rel ptr to first word of map */ 2 54 3 last bit(18), /* rel ptr to last word of map */ 2 55 2 entry_info unal bit(18), /* info about entry of quick block */ 2 56 2 header unal bit(18), /* rel ptr to symbol header */ 2 57 2 chain(4) unal bit(18), /* chain(i) is rel ptr to first symbol 2 58* on start list with length >= 2**i */ 2 59 2 token(0:5) unal bit(18), /* token(i) is rel ptr to first token 2 60* on list with length >= 2 ** i */ 2 61 2 owner unal bit(18); /* rel ptr to owner block */ 2 62 2 63 dcl 1 runtime_token aligned based, 2 64 2 next unal bit(18), /* rel ptr to next token */ 2 65 2 dcl unal bit(18), /* rel ptr to first dcl of this token */ 2 66 2 name, /* ACC */ 2 67 3 size unal unsigned fixed bin (9), /* number of chars in token */ 2 68 3 string unal char(n refer(runtime_token.size)); 2 69 2 70 dcl 1 encoded_value aligned based, 2 71 2 flag bit (2) unal, 2 72 2 code bit (4) unal, 2 73 2 n1 bit (6) unal, 2 74 2 n2 bit (6) unal, 2 75 2 n3 bit (18) unal; 2 76 2 77 /* END INCLUDE FILE ... runtime_symbol.incl.pl1 */ 389 390 3 1 dcl 1 quick_entry aligned based, 3 2 2 return ptr, 3 3 2 argptr ptr, 3 4 2 descptr ptr; 391 392 4 1 dcl 1 ctl_block aligned based, 4 2 2 data ptr, 4 3 2 descriptor ptr, 4 4 2 previous ptr; 393 394 5 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 5 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 5 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 5 4 /* Modified April 1983 by C. Hornig for tasking */ 5 5 5 6 /****^ HISTORY COMMENTS: 5 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 5 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 5 9* added the heap_header_ptr definition. 5 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 5 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 5 12* Modified to support control point management. These changes were actually 5 13* made in February 1985 by G. Palter. 5 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 5 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 5 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 5 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 5 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 5 19* (ITS pair). 5 20* END HISTORY COMMENTS */ 5 21 5 22 /* format: style2 */ 5 23 5 24 dcl sb ptr; /* the main pointer to the stack header */ 5 25 5 26 dcl 1 stack_header based (sb) aligned, 5 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 5 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 5 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 5 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 5 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 5 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 5 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 5 34 2 pad4 bit (2) unal, 5 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 5 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 5 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 5 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 5 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 5 40 2 null_ptr ptr, /* (16) */ 5 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 5 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 5 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 5 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 5 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 5 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 5 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 5 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 5 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 5 50 2 return_no_pop_op_ptr 5 51 ptr, /* (36) pointer to standard return / no pop operator */ 5 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 5 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 5 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 5 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 5 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 5 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 5 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 5 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 5 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 5 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 5 62 2 trace, 5 63 3 frames, 5 64 4 count fixed bin, /* (58) number of trace frames */ 5 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 5 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 5 67 2 pad2 bit (36), /* (61) */ 5 68 2 pad5 pointer; /* (62) pointer to future stuff */ 5 69 5 70 /* The following offset refers to a table within the pl1 operator table. */ 5 71 5 72 dcl tv_offset fixed bin init (361) internal static; 5 73 /* (551) octal */ 5 74 5 75 5 76 /* The following constants are offsets within this transfer vector table. */ 5 77 5 78 dcl ( 5 79 call_offset fixed bin init (271), 5 80 push_offset fixed bin init (272), 5 81 return_offset fixed bin init (273), 5 82 return_no_pop_offset fixed bin init (274), 5 83 entry_offset fixed bin init (275) 5 84 ) internal static; 5 85 5 86 5 87 5 88 5 89 5 90 /* The following declaration is an overlay of the whole stack header. Procedures which 5 91* move the whole stack header should use this overlay. 5 92**/ 5 93 5 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 5 95 5 96 5 97 5 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 395 396 6 1 /* BEGIN INCLUDE FILE -- lot.incl.pl1 S.Webber 9/74, Modified by R. Bratt 04/76, modified by M. Weaver 7/76 */ 6 2 /* modified by M. Weaver 3/77 */ 6 3 6 4 dcl lotp ptr; 6 5 6 6 dcl 1 lot based (lotp) aligned, 6 7 2 lp (0:9999) ptr unaligned; /* array of packed pointers to linkage sections */ 6 8 6 9 dcl lot_fault bit (36) aligned static options (constant) init ("111000000000000000000000000000000000"b); 6 10 /* lot fault has fault code = 0 and offset = 0 */ 6 11 6 12 dcl isotp ptr; 6 13 dcl 1 isot based (isotp) aligned, 6 14 2 isp (0:9999) ptr unaligned; 6 15 6 16 dcl 1 isot1 (0 :9999) aligned based, 6 17 2 flags unaligned, 6 18 3 fault bit (2) unaligned, 6 19 3 system bit (1) unaligned, 6 20 3 mbz bit (6) unaligned, 6 21 2 fault_code fixed bin (8) unaligned, 6 22 2 static_offset bit (18) unaligned; 6 23 6 24 6 25 /* END INCLUDE FILE lot.incl.pl1 */ 397 398 7 1 /* BEGIN INCLUDE FILE its.incl.pl1 7 2* modified 27 July 79 by JRDavis to add its_unsigned 7 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 7 4 7 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 7 6 2 pad1 bit (3) unaligned, 7 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 7 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 7 9 2 pad2 bit (9) unaligned, 7 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 7 11 7 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 7 13 2 pad3 bit (3) unaligned, 7 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 7 15 2 pad4 bit (3) unaligned, 7 16 2 mod bit (6) unaligned; /* further modification */ 7 17 7 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 7 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 7 20 2 pad1 bit (27) unaligned, 7 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 7 22 7 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 7 24 2 pad2 bit (3) unaligned, 7 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 7 26 2 pad3 bit (3) unaligned, 7 27 2 mod bit (6) unaligned; /* further modification */ 7 28 7 29 7 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 7 31 2 pad1 bit (3) unaligned, 7 32 2 segno fixed bin (15) unsigned unaligned, 7 33 2 ringno fixed bin (3) unsigned unaligned, 7 34 2 pad2 bit (9) unaligned, 7 35 2 its_mod bit (6) unaligned, 7 36 7 37 2 offset fixed bin (18) unsigned unaligned, 7 38 2 pad3 bit (3) unaligned, 7 39 2 bit_offset fixed bin (6) unsigned unaligned, 7 40 2 pad4 bit (3) unaligned, 7 41 2 mod bit (6) unaligned; 7 42 7 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 7 44 2 pr_no fixed bin (3) unsigned unaligned, 7 45 2 pad1 bit (27) unaligned, 7 46 2 itp_mod bit (6) unaligned, 7 47 7 48 2 offset fixed bin (18) unsigned unaligned, 7 49 2 pad2 bit (3) unaligned, 7 50 2 bit_offset fixed bin (6) unsigned unaligned, 7 51 2 pad3 bit (3) unaligned, 7 52 2 mod bit (6) unaligned; 7 53 7 54 7 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 7 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 7 57 7 58 /* END INCLUDE FILE its.incl.pl1 */ 399 400 8 1 /* BEGIN INCLUDE FILE ... arg_descriptor.incl.pl1 8 2* 8 3* James R. Davis 1 Mar 79 */ 8 4 /* Modified June 83 JMAthane for extended arg descriptor format */ 8 5 8 6 dcl 1 arg_descriptor based (arg_descriptor_ptr) aligned, 8 7 2 flag bit (1) unal, 8 8 2 type fixed bin (6) unsigned unal, 8 9 2 packed bit (1) unal, 8 10 2 number_dims fixed bin (4) unsigned unal, 8 11 2 size fixed bin (24) unsigned unal; 8 12 8 13 dcl 1 fixed_arg_descriptor based (arg_descriptor_ptr) aligned, 8 14 2 flag bit (1) unal, 8 15 2 type fixed bin (6) unsigned unal, 8 16 2 packed bit (1) unal, 8 17 2 number_dims fixed bin (4) unsigned unal, 8 18 2 scale fixed bin (11) unal, 8 19 2 precision fixed bin (12) unsigned unal; 8 20 8 21 dcl 1 extended_arg_descriptor based (arg_descriptor_ptr) aligned, 8 22 2 flag bit (1) unal, /* = "1"b */ 8 23 2 type fixed bin (6) unsigned unal, /* = 58 */ 8 24 2 packed bit (1) unal, /* significant if number_dims ^= 0 */ 8 25 2 number_dims fixed (4) unsigned unal,/* number of variable dimensions */ 8 26 2 size bit (24) unal, 8 27 2 dims (0 refer (extended_arg_descriptor.number_dims)), /* part referenced by called generated code */ 8 28 3 low fixed bin (35), 8 29 3 high fixed bin (35), 8 30 3 multiplier fixed bin (35), /* in bits if packed, in words if not */ 8 31 2 real_type fixed bin (18) unsigned unal, 8 32 2 type_offset fixed bin (18) unsigned unal; /* offset rel to symbol tree to symbol node for type, if any */ 8 33 8 34 dcl arg_descriptor_ptr ptr; 8 35 8 36 dcl extended_arg_type fixed bin init (58); 8 37 8 38 /* END INCLUDE file .... arg_descriptor.incl.pl1 */ 401 402 9 1 /* BEGIN INCLUDE FILE ... arg_list.incl.pl1 9 2* 9 3* James R. Davis 10 May 79 */ 9 4 9 5 9 6 9 7 /****^ HISTORY COMMENTS: 9 8* 1) change(86-05-15,DGHowe), approve(86-05-15,MCR7375), 9 9* audit(86-07-15,Schroth): 9 10* added command_name_arglist declaration to allow the storage of the 9 11* command name given to the command processor 9 12* END HISTORY COMMENTS */ 9 13 9 14 dcl 1 arg_list aligned based, 9 15 2 header, 9 16 3 arg_count fixed bin (17) unsigned unal, 9 17 3 pad1 bit (1) unal, 9 18 3 call_type fixed bin (18) unsigned unal, 9 19 3 desc_count fixed bin (17) unsigned unal, 9 20 3 pad2 bit (19) unal, 9 21 2 arg_ptrs (arg_list_arg_count refer (arg_list.arg_count)) ptr, 9 22 2 desc_ptrs (arg_list_arg_count refer (arg_list.arg_count)) ptr; 9 23 9 24 9 25 dcl 1 command_name_arglist aligned based, 9 26 2 header, 9 27 3 arg_count fixed bin (17) unsigned unal, 9 28 3 pad1 bit (1) unal, 9 29 3 call_type fixed bin (18) unsigned unal, 9 30 3 desc_count fixed bin (17) unsigned unal, 9 31 3 mbz bit(1) unal, 9 32 3 has_command_name bit(1) unal, 9 33 3 pad2 bit (17) unal, 9 34 2 arg_ptrs (arg_list_arg_count refer (command_name_arglist.arg_count)) ptr, 9 35 2 desc_ptrs (arg_list_arg_count refer (command_name_arglist.arg_count)) ptr, 9 36 2 name, 9 37 3 command_name_ptr pointer, 9 38 3 command_name_length fixed bin (21); 9 39 9 40 9 41 9 42 dcl 1 arg_list_with_envptr aligned based, /* used with non-quick int and entry-var calls */ 9 43 2 header, 9 44 3 arg_count fixed bin (17) unsigned unal, 9 45 3 pad1 bit (1) unal, 9 46 3 call_type fixed bin (18) unsigned unal, 9 47 3 desc_count fixed bin (17) unsigned unal, 9 48 3 pad2 bit (19) unal, 9 49 2 arg_ptrs (arg_list_arg_count refer (arg_list_with_envptr.arg_count)) ptr, 9 50 2 envptr ptr, 9 51 2 desc_ptrs (arg_list_arg_count refer (arg_list_with_envptr.arg_count)) ptr; 9 52 9 53 9 54 dcl ( 9 55 Quick_call_type init (0), 9 56 Interseg_call_type init (4), 9 57 Envptr_supplied_call_type 9 58 init (8) 9 59 ) fixed bin (18) unsigned unal int static options (constant); 9 60 9 61 /* The user must declare arg_list_arg_count - if an adjustable automatic structure 9 62* is being "liked" then arg_list_arg_count may be a parameter, in order to allocate 9 63* an argument list of the proper size in the user's stack 9 64* 9 65**/ 9 66 /* END INCLUDE FILE ... arg_list.incl.pl1 */ 403 404 10 1 /* BEGIN INCLUDE FILE ... pascal_symbol_node.incl.pl1 */ 10 2 10 3 /****^ HISTORY COMMENTS: 10 4* 1) change(86-09-15,JMAthane), approve(86-09-15,MCR7525), 10 5* audit(86-09-15,Martinson), install(86-11-12,MR12.0-1208): 10 6* Added size_is_encoded field in header. 10 7* END HISTORY COMMENTS */ 10 8 10 9 /* Written January 1983 by Melanie Weaver */ 10 10 /* Added size_is_encoded field in header May 85. JMAthane */ 10 11 10 12 dcl 1 pascal_symbol_node_header aligned based, 10 13 2 flags unaligned, /* indicate which pieces the node contains */ 10 14 3 version_flag bit (1) unaligned, /* always "0"b for post-version II PL/I format */ 10 15 3 aligned bit (1) unaligned, 10 16 3 packed bit (1) unaligned, 10 17 3 in_with_block bit (1) unaligned, 10 18 3 name_next bit (1) unaligned, 10 19 3 base_type_info bit (1) unaligned, 10 20 3 address bit (1) unaligned, 10 21 3 father_brother bit (1) unaligned, 10 22 3 son_level bit (1) unaligned, 10 23 3 father_type_successor bit (1) unaligned, 10 24 3 size bit (1) unaligned, 10 25 3 offset bit (1) unaligned, 10 26 3 subrange_limits bit (1) unaligned, 10 27 3 array_info bit (1) unaligned, 10 28 3 variant_info bit (1) unaligned, 10 29 3 size_is_encoded bit (1) unaligned, 10 30 3 pad bit (2) unaligned, 10 31 2 version fixed bin (17) unaligned, /* version of this node format */ 10 32 2 type fixed bin (17) unaligned, /* (extended) data type */ 10 33 2 type_offset fixed bin (18) unsigned unaligned; /* rel ptr to type node */ 10 34 10 35 dcl 1 pascal_name_next aligned based, 10 36 2 name fixed bin (18) unsigned unaligned, /* rel ptr to acc name */ 10 37 2 next_token fixed bin (18) unsigned unaligned; /* rel ptr to next of same class */ 10 38 10 39 dcl 1 pascal_base_type_info aligned based, 10 40 2 base_type fixed bin (17) unaligned, /* type of type */ 10 41 2 base_type_offset fixed bin (18) unsigned unaligned; 10 42 10 43 dcl 1 pascal_address aligned based, 10 44 2 location fixed bin (18) unsigned unaligned, /* location in storage class */ 10 45 2 class fixed bin (6) unsigned unaligned, /* storage class */ 10 46 2 use_digit bit (1) unaligned, 10 47 2 units bit (2) unaligned, /* addressing units */ 10 48 2 offset_is_encoded bit (1) unaligned, /* "1"b if pascal_offset is encoded */ 10 49 2 pad bit (8) unaligned; 10 50 10 51 dcl 1 pascal_father_brother aligned based, 10 52 2 father fixed bin (18) unsigned unaligned, /* rel ptr to father node */ 10 53 2 brother fixed bin (18) unsigned unaligned; /* rel ptr to brother node */ 10 54 10 55 dcl 1 pascal_son_level aligned based, 10 56 2 son fixed bin (18) unsigned unaligned, /* rel ptr to son node */ 10 57 2 level fixed bin (6) unsigned unaligned, /* record level; also enum. type elt. */ 10 58 2 pad bit (12) unaligned; 10 59 10 60 dcl 1 pascal_father_type_successor aligned based, 10 61 2 father_type fixed bin (17) unaligned, 10 62 2 successor fixed bin (18) unsigned unaligned; 10 63 10 64 dcl pascal_size fixed bin (35) based; /* precision, string size, etc. */ 10 65 10 66 dcl pascal_offset fixed bin (35) based; /* offset from address */ 10 67 10 68 dcl 1 pascal_subrange_limits aligned based, 10 69 2 flags aligned, 10 70 3 lower_bound_is_encoded bit (1) unaligned, 10 71 3 upper_bound_is_encoded bit (1) unaligned, 10 72 3 pad bit (34) unaligned, 10 73 2 subrange_lower_bound 10 74 fixed bin (35), 10 75 2 subrange_upper_bound 10 76 fixed bin (35); 10 77 10 78 dcl 1 pascal_array_info aligned based, /* info about array subscripts */ 10 79 2 access_info aligned, 10 80 3 ndims fixed bin (6) unsigned unaligned, /* number of dimensions */ 10 81 3 use_digit fixed bin (1) unsigned unaligned, /* if "1"b and units are half words, 10 82* units are really digits */ 10 83 3 array_units fixed bin (2) unsigned unaligned, 10 84 3 virtual_origin_is_encoded 10 85 bit (1) unaligned, 10 86 3 pad bit (26) unaligned, 10 87 2 virtual_origin fixed bin (35), 10 88 2 bounds (nd refer (pascal_array_info.access_info.ndims)) 10 89 aligned, 10 90 3 lower fixed bin (35), 10 91 3 upper fixed bin (35), 10 92 3 multiplier fixed bin (35), 10 93 3 subscript_type fixed bin (17) unaligned, 10 94 3 subscript_type_offset 10 95 fixed bin (18) unsigned unaligned, 10 96 3 flags aligned, 10 97 4 lower_is_encoded 10 98 bit (1) unaligned, 10 99 4 upper_is_encoded 10 100 bit (1) unaligned, 10 101 4 multiplier_is_encoded 10 102 bit (1) unaligned, 10 103 4 pad bit (33) unaligned; 10 104 10 105 dcl 1 pascal_variant_info aligned based, /* info to locate a record's variants */ 10 106 2 number_of_variants 10 107 fixed bin (17) unaligned, 10 108 2 pad bit (18) unaligned, 10 109 2 first_value_in_set fixed bin (35) unaligned, /* value corresponding to the first bit in set stings */ 10 110 2 case (nvariants refer 10 111 (pascal_variant_info.number_of_variants)), 10 112 3 set_offset fixed bin (18) unsigned unaligned, /* bit string specifies cases; 10 113* set's base type is this node's type */ 10 114 3 brother fixed bin (18) unsigned unaligned; /* rel ptr to brother for this variant */ 10 115 10 116 dcl 1 pascal_encoded_value aligned based, /* extended encoded value format */ 10 117 2 code bit (6) unaligned, /* tells how to interpret the other fields */ 10 118 2 (n1, n2) bit (6) unaligned, 10 119 2 n3 fixed bin (18) unsigned unaligned; 10 120 10 121 dcl nvariants fixed bin (17); 10 122 dcl nd fixed bin (6) unsigned; 10 123 10 124 10 125 10 126 /* END INCLUDE FILE ... pascal_symbol_node.incl.pl1 */ 405 406 11 1 /* BEGIN INCLUDE FILE runtime_symbol_info_.incl.pl1 */ 11 2 11 3 11 4 /****^ HISTORY COMMENTS: 11 5* 1) change(86-09-05,JMAthane), approve(86-09-05,MCR7525), 11 6* audit(86-09-11,Martinson), install(86-11-12,MR12.0-1208): 11 7* Added runtime_symbol_info_$subrange entry which was missing. Added 11 8* has_dimensions and has subrange_limits fields in type_info record. 11 9* Structure version numbers have not been changed since this change does not 11 10* affect existing programs. 11 11* END HISTORY COMMENTS */ 11 12 11 13 /* Declarations for using the various entry points in runtime_symbol_info_ */ 11 14 /* NOTE: These entries do not support PL/1 version 1. */ 11 15 11 16 /* Made structures aligned, removed variable extent from runtime_array_info.bounds 08/25/83 S. Herbst */ 11 17 /* Added version strings to structures 10/05/83 S. Herbst */ 11 18 /* Added has_dimensions and has_subrange_limits bits in type_info 11 19*Added subrange entry. JMAthane 08/31/84 */ 11 20 11 21 11 22 dcl runtime_symbol_info_$type entry (ptr, ptr, fixed bin (35)); 11 23 11 24 dcl 1 runtime_type_info aligned based, 11 25 2 version char (8), /* = "RUNTYP_1" */ 11 26 2 flags, 11 27 3 aligned bit (1) unal, 11 28 3 packed bit (1) unal, 11 29 3 size_is_encoded bit (1) unal, 11 30 3 has_dimensions bit (1) unal, 11 31 3 has_subrange_limits bit (1) unal, 11 32 3 pad bit (23) unal, 11 33 2 scale fixed bin (7) unal, 11 34 2 (type, base_type) fixed bin (18) unsigned unal, 11 35 2 (type_addr, base_type_addr) ptr, 11 36 2 size fixed bin (35); 11 37 11 38 dcl runtime_symbol_info_$father entry (ptr) returns (ptr); 11 39 11 40 dcl runtime_symbol_info_$brother entry (ptr) returns (ptr); 11 41 11 42 dcl runtime_symbol_info_$father_type entry (ptr) returns (ptr); 11 43 11 44 dcl runtime_symbol_info_$son entry (ptr) returns (ptr); 11 45 11 46 dcl runtime_symbol_info_$successor entry (ptr) returns (ptr); 11 47 11 48 dcl runtime_symbol_info_$name entry (ptr) returns (ptr); 11 49 11 50 dcl runtime_symbol_info_$level entry (ptr) returns (fixed bin); 11 51 11 52 dcl runtime_symbol_info_$next entry (ptr) returns (ptr); 11 53 11 54 dcl runtime_symbol_info_$address entry (ptr, ptr, fixed bin (35)); 11 55 11 56 dcl 1 runtime_address_info aligned based, 11 57 2 version char (8), /* = "RUNADR_1" */ 11 58 2 location fixed bin (18) unsigned unal, 11 59 2 class fixed bin (6) unsigned unal, 11 60 2 use_digit fixed bin (1) unsigned unal, 11 61 2 units fixed bin (2) unsigned unal, 11 62 2 offset_is_encoded bit (1) unal, 11 63 2 pad bit (8) unal, 11 64 2 offset fixed bin (35); 11 65 11 66 dcl runtime_symbol_info_$array_dims entry (ptr) returns (fixed bin); 11 67 11 68 dcl runtime_symbol_info_$array entry (ptr, ptr, fixed bin (35)); 11 69 11 70 dcl 1 runtime_array_info aligned based, 11 71 2 version char (8), /* = "RUNARY_1" */ 11 72 2 access_info aligned, 11 73 3 ndims fixed bin (6) unsigned unaligned, /* number of dimensions */ 11 74 3 use_digit fixed bin (1) unsigned unaligned, /* if "1"b and units are half words, 11 75* units are really digits */ 11 76 3 array_units fixed bin (2) unsigned unaligned, 11 77 3 virtual_origin_is_encoded 11 78 bit (1) unaligned, 11 79 3 pad bit (26) unaligned, 11 80 2 virtual_origin fixed bin (35), 11 81 2 bounds (16) 11 82 aligned, 11 83 3 flags aligned, 11 84 4 lower_is_encoded 11 85 bit (1) unaligned, 11 86 4 upper_is_encoded 11 87 bit (1) unaligned, 11 88 4 multiplier_is_encoded 11 89 bit (1) unaligned, 11 90 4 pad bit (33) unaligned, 11 91 3 lower fixed bin (35), 11 92 3 upper fixed bin (35), 11 93 3 multiplier fixed bin (35), 11 94 3 subscript_type fixed bin (35), 11 95 3 subscript_type_addr ptr; 11 96 11 97 dcl n_dims fixed bin; 11 98 11 99 dcl runtime_symbol_info_$n_variants entry (ptr) returns (fixed bin (35)); 11 100 11 101 dcl runtime_symbol_info_$variant entry (ptr, ptr, fixed bin (35)); 11 102 11 103 dcl 1 runtime_variant_info aligned based, 11 104 2 version char (8), /* = "RUNVAR_1" */ 11 105 2 number_of_variants fixed bin, 11 106 2 first_value_in_set fixed bin (35), /* value corresponding to the first bit in set stings */ 11 107 2 case (n_variants), 11 108 3 set_addr ptr, /* bit string specifies cases; 11 109* set's base type is this node's type */ 11 110 3 brother_addr ptr; /* ptr to brother for this variant */ 11 111 11 112 dcl n_variants fixed bin (35); 11 113 11 114 dcl runtime_symbol_info_$subrange entry (ptr, ptr, fixed bin (35)); 11 115 11 116 dcl 1 runtime_subrange_info based, 11 117 2 version char (8), /* = "RUNSUB_1" */ 11 118 2 flags aligned, 11 119 3 has_subrange_limits bit (1) unal, 11 120 3 lower_bound_is_encoded bit (1) unal, 11 121 3 upper_bound_is_encoded bit (1) unal, 11 122 3 pad bit (33) unal, 11 123 2 subrange_lower_bound fixed bin (35), 11 124 2 subrange_upper_bound fixed bin (35); 11 125 11 126 11 127 dcl RUNTIME_TYPE_INFO_VERSION_1 char (8) int static options (constant) init ("RUNTYP_1"); 11 128 dcl RUNTIME_ADDRESS_INFO_VERSION_1 char (8) int static options (constant) init ("RUNADR_1"); 11 129 dcl RUNTIME_ARRAY_INFO_VERSION_1 char (8) int static options (constant) init ("RUNARY_1"); 11 130 dcl RUNTIME_VARIANT_INFO_VERSION_1 char (8) int static options (constant) init ("RUNVAR_1"); 11 131 dcl RUNTIME_SUBRANGE_INFO_VERSION_1 char (8) int static options (constant) init ("RUNSUB_1"); 11 132 11 133 11 134 /* END INCLUDE FILE runtime_symbol_info_.incl.pl1 */ 407 408 409 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/12/86 1607.5 decode_runtime_value.pl1 >spec>install>1212>decode_runtime_value.pl1 387 1 05/06/74 1752.6 stu_frame.incl.pl1 >ldd>include>stu_frame.incl.pl1 389 2 11/26/79 1320.6 runtime_symbol.incl.pl1 >ldd>include>runtime_symbol.incl.pl1 391 3 05/06/74 1743.0 quick_entry.incl.pl1 >ldd>include>quick_entry.incl.pl1 393 4 05/06/74 1741.0 ctl_block.incl.pl1 >ldd>include>ctl_block.incl.pl1 395 5 11/07/86 1550.3 stack_header.incl.pl1 >ldd>include>stack_header.incl.pl1 397 6 08/05/77 1022.4 lot.incl.pl1 >ldd>include>lot.incl.pl1 399 7 11/26/79 1320.6 its.incl.pl1 >ldd>include>its.incl.pl1 401 8 11/02/83 1845.0 arg_descriptor.incl.pl1 >ldd>include>arg_descriptor.incl.pl1 403 9 08/05/86 0856.8 arg_list.incl.pl1 >ldd>include>arg_list.incl.pl1 405 10 11/12/86 1336.3 pascal_symbol_node.incl.pl1 >spec>install>1212>pascal_symbol_node.incl.pl1 407 11 11/12/86 1333.4 runtime_symbol_info_.incl.pl1 >spec>install>1212>runtime_symbol_info_.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. Envptr_supplied_call_type constant fixed bin(18,0) initial unsigned unaligned dcl 9-54 ref 295 P_bit_offset parameter fixed bin(24,0) dcl 371 ref 369 377 378 P_ptr parameter pointer dcl 335 in procedure "convert_ptr" ref 329 344 346 351 P_ptr parameter pointer dcl 370 in procedure "bitrel" ref 369 378 P_unal_ptr parameter pointer unaligned dcl 382 ref 381 384 a_value 000101 automatic structure level 1 dcl 42 set ref 50* 69* 70 addr builtin function dcl 46 ref 70 204 206 378 addrel builtin function dcl 46 ref 87 90 93 93 104 104 107 107 110 110 110 115 124 129 131 137 151 185 273 307 309 321 323 324 361 361 an_itp_ptr 000254 automatic structure level 1 dcl 336 set ref 344* an_its_ptr 000116 automatic structure level 1 dcl 98 set ref 100* arg_count based fixed bin(17,0) level 3 in structure "arg_list_with_envptr" packed unsigned unaligned dcl 9-42 in procedure "decode_runtime_value" ref 295 arg_count based fixed bin(17,0) level 3 in structure "arg_list" packed unsigned unaligned dcl 9-14 in procedure "decode_runtime_value" ref 277 297 arg_descriptor based structure level 1 dcl 8-6 arg_list based structure level 1 dcl 9-14 arg_list_arg_count 000100 automatic fixed bin(17,0) dcl 37 set ref 123 128 277* arg_list_with_envptr based structure level 1 dcl 9-42 arg_ptrs 2 based pointer array level 2 dcl 9-14 set ref 124* 129* argptr 32 based pointer level 2 in structure "frame" dcl 1-1 in procedure "decode_runtime_value" ref 267 275 argptr 2 based pointer level 2 in structure "quick_entry" dcl 3-1 in procedure "decode_runtime_value" ref 273 attempt_thunk 000010 constant entry external dcl 39 ref 117 based_fixed_bin based fixed bin(17,0) dcl 48 ref 87 90 93 104 107 110 115 124 129 137 147 151 baseno builtin function dcl 46 in procedure "decode_runtime_value" ref 180 233 253 baseno builtin function dcl 383 in procedure "faulty_ptr" ref 384 basep 000260 automatic pointer dcl 338 set ref 358* 359* 361 361 bin builtin function dcl 46 ref 357 361 361 bit_offset 1(21) 000254 automatic bit(6) level 2 in structure "an_itp_ptr" packed unaligned dcl 336 in procedure "convert_ptr" set ref 361 361 bit_offset 1(21) 000116 automatic bit(6) level 2 in structure "an_its_ptr" packed unaligned dcl 98 in begin block on line 96 set ref 101 blk parameter pointer dcl 30 set ref 28 63 117* 187 245 245 267 269 272 273 block_dcld_in 000014 constant entry external dcl 159 ref 186 block_ptr 000122 automatic pointer dcl 158 set ref 187* 189 190* 190* 191 199* call_type 0(18) based fixed bin(18,0) level 3 packed unsigned unaligned dcl 9-14 ref 295 code 0(02) 000101 automatic bit(4) level 2 in structure "a_value" packed unaligned dcl 42 in procedure "decode_runtime_value" set ref 57 code parameter fixed bin(35,0) dcl 30 in procedure "decode_runtime_value" set ref 28 53* 63 75* 83* 117* code based bit(6) level 2 in structure "pascal_encoded_value" packed unaligned dcl 10-116 in procedure "decode_runtime_value" ref 70 ctl_block based structure level 1 dcl 4-1 data based pointer level 2 dcl 4-1 ref 151 desc_count 1 based fixed bin(17,0) level 3 packed unsigned unaligned dcl 9-14 ref 292 desc_ptrs based pointer array level 2 in structure "arg_list" dcl 9-14 in procedure "decode_runtime_value" set ref 297* desc_ptrs based pointer array level 2 in structure "arg_list_with_envptr" dcl 9-42 in procedure "decode_runtime_value" set ref 295* descriptor 2 based pointer level 2 dcl 4-1 ref 323 display 40 based pointer level 2 dcl 1-1 ref 197 220 display_count 000126 automatic fixed bin(17,0) dcl 160 set ref 188* 192* 192 195 display_ct parameter fixed bin(17,0) dcl 285 in procedure "get_desc_ptr" set ref 283 290* display_ct parameter fixed bin(17,0) dcl 261 in procedure "get_arglist_ptr" set ref 259 264* display_ct parameter fixed bin(17,0) dcl 213 in procedure "get_stack_ptr" ref 211 219 dp 000244 automatic pointer dcl 320 set ref 321* 323* 324 encoded_value based structure level 1 dcl 2-70 entry 26 based pointer level 2 dcl 1-1 ref 244 entry_info 4 based bit(18) level 2 packed unaligned dcl 2-38 ref 272 273 extended_arg_type 000110 automatic fixed bin(17,0) initial dcl 8-36 set ref 8-36* fixed builtin function dcl 46 ref 57 70 79 80 81 101 135 143 180 233 253 flag based bit(1) level 2 in structure "arg_descriptor" packed unaligned dcl 8-6 in procedure "decode_runtime_value" ref 133 flag 000101 automatic bit(2) level 2 in structure "a_value" packed unaligned dcl 42 in procedure "decode_runtime_value" set ref 52 52 frame based structure level 1 dcl 1-1 get_runtime_address 000016 constant entry external dcl 161 ref 199 hbound builtin function dcl 46 ref 72 header based structure level 2 in structure "arg_list_with_envptr" dcl 9-42 in procedure "decode_runtime_value" header based structure level 2 in structure "arg_list" dcl 9-14 in procedure "decode_runtime_value" i 000134 automatic fixed bin(17,0) dcl 170 in begin block on line 155 set ref 195* i 000156 automatic fixed bin(17,0) dcl 215 in procedure "get_stack_ptr" set ref 219* ilp 000166 automatic pointer unaligned dcl 229 in procedure "get_linkage_ptr" set ref 233* 234* 235 ilp 000144 automatic pointer unaligned dcl 176 in procedure "get_linkage_ptr" set ref 180* 181* 182 isot based structure level 1 dcl 6-13 isot_ptr 52 based pointer level 2 dcl 5-26 ref 253 isp 000204 automatic pointer unaligned dcl 251 in procedure "get_static_ptr" set ref 253* 254* 255 isp based pointer array level 2 in structure "isot" packed unaligned dcl 6-13 in procedure "decode_runtime_value" ref 253 itp based structure level 1 dcl 7-18 itp_mod 0(30) 000254 automatic bit(6) level 2 packed unaligned dcl 336 set ref 346 349 355 its based structure level 1 dcl 7-5 loc 000124 automatic pointer dcl 158 set ref 199* 200 204 204 206 lot based structure level 1 dcl 6-6 lot_ptr 26 based pointer level 2 dcl 5-26 ref 180 233 lp based pointer array level 2 in structure "lot" packed unaligned dcl 6-6 in procedure "decode_runtime_value" ref 180 233 lp parameter pointer dcl 30 in procedure "decode_runtime_value" ref 28 63 178 178 231 231 n 000102 automatic fixed bin(17,0) dcl 44 set ref 57* 59 70* 72 85 n1 000103 automatic fixed bin(17,0) dcl 44 in procedure "decode_runtime_value" set ref 79* 87* 93 104* 110 120* 126* 131* 137* 202 203 204 206 307 321 n1 0(06) 000101 automatic bit(6) level 2 in structure "a_value" packed unaligned dcl 42 in procedure "decode_runtime_value" set ref 79 n2 0(12) 000101 automatic bit(6) level 2 in structure "a_value" packed unaligned dcl 42 in procedure "decode_runtime_value" set ref 80 n2 000104 automatic fixed bin(17,0) dcl 44 in procedure "decode_runtime_value" set ref 80* 104 107 110 115 123 124 128 129 131* 137* 151 201 203* 203 204 204 206 206 324 n3 000105 automatic fixed bin(17,0) dcl 44 in procedure "decode_runtime_value" set ref 81* 87 90 93 101 104 107 110 124 129 131 137 185 307 309 321 323 n3 0(18) 000101 automatic bit(18) level 2 in structure "a_value" packed unaligned dcl 42 in procedure "decode_runtime_value" set ref 81 narg parameter fixed bin(17,0) dcl 286 ref 283 292 295 297 null builtin function dcl 46 ref 99 113 178 181 191 195 199 199 199 199 200 217 231 243 244 245 267 offset 000262 automatic bit(18) level 2 in structure "text_embedded_ptr" packed unaligned dcl 339 in procedure "convert_ptr" set ref 352 offset 1 000254 automatic bit(18) level 2 in structure "an_itp_ptr" packed unaligned dcl 336 in procedure "convert_ptr" set ref 361 361 pascal_encoded_value based structure level 1 dcl 10-116 pr_no 000254 automatic bit(3) level 2 packed unaligned dcl 336 set ref 357 ptr builtin function dcl 46 ref 245 352 ptr_var based pointer dcl 47 ref 93 104 107 110 110 129 309 321 323 q 000154 automatic pointer dcl 214 in procedure "get_stack_ptr" set ref 216* 217 220* 220 222 q 000226 automatic pointer dcl 288 in procedure "get_desc_ptr" set ref 290* 292 295 295 297 q 000214 automatic pointer dcl 263 in procedure "get_arglist_ptr" set ref 264* 267* 267 273* 273 275* 275 277 278 quick parameter bit(1) dcl 262 in procedure "get_arglist_ptr" set ref 259 265* 271* quick 000224 automatic bit(1) dcl 287 in procedure "get_desc_ptr" set ref 290* 292 quick 0(01) based bit(1) level 2 in structure "runtime_block" packed unaligned dcl 2-38 in procedure "decode_runtime_value" ref 269 quick_entry based structure level 1 dcl 3-1 refp parameter pointer dcl 30 set ref 28 63 99 100 113 115 117* reg 000256 automatic fixed bin(17,0) dcl 337 set ref 357* 358 359 runtime_block based structure level 1 dcl 2-38 runtime_symbol_info_$father 000012 constant entry external dcl 11-38 ref 190 s based bit(1) level 2 packed unaligned dcl 163 ref 204 signed_value based structure level 1 packed unaligned dcl 163 size 0(12) based fixed bin(24,0) level 2 packed unsigned unaligned dcl 8-6 ref 133 135 143 sp parameter pointer dcl 30 set ref 28 63 87* 104* 117* 120* 126* 131* 137* 194 195 244 244 358 stack parameter pointer dcl 260 in procedure "get_arglist_ptr" set ref 259 264* stack parameter pointer dcl 284 in procedure "get_desc_ptr" set ref 283 290* stack parameter pointer dcl 212 in procedure "get_stack_ptr" ref 211 216 stack_header based structure level 1 dcl 5-26 stackbaseptr builtin function dcl 46 ref 180 233 253 str based structure level 1 dcl 373 string builtin function dcl 342 in procedure "convert_ptr" set ref 344* 351* string builtin function dcl 46 in procedure "decode_runtime_value" set ref 50* 69* 100* substr builtin function dcl 46 ref 135 symb parameter pointer dcl 67 ref 63 185 symbol_ptr 000120 automatic pointer dcl 158 set ref 185* 186* 199* target based bit(1) level 2 packed unaligned dcl 373 set ref 378 temp 000106 automatic pointer dcl 45 set ref 120* 124 126* 129 131* 133 133 135 text_embedded_ptr 000262 automatic structure level 1 dcl 339 set ref 351* this_block 000132 automatic pointer dcl 169 set ref 186* 189 this_sp 000130 automatic pointer dcl 168 set ref 194* 197* 197 199* tp parameter pointer dcl 30 ref 28 63 243 243 unsigned_value based bit unaligned dcl 166 ref 206 unspec builtin function dcl 342 in procedure "convert_ptr" ref 344 351 unspec builtin function dcl 46 in procedure "decode_runtime_value" ref 50 69 100 135 v parameter fixed bin(35,0) dcl 30 in procedure "decode_runtime_value" set ref 28 50 54 63 69 117* v 0(01) based bit level 2 in structure "signed_value" packed unaligned dcl 163 in begin block on line 155 ref 204 v_36b based bit(36) unaligned dcl 167 set ref 204* 206* value 000127 automatic fixed bin(35,0) dcl 162 set ref 204 206 208 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ITP_MODIFIER internal static bit(6) initial unaligned dcl 7-56 ITS_MODIFIER internal static bit(6) initial unaligned dcl 7-55 Interseg_call_type internal static fixed bin(18,0) initial unsigned unaligned dcl 9-54 Quick_call_type internal static fixed bin(18,0) initial unsigned unaligned dcl 9-54 RUNTIME_ADDRESS_INFO_VERSION_1 internal static char(8) initial unaligned dcl 11-128 RUNTIME_ARRAY_INFO_VERSION_1 internal static char(8) initial unaligned dcl 11-129 RUNTIME_SUBRANGE_INFO_VERSION_1 internal static char(8) initial unaligned dcl 11-131 RUNTIME_TYPE_INFO_VERSION_1 internal static char(8) initial unaligned dcl 11-127 RUNTIME_VARIANT_INFO_VERSION_1 internal static char(8) initial unaligned dcl 11-130 arg_descriptor_ptr automatic pointer dcl 8-34 call_offset internal static fixed bin(17,0) initial dcl 5-78 command_name_arglist based structure level 1 dcl 9-25 entry_offset internal static fixed bin(17,0) initial dcl 5-78 extended_arg_descriptor based structure level 1 dcl 8-21 fixed_arg_descriptor based structure level 1 dcl 8-13 isot1 based structure array level 1 dcl 6-16 isotp automatic pointer dcl 6-12 itp_unsigned based structure level 1 dcl 7-43 its_unsigned based structure level 1 dcl 7-30 lot_fault internal static bit(36) initial dcl 6-9 lotp automatic pointer dcl 6-4 n_dims automatic fixed bin(17,0) dcl 11-97 n_variants automatic fixed bin(35,0) dcl 11-112 nd automatic fixed bin(6,0) unsigned dcl 10-122 nvariants automatic fixed bin(17,0) dcl 10-121 pascal_address based structure level 1 dcl 10-43 pascal_array_info based structure level 1 dcl 10-78 pascal_base_type_info based structure level 1 dcl 10-39 pascal_father_brother based structure level 1 dcl 10-51 pascal_father_type_successor based structure level 1 dcl 10-60 pascal_name_next based structure level 1 dcl 10-35 pascal_offset based fixed bin(35,0) dcl 10-66 pascal_size based fixed bin(35,0) dcl 10-64 pascal_son_level based structure level 1 dcl 10-55 pascal_subrange_limits based structure level 1 dcl 10-68 pascal_symbol_node_header based structure level 1 dcl 10-12 pascal_variant_info based structure level 1 dcl 10-105 push_offset internal static fixed bin(17,0) initial dcl 5-78 return_no_pop_offset internal static fixed bin(17,0) initial dcl 5-78 return_offset internal static fixed bin(17,0) initial dcl 5-78 runtime_address_info based structure level 1 dcl 11-56 runtime_array_info based structure level 1 dcl 11-70 runtime_bound based structure level 1 unaligned dcl 2-33 runtime_subrange_info based structure level 1 unaligned dcl 11-116 runtime_symbol based structure level 1 dcl 2-3 runtime_symbol_info_$address 000000 constant entry external dcl 11-54 runtime_symbol_info_$array 000000 constant entry external dcl 11-68 runtime_symbol_info_$array_dims 000000 constant entry external dcl 11-66 runtime_symbol_info_$brother 000000 constant entry external dcl 11-40 runtime_symbol_info_$father_type 000000 constant entry external dcl 11-42 runtime_symbol_info_$level 000000 constant entry external dcl 11-50 runtime_symbol_info_$n_variants 000000 constant entry external dcl 11-99 runtime_symbol_info_$name 000000 constant entry external dcl 11-48 runtime_symbol_info_$next 000000 constant entry external dcl 11-52 runtime_symbol_info_$son 000000 constant entry external dcl 11-44 runtime_symbol_info_$subrange 000000 constant entry external dcl 11-114 runtime_symbol_info_$successor 000000 constant entry external dcl 11-46 runtime_symbol_info_$type 000000 constant entry external dcl 11-22 runtime_symbol_info_$variant 000000 constant entry external dcl 11-101 runtime_token based structure level 1 dcl 2-63 runtime_type_info based structure level 1 dcl 11-24 runtime_variant_info based structure level 1 dcl 11-103 sb automatic pointer dcl 5-24 stack_header_overlay based fixed bin(17,0) array dcl 5-94 tv_offset internal static fixed bin(17,0) initial dcl 5-72 NAMES DECLARED BY EXPLICIT CONTEXT. bitrel 001614 constant entry internal dcl 369 ref 361 convert_ptr 001520 constant entry internal dcl 329 ref 124 129 295 297 decode_runtime_value 000054 constant entry external dcl 28 decode_runtime_value_extended 000123 constant entry external dcl 63 fail 000146 constant label dcl 75 ref 59 99 113 123 128 191 200 201 202 217 234 246 254 272 292 359 364 377 faulty_ptr 001625 constant entry internal dcl 381 ref 181 234 254 get_arglist_ptr 001246 constant entry internal dcl 259 ref 120 126 290 get_ctl_block_ptr 001441 constant entry internal dcl 302 ref 151 get_ctl_descriptor 001466 constant entry internal dcl 312 ref 143 147 get_desc_ptr 001326 constant entry internal dcl 283 ref 131 137 get_linkage_ptr 001026 constant entry internal dcl 172 in begin block on line 155 ref 199 199 get_linkage_ptr 001126 constant entry internal dcl 225 in procedure "decode_runtime_value" ref 93 110 309 323 get_stack_ptr 001074 constant entry internal dcl 211 ref 87 104 264 get_static_ptr 001221 constant entry internal dcl 250 ref 90 107 307 321 359 get_text_ptr 001164 constant entry internal dcl 240 ref 180 199 199 233 253 352 join 000144 constant label dcl 72 ref 61 sw 000000 constant label array(0:16) dcl 87 ref 72 85 NAME DECLARED BY CONTEXT OR IMPLICATION. copy builtin function ref 204 206 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2046 2066 1742 2056 Length 2464 1742 20 361 103 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME decode_runtime_value 310 external procedure is an external procedure. begin block on line 96 begin block shares stack frame of external procedure decode_runtime_value. begin block on line 155 begin block shares stack frame of external procedure decode_runtime_value. get_linkage_ptr internal procedure shares stack frame of external procedure decode_runtime_value. get_stack_ptr internal procedure shares stack frame of external procedure decode_runtime_value. get_linkage_ptr internal procedure shares stack frame of external procedure decode_runtime_value. get_text_ptr internal procedure shares stack frame of external procedure decode_runtime_value. get_static_ptr internal procedure shares stack frame of external procedure decode_runtime_value. get_arglist_ptr internal procedure shares stack frame of external procedure decode_runtime_value. get_desc_ptr internal procedure shares stack frame of external procedure decode_runtime_value. get_ctl_block_ptr internal procedure shares stack frame of external procedure decode_runtime_value. get_ctl_descriptor internal procedure shares stack frame of external procedure decode_runtime_value. convert_ptr internal procedure shares stack frame of external procedure decode_runtime_value. bitrel internal procedure shares stack frame of external procedure decode_runtime_value. faulty_ptr internal procedure shares stack frame of external procedure decode_runtime_value. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME decode_runtime_value 000100 arg_list_arg_count decode_runtime_value 000101 a_value decode_runtime_value 000102 n decode_runtime_value 000103 n1 decode_runtime_value 000104 n2 decode_runtime_value 000105 n3 decode_runtime_value 000106 temp decode_runtime_value 000110 extended_arg_type decode_runtime_value 000116 an_its_ptr begin block on line 96 000120 symbol_ptr begin block on line 155 000122 block_ptr begin block on line 155 000124 loc begin block on line 155 000126 display_count begin block on line 155 000127 value begin block on line 155 000130 this_sp begin block on line 155 000132 this_block begin block on line 155 000134 i begin block on line 155 000144 ilp get_linkage_ptr 000154 q get_stack_ptr 000156 i get_stack_ptr 000166 ilp get_linkage_ptr 000204 isp get_static_ptr 000214 q get_arglist_ptr 000224 quick get_desc_ptr 000226 q get_desc_ptr 000244 dp get_ctl_descriptor 000254 an_itp_ptr convert_ptr 000256 reg convert_ptr 000260 basep convert_ptr 000262 text_embedded_ptr convert_ptr THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_bit_temp cat_realloc_bits call_ext_out begin_return_mac return_mac signal_op shorten_stack ext_entry repeat set_bits_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. attempt_thunk block_dcld_in get_runtime_address runtime_symbol_info_$father NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 8 36 000041 28 000045 50 000067 52 000072 53 000101 54 000102 57 000105 59 000111 61 000113 63 000114 69 000136 70 000141 72 000144 75 000146 76 000150 79 000152 80 000156 81 000162 83 000165 85 000166 87 000170 90 000211 93 000221 99 000234 100 000241 101 000245 104 000254 107 000300 110 000313 113 000331 115 000336 117 000345 120 000372 123 000411 124 000414 126 000433 128 000452 129 000455 131 000475 133 000516 135 000525 137 000531 143 000554 147 000562 151 000567 185 000600 186 000606 187 000617 188 000623 189 000624 190 000630 191 000640 192 000644 193 000645 194 000646 195 000652 197 000665 198 000670 199 000672 200 000726 201 000732 202 000735 203 000740 204 000742 206 000771 208 001020 209 001025 172 001026 178 001030 180 001041 181 001053 182 001064 409 001070 211 001074 216 001076 217 001101 219 001105 220 001115 221 001120 222 001122 225 001126 231 001130 233 001141 234 001153 235 001160 240 001164 243 001166 244 001177 245 001210 246 001220 250 001221 253 001223 254 001235 255 001242 259 001246 264 001250 265 001263 267 001265 269 001276 271 001302 272 001304 273 001310 274 001314 275 001315 277 001320 278 001323 283 001326 290 001330 292 001345 295 001356 297 001413 302 001441 307 001443 309 001455 312 001466 321 001470 323 001502 324 001512 329 001520 344 001522 346 001526 349 001537 351 001541 352 001543 355 001554 357 001556 358 001561 359 001570 361 001574 364 001613 369 001614 377 001616 378 001620 381 001625 384 001627 ----------------------------------------------------------- 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