COMPILATION LISTING OF SEGMENT lisp_obarray_utils_ Compiled by: Multics PL/I Compiler, Release 28b, of April 11, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 06/30/83 0848.0 mst Thu Options: map single_symbol_list 1 /* ************************************************************** 2* * * 3* * Copyright, (C) Massachusetts Institute of Technology, 1973 * 4* * * 5* ************************************************************** */ 6 lisp_obarray_utils_: proc; 7 8 /* procedure to find an atom by name, and intern it on the current obarray. 9* Redone completely for the unsharing of nil and the PL/I null pointer. 10* Single character atoms put in obarray, 12 Nov 72, DAM 11* New hash function, 12 Nov 72, DAM 12* Modified 74.05.31 by DAM for new arrays. intern, remob, makoblist added. 13* */ 14 15 dcl 16 htptr ptr, /* temp pointer to hash table */ 17 18 1 obarray_struct based(htptr) aligned, 19 2 hash_table(0:510) fixed bin(71), 20 2 char_objects(0:127) fixed bin(71), 21 22 namelen fixed bin, 23 indx fixed bin, 24 lisp_get_atom_$hash_fcn entry(char(*) aligned, fixed bin), /* first arg better be padded with 25* \000 to multiple of 4 characters */ 26 lisp_alloc_ entry(fixed bin, fixed bin(71) aligned), 27 lisp_array_fcns_$star_array entry, 28 lisp_special_fns_$xcons entry, 29 lisp_special_fns_$cons entry, 30 lisp_list_utils_$subst entry, 31 nargs fixed bin, 32 stack ptr, 33 (addr, divide, length, mod, substr) builtin; 34 1 1 /* Include file lisp_ptr_fmt.incl.pl1; 1 2* describes the format of lisp pointers as 1 3* a bit string overlay on the double word ITS pair 1 4* which allows lisp to access some unused bits in 1 5* the standard ITS pointer format. It should be noted that 1 6* this is somewhat of a kludge, since 1 7* it is quite machine dependent. However, to store type 1 8* fields in the pointer, saves 2 words in each cons, 1 9* plus some efficiency problems. 1 10* 1 11* D.Reed 4/1/71 */ 1 12 /* modified to move type field to other half of ptr */ 1 13 /* D.Reed 5/31/72 */ 1 14 1 15 1 16 dcl based_ptr ptr aligned based; /* for dealing with lisp values as pointers */ 1 17 dcl lisp_ptr_type bit(36) aligned based, /* for more efficient checking of type bits */ 1 18 1 lisp_ptr based aligned, /* structure of double word pointer in lisp */ 1 19 2 segno bit(18) unaligned, /* segment number pointed to by pointer */ 1 20 2 ringnum bit(3) unaligned, /* ring mumber for validation */ 1 21 2 type bit(9) unaligned, /* type field */ 1 22 2 itsmod bit(6) unaligned, 1 23 2 offset fixed bin(17) unaligned, /* offset in segment of object pointed to */ 1 24 2 chain bit(18) unaligned, /* normally 0, but may be set to chain pointers together */ 1 25 1 26 /* manifest constant strings for testing above type field */ 1 27 1 28 ( 1 29 Cons init("000000000"b), /* a pointer to a list has a zero type field */ 1 30 Fixed init("100000000"b), /* a fixed point number, stored in second word of the ptr */ 1 31 Float init("010000000"b), /* a floating number, also stored in the second word of the ptr */ 1 32 Atsym init("001000000"b), /* this bit on means a ptr to an atomic symbol */ 1 33 Atomic init("111111111"b), /* any bit on means an atomic data type */ 1 34 Bignum init("000001000"b), /* a multiple-precision number */ 1 35 Bigfix init("000001000"b), /* a fixed point bignum (only kind for now) */ 1 36 Numeric init("110000000"b), /* either type immediate number. Both bits on 1 37* means a special internal uncollectable weird object */ 1 38 Uncollectable init("110000000"b), /* not looked through by garbage collector */ 1 39 String init("000100000"b), /* pointer to lisp character string - length word, chars */ 1 40 Subr init("000010000"b), /* pointer to compiled (or builtin) subroutine (linkage) code */ 1 41 System_Subr init("000000100"b), /* Subr bit must be on too, indicates ptr into lisp_subr_tv_ */ 1 42 Array init("000000010"b), /* Subr bit must be on too, indicates ptr to a lisp array */ 1 43 File init("000000001"b) /* pointer to a file object (iochan block) */ 1 44 ) bit(9) static, 1 45 1 46 /* 36 bit manifest constant strings for testing lisp_ptr_type */ 1 47 1 48 1 49 ( 1 50 Cons36 init("000000000000000000000000000000"b), 1 51 Fixed36 init("000000000000000000000100000000"b), 1 52 Float36 init("000000000000000000000010000000"b), 1 53 Atsym36 init("000000000000000000000001000000"b), 1 54 Atomic36 init("000000000000000000000111111100"b), 1 55 Bignum36 init("000000000000000000000000001000"b), 1 56 System_Subr36 1 57 init("000000000000000000000000000100"b), 1 58 Bigfix36 init("000000000000000000000000001000"b), 1 59 Numeric36 init("000000000000000000000110000000"b), /* does not check for bignum */ 1 60 NotConsOrAtsym36 1 61 init("000000000000000000000110111111"b), 1 62 SubrNumeric36 1 63 init("000000000000000000000110010000"b), /* used in garbage collector, for quick check */ 1 64 String36 init("000000000000000000000000100000"b), 1 65 Subr36 init("000000000000000000000000010000"b), 1 66 File36 init("000000000000000000000000000001"b), 1 67 Array36 init("000000000000000000000000000010"b)) bit(36) aligned static, 1 68 1 69 /* undefined pointer value is double word of zeros */ 1 70 1 71 Undefined bit(72) static init(""b); 1 72 1 73 /* end of include file lisp_ptr_fmt.incl.pl1 */ 35 2 1 /* include file lisp_stack_fmt.incl.pl1 -- 2 2* describes the format of the pushdown list 2 3* used by the lisp evaluator and lisp subrs 2 4* for passing arguments, saving atom bindings, 2 5* and as temporaries */ 2 6 2 7 dcl 2 8 temp(10000) fixed bin(71) aligned based, 2 9 2 10 temp_ptr(10000) ptr aligned based, 2 11 1 push_down_list_ptr_types(10000) based aligned, 2 12 2 junk bit(21) unaligned, 2 13 2 temp_type bit(9) unaligned, 2 14 2 more_junk bit(42) unaligned, 2 15 2 16 1 pdl_ptr_types36(10000) based aligned, 2 17 2 temp_type36 bit(36), 2 18 2 junk bit(36), 2 19 2 20 1 binding_block aligned based, 2 21 2 top_block bit(18) unaligned, 2 22 2 bot_block bit(18) unaligned, /* these two are rel pointers into the marked PDL */ 2 23 2 back_ptr bit(18) unaligned, /* relative pointer into unmarked PDL for last binding block. */ 2 24 2 rev_ptr bit(18) unaligned, /* relative pointer to reversal bb which reversed this one, init to 0 */ 2 25 2 26 1 bindings(10000) based aligned, /* format fof bindings on stack */ 2 27 2 old_val fixed bin(71) aligned, 2 28 2 atom fixed bin(71) aligned; 2 29 2 30 2 31 2 32 /* end include file lisp_stack_fmt.incl.pl1 */ 36 3 1 /* Include file lisp_cons_fmt.incl.pl1; 3 2* defines the format for a cons within the lisp system 3 3* D.Reed 4/1/71 */ 3 4 3 5 dcl consptr ptr, 3 6 1 cons aligned based (consptr), /* structure defining format for cons */ 3 7 2 car fixed bin(71), 3 8 2 cdr fixed bin(71), 3 9 3 10 1 cons_ptrs aligned based (consptr), /* for using car and cdr as pointers */ 3 11 2 car ptr, 3 12 2 cdr ptr, 3 13 3 14 3 15 1 cons_types aligned based (consptr), /* structure for extracting types out of cons */ 3 16 2 padding bit(21) unaligned, 3 17 2 car bit(9) unaligned, 3 18 2 padding2 bit(63) unaligned, 3 19 2 cdr bit(9) unaligned, 3 20 2 padend bit(42) unaligned; 3 21 3 22 dcl 1 cons_types36 aligned based, 3 23 2 car bit(36), 3 24 2 pada bit(36), 3 25 2 cdr bit(36), 3 26 2 padd bit(36); 3 27 3 28 3 29 /* end include file lisp_cons_fmt.incl.pl1 */ 37 4 1 /* Include file lisp_atom_fmt.incl.pl1; 4 2* describes internal format of atoms in the lisp system 4 3* D.Reed 4/1/71 */ 4 4 4 5 dcl 1 atom aligned based, /* overlay for atom fomat */ 4 6 2 value fixed bin(71), /* atom's value */ 4 7 2 plist fixed bin(71), /* property list */ 4 8 2 pnamel fixed bin, /* length of print name */ 4 9 2 pname char(1 refer(pnamel)), /* print name of atom */ 4 10 4 11 1 atom_ptrs based aligned, /* for use of plist and value of atom as ptrs */ 4 12 2 value ptr, 4 13 2 plist ptr, 4 14 4 15 1 atom_double_words based aligned, /* overlay for atom pointer checking */ 4 16 2 value bit(72), 4 17 2 plist bit(72); 4 18 4 19 /* end of include file lisp_atom_fmt.incl.pl1 */ 38 5 1 /* lisp number format -- overlaid on standard its pointer. */ 5 2 5 3 5 4 dcl 1 fixnum_fmt based aligned, 5 5 2 type_info bit(36) aligned, 5 6 2 fixedb fixed bin, 5 7 5 8 1 flonum_fmt based aligned, 5 9 2 type_info bit(36) aligned, 5 10 2 floatb float bin, 5 11 5 12 fixnum_type bit(36) aligned static init("000000000000000000000100000000100111"b), 5 13 flonum_type bit(36) aligned static init("000000000000000000000010000000100111"b); 5 14 5 15 /* end of lisp number format */ 5 16 39 6 1 /***** BEGIN INCLUDE FILE lisp_array_fmt.incl.pl1 *****/ 6 2 6 3 /* This include file defines the format of the "new" LISP arrays. 6 4* Written 74.05.13 by DAM */ 6 5 6 6 /* Info block in static space. pointed at by array ptr */ 6 7 6 8 dcl 1 array_info aligned based structure, /* 8 words long */ 6 9 2 ndims fixed bin(17) unaligned, /* number of dimensions */ 6 10 2 gc_mark bit(18) unaligned, /* alternating bits for garbage coll. */ 6 11 2 call_array_operator bit(36), /* tspbp instruction to array opr */ 6 12 2 array_data_ptr pointer, /* -> array_data structure */ 6 13 2 array_load_sequence(3) bit(36), /* lda, ldq, tra bp|0 */ 6 14 2 type fixed bin(17) unaligned, /* type of array, see dcl below */ 6 15 2 minus_2_times_ndims fixed bin(17) unaligned; /* for convenience of array opr */ 6 16 6 17 /* Codes for the different types of arrays: 6 18* Name Value arg to *array to create one */ 6 19 6 20 dcl (S_expr_array init(0), /* t */ 6 21 Un_gc_array init(1), /* nil */ 6 22 Fixnum_array init(2), /* fixnum */ 6 23 Flonum_array init(3), /* flonum */ 6 24 Readtable_array init(4), /* readtable */ 6 25 Obarray_array init(5), /* obarray */ 6 26 Dead_array init(6) /* (*rearray a) */ 6 27 ) fixed bin(17) static; 6 28 6 29 /* Block of array data and dimensions, in garbage-collected Lists space */ 6 30 6 31 dcl 1 array_data aligned based structure, 6 32 2 dope_vector(ZERO), /* address by dope_vector(i-ndims). no way to dcl in PL/I */ 6 33 3 bounds fixed bin(35), /* 0 <_ subscript < bounds */ 6 34 3 multiplier fixed bin(35), /* multiplier in polynomial-type subscript calc. */ 6 35 2 data(0:1000) fixed bin(71); /* single or double words depending on type of array */ 6 36 6 37 dcl ZERO fixed bin static init(0); /* Circumvent a compiler bug causing reference through null pointer in get_array_size$multf */ 6 38 6 39 /***** END INCLUDE FILE lisp_array_fmt.incl.pl1 *****/ 40 7 1 /* Include file lisp_common_vars.incl.pl1; 7 2* describes the external static variables which may be referenced 7 3* by lisp routines. 7 4* D. Reed 4/1/71 */ 7 5 7 6 dcl 1 lisp_static_vars_$lisp_static_vars_ external, 7 7 2 cclist_ptr ptr, /* pointer to list of constants kept 7 8* by compiled programs */ 7 9 2 garbage_collect_soon bit(1) aligned, /* if this is on we should garbage collect soon */ 7 10 7 11 lisp_static_vars_$err_recp ptr ext aligned, /* pointer to error data */ 7 12 err_recp ptr defined (lisp_static_vars_$err_recp), 7 13 eval_frame ptr defined (lisp_static_vars_$eval_frame), /* info kept by eval if *rset t */ 7 14 lisp_static_vars_$eval_frame ptr ext static, 7 15 lisp_static_vars_$prog_frame ptr ext aligned, 7 16 lisp_static_vars_$err_frame ptr ext aligned, 7 17 lisp_static_vars_$catch_frame ptr ext aligned, 7 18 lisp_static_vars_$unwp_frame ptr ext aligned, 7 19 lisp_static_vars_$stack_ptr ptr ext aligned, 7 20 lisp_static_vars_$t_atom fixed bin(71) ext aligned, 7 21 lisp_static_vars_$top_level label ext, /* top level read_eval_print loop */ 7 22 lisp_static_vars_$unmkd_ptr ptr ext aligned, 7 23 lisp_static_vars_$binding_top ptr ext aligned, 7 24 lisp_static_vars_$obarray fixed bin(71) aligned ext, 7 25 obarray fixed bin(71) defined (lisp_static_vars_$obarray), 7 26 lisp_static_vars_$array_atom fixed bin(71) aligned ext, 7 27 array_atom fixed bin(71) defined (lisp_static_vars_$array_atom), 7 28 binding_top ptr defined (lisp_static_vars_$binding_top), 7 29 unmkd_ptr ptr defined (lisp_static_vars_$unmkd_ptr), 7 30 stack_ptr ptr defined (lisp_static_vars_$stack_ptr), 7 31 lisp_static_vars_$nil ext static fixed bin(71) aligned, 7 32 nil fixed bin(71) defined (lisp_static_vars_$nil), 7 33 lisp_static_vars_$tty_input_chan ext static ptr, /* used by the reader */ 7 34 lisp_static_vars_$tty_output_chan ext static ptr, /*used by print*/ 7 35 tty_input_chan ptr def (lisp_static_vars_$tty_input_chan), 7 36 tty_output_chan ptr def (lisp_static_vars_$tty_output_chan), 7 37 lisp_static_vars_$iochan_list external pointer, /* list of all open iochans */ 7 38 nil_ptr ptr based(addr(lisp_static_vars_$nil)) aligned, 7 39 prog_frame ptr def (lisp_static_vars_$prog_frame), /* 3 ptrs for use of lisp_prog_fns_ */ 7 40 err_frame ptr def (lisp_static_vars_$err_frame), /* they point out frames in unmkd pdl */ 7 41 catch_frame ptr def (lisp_static_vars_$catch_frame), 7 42 unwp_frame ptr def (lisp_static_vars_$unwp_frame), 7 43 t_atom_ptr ptr aligned based(addr(lisp_static_vars_$t_atom)), 7 44 t_atom fixed bin(71) defined (lisp_static_vars_$t_atom); /* pointer to atom t */ 7 45 dcl lisp_static_vars_$user_intr_array(20) fixed bin(71) aligned ext static, /* -> atoms whose values are intr service functions */ 7 46 user_intr_array (20) fixed bin(71) aligned def (lisp_static_vars_$user_intr_array), 7 47 lisp_static_vars_$star_rset fixed bin(71) aligned ext static, 7 48 star_rset fixed bin(71) aligned def (lisp_static_vars_$star_rset); 7 49 7 50 7 51 /* end include file lisp_common_vars.incl.pl1 */ 41 42 43 44 45 init_ht: entry; 46 47 stack = stack_ptr; 48 stack_ptr = addr(stack -> temp(5)); 49 50 call lisp_alloc_(6,stack->temp(1)); /* room for nil */ 51 stack -> temp_type(1) = Atsym; 52 stack -> temp_ptr(1) -> atom.value = stack -> temp(1); /* value (nil) = nil */ 53 stack -> temp_ptr(1) ->atom.plist = stack -> temp(1); /* plist (nil) = nil */ 54 stack -> temp_ptr(1) -> atom.pnamel = 3; 55 substr(stack -> temp_ptr(1) -> atom.pname,1,3) = "nil"; 56 nil = stack -> temp(1); 57 58 call lisp_alloc_(8,stack->temp(1)); 59 stack -> temp_type(1) = Atsym; 60 stack -> temp_ptr(1) -> atom.pnamel = 7; 61 substr(stack -> temp_ptr(1) ->atom.pname,1,7) = "obarray"; 62 stack -> temp_ptr(1) -> atom.plist = nil; 63 obarray = stack -> temp(1); 64 65 /* use *array to create an initially empty obarray. 66* it will look at the entries nil and obarray in lisp_static_vars_, only */ 67 68 addr(stack -> temp(4)) -> fixnum_fmt.type_info = fixnum_type; 69 addr(stack -> temp(4)) -> fixedb = -6; 70 stack -> temp(1) = nil; 71 stack -> temp(2) = obarray; 72 stack -> temp(3) = nil; 73 call lisp_array_fcns_$star_array; /* create array pointer, make empty obarray, return array ptr */ 74 addr(obarray) -> based_ptr -> atom.value = stack -> temp(1); 75 76 htptr = stack -> temp_ptr(1) -> array_info.array_data_ptr; 77 call lisp_get_atom_$hash_fcn("obarray", indx); 78 stack_ptr = addr(stack -> temp(3)); 79 stack -> temp(2) = nil; 80 stack -> temp(1) = obarray; 81 call lisp_special_fns_$cons; 82 hash_table(indx) = stack -> temp(1); 83 84 call lisp_get_atom_$hash_fcn("nil", indx); 85 stack_ptr = addr(stack -> temp(3)); 86 stack -> temp(2), stack -> temp(1) = nil; 87 call lisp_special_fns_$cons; 88 hash_table(indx) = stack -> temp(1); 89 90 return; 91 92 in: entry(atomic_object); 93 94 in_out = 0; 95 goto hashjoin; 96 97 out: entry(atomic_object); 98 99 dcl atomic_object fixed bin(71)aligned, 100 in_out fixed bin(1); 101 102 in_out = 1; 103 hashjoin: 104 105 if addr(atomic_object)->lisp_ptr_type & Atsym36 then; 106 else return; 107 108 htptr = addr(obarray)->based_ptr->atom_ptrs.value -> array_info.array_data_ptr; 109 110 call lisp_get_atom_$hash_fcn(addr(atomic_object)->based_ptr -> atom.pname, indx); 111 if indx >= 511 then go to sing_char(in_out); /* single char atom */ 112 113 stack = stack_ptr ; 114 stack_ptr = addr(stack -> temp(4)); 115 116 stack -> temp(1) = hash_table(indx); 117 stack -> temp_ptr(2) = addr(hash_table(indx-1)); 118 stack -> temp_type(2) = Numeric; 119 120 121 do while(stack->temp(1) ^= nil); 122 stack -> temp(3) = stack -> temp_ptr(1) -> cons.car; 123 go to case(in_out); 124 case(0): 125 if stack -> temp_ptr(3) -> atom.pname = addr(atomic_object) -> based_ptr -> atom.pname 126 then do; 127 atomic_object = stack -> temp(3); 128 go to done_out; 129 end; 130 else go to endcase; 131 132 case(1): 133 if stack -> temp(3) = atomic_object 134 then do; 135 stack -> temp_ptr(2) -> cons.cdr = stack -> temp_ptr(1) -> cons.cdr; 136 go to done_out; 137 end; 138 endcase: 139 stack -> temp(2) = stack -> temp(1); 140 stack -> temp(1) = stack -> temp_ptr(1) -> cons.cdr; 141 end; 142 143 if in_out = 0 144 then do; 145 stack -> temp(3) = hash_table(indx); 146 stack -> temp(2) = atomic_object; 147 call lisp_special_fns_$cons; 148 htptr = addr(obarray)->based_ptr->atom_ptrs.value -> array_info.array_data_ptr; /* gc may have moved it or lost it */ 149 hash_table(indx) = stack -> temp(2); 150 end; 151 152 done_out: stack_ptr = stack; 153 return; 154 155 sing_char(0): /* insert single char atom if not already there */ 156 if hash_table(indx) ^= nil then atomic_object = hash_table(indx); 157 else hash_table(indx) = atomic_object; 158 return; 159 sing_char(1): 160 hash_table(indx) = nil; 161 return; 162 163 intern: entry; 164 165 stack = addrel(stack_ptr, -2); 166 call in(stack -> temp(1)); 167 return; 168 169 remob: entry; 170 171 stack = addrel(stack_ptr, -2); 172 call out(stack -> temp(1)); 173 return; 174 175 makoblist:entry; 176 177 stack = addrel(stack_ptr,-2); 178 if stack -> temp(1) = nil /* not to be made, just make a list of lists */ 179 then do; 180 stack_ptr = addr(stack -> temp(6)); 181 stack -> temp(1), 182 stack -> temp(2), 183 stack -> temp(3), 184 stack -> temp(4) = nil; 185 do nargs = 0 to 509; /* scan over all obarray - except character objects */ 186 stack -> temp(5) = addr(obarray)->based_ptr->atom_ptrs.value -> array_info.array_data_ptr-> array_data.data(nargs); 187 call lisp_list_utils_$subst; /* copy list */ 188 stack -> temp(1) = stack -> temp(3); /* get answer */ 189 stack_ptr = addr(stack -> temp(3)); 190 call lisp_special_fns_$cons; 191 stack_ptr = addr(stack -> temp(6)); 192 stack -> temp(2) = stack -> temp(1); 193 stack -> temp(3),stack->temp(4) = nil; 194 end; 195 do nargs = 511 to 638; /* scan over character objects */ 196 stack -> temp(5) = addr(obarray) -> based_ptr -> atom_ptrs.value -> array_info.array_data_ptr-> array_data.data(nargs); 197 if stack -> temp(5) ^= nil then do; /* if this char object has been interned */ 198 call lisp_special_fns_$xcons; 199 stack_ptr = addr(stack -> temp(6)); 200 end; 201 end; 202 stack -> temp(2) = stack -> temp(4); 203 stack_ptr = addr(stack -> temp(3)); 204 call lisp_special_fns_$xcons; 205 return; 206 end; 207 else do; 208 stack_ptr = addr(stack -> temp(6)); 209 stack -> temp(2) = stack -> temp(1); /* atom to be made into obarray */ 210 stack -> temp(3) = lisp_static_vars_$obarray; 211 stack -> temp(4) = t_atom; /* copy existing obarray */ 212 addr(stack -> temp(5)) -> fixnum_fmt.type_info = fixnum_type; 213 addr(stack -> temp(5)) -> fixedb = -6; 214 call lisp_array_fcns_$star_array; 215 stack_ptr = addr(stack -> temp(2)); 216 return; 217 end; 218 219 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/29/83 1542.3 lisp_obarray_utils_.pl1 >special_ldd>on>06/27/83>lisp_obarray_utils_.pl1 35 1 03/27/82 0437.0 lisp_ptr_fmt.incl.pl1 >ldd>include>lisp_ptr_fmt.incl.pl1 36 2 03/27/82 0437.0 lisp_stack_fmt.incl.pl1 >ldd>include>lisp_stack_fmt.incl.pl1 37 3 03/27/82 0437.0 lisp_cons_fmt.incl.pl1 >ldd>include>lisp_cons_fmt.incl.pl1 38 4 03/27/82 0437.1 lisp_atom_fmt.incl.pl1 >ldd>include>lisp_atom_fmt.incl.pl1 39 5 03/27/82 0437.0 lisp_nums.incl.pl1 >ldd>include>lisp_nums.incl.pl1 40 6 03/27/82 0437.1 lisp_array_fmt.incl.pl1 >ldd>include>lisp_array_fmt.incl.pl1 41 7 03/27/82 0437.0 lisp_common_vars.incl.pl1 >ldd>include>lisp_common_vars.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) Array internal static bit(9) initial unaligned dcl 1-17 Array36 internal static bit(36) initial dcl 1-17 Atomic internal static bit(9) initial unaligned dcl 1-17 Atomic36 internal static bit(36) initial dcl 1-17 Atsym constant bit(9) initial unaligned dcl 1-17 ref 51 59 Atsym36 constant bit(36) initial dcl 1-17 ref 103 Bigfix internal static bit(9) initial unaligned dcl 1-17 Bigfix36 internal static bit(36) initial dcl 1-17 Bignum internal static bit(9) initial unaligned dcl 1-17 Bignum36 internal static bit(36) initial dcl 1-17 Cons internal static bit(9) initial unaligned dcl 1-17 Cons36 internal static bit(36) initial dcl 1-17 Dead_array internal static fixed bin(17,0) initial dcl 6-20 File internal static bit(9) initial unaligned dcl 1-17 File36 internal static bit(36) initial dcl 1-17 Fixed internal static bit(9) initial unaligned dcl 1-17 Fixed36 internal static bit(36) initial dcl 1-17 Fixnum_array internal static fixed bin(17,0) initial dcl 6-20 Float internal static bit(9) initial unaligned dcl 1-17 Float36 internal static bit(36) initial dcl 1-17 Flonum_array internal static fixed bin(17,0) initial dcl 6-20 NotConsOrAtsym36 internal static bit(36) initial dcl 1-17 Numeric constant bit(9) initial unaligned dcl 1-17 ref 118 Numeric36 internal static bit(36) initial dcl 1-17 Obarray_array internal static fixed bin(17,0) initial dcl 6-20 Readtable_array internal static fixed bin(17,0) initial dcl 6-20 S_expr_array internal static fixed bin(17,0) initial dcl 6-20 String internal static bit(9) initial unaligned dcl 1-17 String36 internal static bit(36) initial dcl 1-17 Subr internal static bit(9) initial unaligned dcl 1-17 Subr36 internal static bit(36) initial dcl 1-17 SubrNumeric36 internal static bit(36) initial dcl 1-17 System_Subr internal static bit(9) initial unaligned dcl 1-17 System_Subr36 internal static bit(36) initial dcl 1-17 Un_gc_array internal static fixed bin(17,0) initial dcl 6-20 Uncollectable internal static bit(9) initial unaligned dcl 1-17 Undefined internal static bit(72) initial unaligned dcl 1-17 ZERO constant fixed bin(17,0) initial dcl 6-37 ref 186 196 addr builtin function dcl 15 ref 48 68 69 74 78 85 103 108 110 114 117 124 148 180 186 189 191 196 199 203 208 212 213 215 addrel builtin function ref 165 171 177 array_atom defined fixed bin(71,0) dcl 7-6 array_data based structure level 1 dcl 6-31 array_data_ptr 2 based pointer level 2 dcl 6-8 ref 76 108 148 186 196 array_info based structure level 1 dcl 6-8 atom based structure level 1 dcl 4-5 atom_double_words based structure level 1 dcl 4-5 atom_ptrs based structure level 1 dcl 4-5 atomic_object parameter fixed bin(71,0) dcl 99 set ref 92 97 103 110 124 127* 132 146 155* 157 based_ptr based pointer dcl 1-16 ref 74 108 110 124 148 186 196 binding_block based structure level 1 dcl 2-7 binding_top defined pointer dcl 7-6 bindings based structure array level 1 dcl 2-7 car based fixed bin(71,0) level 2 dcl 3-5 ref 122 case 000000 constant label array(0:1) dcl 124 ref 123 catch_frame defined pointer dcl 7-6 cdr 2 based fixed bin(71,0) level 2 dcl 3-5 set ref 135* 135 140 cons based structure level 1 dcl 3-5 cons_ptrs based structure level 1 dcl 3-5 cons_types based structure level 1 dcl 3-5 cons_types36 based structure level 1 dcl 3-22 consptr automatic pointer dcl 3-5 data based fixed bin(71,0) array level 2 dcl 6-31 ref 186 196 divide builtin function dcl 15 done_out 000473 constant label dcl 152 ref 128 136 endcase 000433 constant label dcl 138 ref 130 err_frame defined pointer dcl 7-6 err_recp defined pointer dcl 7-6 eval_frame defined pointer dcl 7-6 fixedb 1 based fixed bin(17,0) level 2 dcl 5-4 set ref 69* 213* fixnum_fmt based structure level 1 dcl 5-4 fixnum_type constant bit(36) initial dcl 5-4 ref 68 212 flonum_fmt based structure level 1 dcl 5-4 flonum_type internal static bit(36) initial dcl 5-4 hash_table based fixed bin(71,0) array level 2 dcl 15 set ref 82* 88* 116 117 145 149* 155 155 157* 159* hashjoin 000305 constant label dcl 103 ref 95 htptr 000100 automatic pointer dcl 15 set ref 76* 82 88 108* 116 117 145 148* 149 155 155 157 159 in 000265 constant entry external dcl 92 ref 166 in_out 000106 automatic fixed bin(1,0) dcl 99 set ref 94* 102* 111 123 143 indx 000102 automatic fixed bin(17,0) dcl 15 set ref 77* 82 84* 88 110* 111 116 117 145 149 155 155 157 159 init_ht 000024 constant entry external dcl 45 intern 000527 constant entry external dcl 163 length builtin function dcl 15 lisp_alloc_ 000012 constant entry external dcl 15 ref 50 58 lisp_array_fcns_$star_array 000014 constant entry external dcl 15 ref 73 214 lisp_get_atom_$hash_fcn 000010 constant entry external dcl 15 ref 77 84 110 lisp_list_utils_$subst 000022 constant entry external dcl 15 ref 187 lisp_obarray_utils_ 000015 constant entry external dcl 6 lisp_ptr based structure level 1 dcl 1-17 lisp_ptr_type based bit(36) dcl 1-17 ref 103 lisp_special_fns_$cons 000020 constant entry external dcl 15 ref 81 87 147 190 lisp_special_fns_$xcons 000016 constant entry external dcl 15 ref 198 204 lisp_static_vars_$array_atom external static fixed bin(71,0) dcl 7-6 lisp_static_vars_$binding_top external static pointer dcl 7-6 lisp_static_vars_$catch_frame external static pointer dcl 7-6 lisp_static_vars_$err_frame external static pointer dcl 7-6 lisp_static_vars_$err_recp external static pointer dcl 7-6 lisp_static_vars_$eval_frame external static pointer dcl 7-6 lisp_static_vars_$iochan_list external static pointer dcl 7-6 lisp_static_vars_$lisp_static_vars_ external static structure level 1 unaligned dcl 7-6 lisp_static_vars_$nil 000032 external static fixed bin(71,0) dcl 7-6 set ref 56* 56 62 62 70 70 72 72 79 79 86 86 121 121 155 155 159 159 178 178 181 181 193 193 197 197 lisp_static_vars_$obarray 000030 external static fixed bin(71,0) dcl 7-6 set ref 63* 63 71 71 74 74 80 80 108 108 148 148 186 186 196 196 210 lisp_static_vars_$prog_frame external static pointer dcl 7-6 lisp_static_vars_$stack_ptr 000024 external static pointer dcl 7-6 set ref 47 47 48* 48 78* 78 85* 85 113 113 114* 114 152* 152 165 165 171 171 177 177 180* 180 189* 189 191* 191 199* 199 203* 203 208* 208 215* 215 lisp_static_vars_$star_rset external static fixed bin(71,0) dcl 7-45 lisp_static_vars_$t_atom 000026 external static fixed bin(71,0) dcl 7-6 ref 211 211 lisp_static_vars_$top_level external static label variable dcl 7-6 lisp_static_vars_$tty_input_chan external static pointer dcl 7-6 lisp_static_vars_$tty_output_chan external static pointer dcl 7-6 lisp_static_vars_$unmkd_ptr external static pointer dcl 7-6 lisp_static_vars_$unwp_frame external static pointer dcl 7-6 lisp_static_vars_$user_intr_array external static fixed bin(71,0) array dcl 7-45 makoblist 000571 constant entry external dcl 175 mod builtin function dcl 15 namelen automatic fixed bin(17,0) dcl 15 nargs 000103 automatic fixed bin(17,0) dcl 15 set ref 185* 186* 195* 196* nil defined fixed bin(71,0) dcl 7-6 set ref 56* 62 70 72 79 86 121 155 159 178 181 193 197 nil_ptr based pointer dcl 7-6 obarray defined fixed bin(71,0) dcl 7-6 set ref 63* 71 74 80 108 148 186 196 obarray_struct based structure level 1 dcl 15 out 000276 constant entry external dcl 97 ref 172 pdl_ptr_types36 based structure array level 1 dcl 2-7 plist 2 based fixed bin(71,0) level 2 dcl 4-5 set ref 53* 62* pname 5 based char level 2 dcl 4-5 set ref 55* 61* 110* 124 124 pnamel 4 based fixed bin(17,0) level 2 dcl 4-5 set ref 54* 55 60* 61 110 110 124 124 prog_frame defined pointer dcl 7-6 push_down_list_ptr_types based structure array level 1 dcl 2-7 remob 000550 constant entry external dcl 169 sing_char 000002 constant label array(0:1) dcl 155 ref 111 stack 000104 automatic pointer dcl 15 set ref 47* 48 50 51 52 52 53 53 54 55 56 58 59 60 61 62 63 68 69 70 71 72 74 76 78 79 80 82 85 86 86 88 113* 114 116 117 118 121 122 122 124 127 132 135 135 138 138 140 140 145 146 149 152 165* 166 171* 172 177* 178 180 181 181 181 181 186 188 188 189 191 192 192 193 193 196 197 199 202 202 203 208 209 209 210 211 212 213 215 stack_ptr defined pointer dcl 7-6 set ref 47 48* 78* 85* 113 114* 152* 165 171 177 180* 189* 191* 199* 203* 208* 215* star_rset defined fixed bin(71,0) dcl 7-45 substr builtin function dcl 15 set ref 55* 61* t_atom defined fixed bin(71,0) dcl 7-6 ref 211 t_atom_ptr based pointer dcl 7-6 temp based fixed bin(71,0) array dcl 2-7 set ref 48 50* 52 53 56 58* 63 68 69 70* 71* 72* 74 78 79* 80* 82 85 86* 86* 88 114 116* 121 122* 127 132 138* 138 140* 145* 146* 149 166* 172* 178 180 181* 181* 181* 181* 186* 188* 188 189 191 192* 192 193* 193* 196* 197 199 202* 202 203 208 209* 209 210* 211* 212 213 215 temp_ptr based pointer array dcl 2-7 set ref 52 53 54 55 60 61 62 76 117* 122 124 135 135 140 temp_type 0(21) based bit(9) array level 2 packed unaligned dcl 2-7 set ref 51* 59* 118* tty_input_chan defined pointer dcl 7-6 tty_output_chan defined pointer dcl 7-6 type_info based bit(36) level 2 dcl 5-4 set ref 68* 212* unmkd_ptr defined pointer dcl 7-6 unwp_frame defined pointer dcl 7-6 user_intr_array defined fixed bin(71,0) array dcl 7-45 value based pointer level 2 in structure "atom_ptrs" dcl 4-5 in procedure "lisp_obarray_utils_" ref 108 148 186 196 value based fixed bin(71,0) level 2 in structure "atom" dcl 4-5 in procedure "lisp_obarray_utils_" set ref 52* 74* STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1174 1230 773 1204 Length 1606 773 34 341 200 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME lisp_obarray_utils_ 90 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME lisp_obarray_utils_ 000100 htptr lisp_obarray_utils_ 000102 indx lisp_obarray_utils_ 000103 nargs lisp_obarray_utils_ 000104 stack lisp_obarray_utils_ 000106 in_out lisp_obarray_utils_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_in call_ext_out_desc call_ext_out return ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. lisp_alloc_ lisp_array_fcns_$star_array lisp_get_atom_$hash_fcn lisp_list_utils_$subst lisp_special_fns_$cons lisp_special_fns_$xcons THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. lisp_static_vars_$nil lisp_static_vars_$obarray lisp_static_vars_$stack_ptr lisp_static_vars_$t_atom LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 6 000014 45 000022 47 000031 48 000034 50 000036 51 000050 52 000054 53 000057 54 000063 55 000067 56 000073 58 000076 59 000110 60 000114 61 000120 62 000125 63 000132 68 000134 69 000137 70 000141 71 000143 72 000145 73 000147 74 000153 76 000157 77 000163 78 000201 79 000205 80 000207 81 000211 82 000215 84 000222 85 000241 86 000245 87 000250 88 000254 90 000261 92 000262 94 000272 95 000273 97 000274 102 000303 103 000305 106 000312 108 000313 110 000321 111 000342 113 000347 114 000353 116 000355 117 000360 118 000365 121 000371 122 000376 123 000402 124 000404 127 000416 128 000420 130 000421 132 000422 135 000426 136 000432 138 000433 140 000435 141 000440 143 000441 145 000443 146 000450 147 000453 148 000457 149 000465 152 000473 153 000475 155 000476 157 000511 158 000517 159 000520 161 000525 163 000526 165 000534 166 000541 167 000546 169 000547 171 000555 172 000562 173 000567 175 000570 177 000576 178 000603 180 000606 181 000610 185 000615 186 000621 187 000636 188 000642 189 000645 190 000650 191 000654 192 000660 193 000662 194 000665 195 000667 196 000675 197 000712 198 000715 199 000721 201 000725 202 000727 203 000732 204 000735 205 000741 208 000742 209 000744 210 000746 211 000750 212 000752 213 000754 214 000756 215 000762 216 000766 ----------------------------------------------------------- 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