COMPILATION LISTING OF SEGMENT lisp_load_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-18_1125.79_Tue_mdt Options: optimize map 1 /* ************************************************************** 2* * * 3* * Copyright, (C) Massachusetts Institute of Technology, 1973 * 4* * * 5* ************************************************************** */ 6 lisp_load_: proc; 7 8 /* MACLISP load subr...takes one arg, the name of segment to be loaded, 9* and loads it, returning t */ 10 /* hacked by BSG 5/14/80 to not namedup */ 11 12 /* declarations */ 13 14 dcl (pathptr, tempp, stack, unm, object_ptr, actionp, entrp, entryp, linkp, linksp, 15 constp, blockp, sblkp, symrtp, defp) ptr; 16 17 dcl (length, addr, addrel, null, rtrim, ptr) builtin; 18 dcl array_links_blockp pointer, 19 call_array_link_snap_opr bit(36) static init("001000000001010110010111010001010000"b), 20 array_link_space fixed bin(18), 21 array_linksp pointer, 22 number_of_array_links fixed bin; 23 24 dcl constant_index fixed bin(17) aligned, 25 1 constant_index_format aligned structure based(addr(constant_index)), 26 2 unused_bits bit(18) unaligned, 27 2 load_time bit(1) unaligned, 28 2 constant_x fixed bin(16) unaligned; 29 30 dcl 1 oi aligned automatic structure like object_info; 31 32 dcl 1 error_struc based aligned, 33 2 code1 fixed bin(35), 34 2 code2 fixed bin(35); 35 36 dcl code fixed bin(35), 37 ename char (32), 38 objects(0:10000) fixed bin(71) based aligned, 39 lisp_static_vars_$no_snapped_links bit(1) external aligned, 40 lisp_static_vars_$infile ext fixed bin(71), 41 infile fixed bin(71) defined(lisp_static_vars_$infile), 42 lisp_static_vars_$instack ext fixed bin(71), 43 instack fixed bin(71) defined(lisp_static_vars_$instack), 44 ent_length fixed bin(24), 45 alloc_size fixed bin(18), 46 i fixed bin(18), 47 offset_head fixed bin, 48 bit_count fixed bin (24), 49 uname char (32), 50 51 lisp_error_ entry, 52 lisp_linker_ entry(pointer), 53 unique_chars_ entry (bit (*)) returns (char (15)), 54 hcs_$initiate_count entry (char (*), char (*), char (*), fixed bin (24), fixed bin (2), ptr, fixed bin (35)), 55 hcs_$make_ptr entry (ptr, char (*), char (*), ptr, fixed bin (35)), 56 hcs_$status_mins entry (ptr, fixed bin (2), fixed bin (24), fixed bin (35)), 57 get_definition_ entry (ptr, char(*), char(*), ptr, fixed bin(35)), 58 error_table_$segknown ext fixed bin(35), 59 lisp_alloc_ entry(fixed bin(18), fixed bin(71)), 60 lisp_alloc_$cons entry, 61 lisp_io_control_$openi entry, 62 lisp_io_control_$close entry, 63 lisp_reader_$read entry, 64 lisp_$eval entry, 65 object_info_$brief entry(ptr, fixed bin(24), ptr, fixed bin(35)), 66 lisp_property_fns_$putprop entry, 67 lisp_property_fns_$remprop entry, 68 lisp_static_vars_$defun ext ptr, 69 lisp_static_vars_$expr_hash ext fixed bin(71), 70 lisp_static_man_$allocate entry(ptr, fixed bin(18)), 71 lisp_get_atom_ entry(char(*), fixed bin(71)); 72 73 dcl lisp_static_vars_$subr ext fixed bin(71), 74 lisp_static_vars_$lsubr ext fixed bin(71), 75 lisp_static_vars_$fsubr ext fixed bin(71), 76 subr fixed bin(71) defined(lisp_static_vars_$subr), 77 lsubr fixed bin(71) defined(lisp_static_vars_$lsubr), 78 fsubr fixed bin(71) defined(lisp_static_vars_$fsubr); 79 80 dcl lisp_linkage_error condition, /* signalled by lisp_linker_ (kludge) */ 81 lisp_static_vars_$subr_block_list external pointer; 82 83 1 1 /* BEGIN INCLUDE FILE definition.incl.pl1 */ 1 2 1 3 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 1 7* audit(86-07-18,DGHowe), install(86-11-20,MR12.0-1222): 1 8* Modified to add indirect bit to definition flags. 1 9* END HISTORY COMMENTS */ 1 10 1 11 1 12 dcl 1 definition aligned based, 1 13 2 forward unal bit(18), /* offset of next def */ 1 14 2 backward unal bit(18), /* offset of previous def */ 1 15 2 value unal bit(18), 1 16 2 flags unal, 1 17 3 new bit(1), 1 18 3 ignore bit(1), 1 19 3 entry bit(1), 1 20 3 retain bit(1), 1 21 3 argcount bit(1), 1 22 3 descriptors bit(1), 1 23 3 indirect bit(1), 1 24 3 unused bit(8), 1 25 2 class unal bit(3), 1 26 2 symbol unal bit(18), /* offset of ACC for symbol */ 1 27 2 segname unal bit(18); /* offset of segname def */ 1 28 1 29 /* END INCLUDE FILE definition.incl.pl1 */ 84 2 1 /* BEGIN INCLUDE FILE lisp_iochan.incl.pl1 */ 2 2 2 3 /* This include file describes the format of the 'iochan' block, 2 4* which is used to implement lisp file-objects. The iochan 2 5* is the central data base of the i/o system. When open 2 6* is used, an iochan is created in lisp static storage. 2 7* When the lisp environment is booted, 2 iochans for input and 2 8* output on the tty are created. Iochans are saved and restored 2 9* by the save mechanism */ 2 10 2 11 /* open i/o channel information */ 2 12 2 13 dcl 1 iochan based aligned, /* format of a file object */ 2 14 2 ioindex fixed bin(24), /* 0-origin character position in block */ 2 15 2 iolength fixed bin(24), /* size of block in chars - actual(in), max(out) */ 2 16 2 ioptr pointer, /* -> block */ 2 17 2 thread pointer, /* list of all iochans open; from lisp_static_vars_$iochan_list */ 2 18 2 fcbp pointer, /* for tssi_ */ 2 19 2 aclinfop pointer, /* .. */ 2 20 2 component fixed bin, /* .. */ 2 21 2 charpos fixed bin, /* 0-origin horizontal position on line */ 2 22 2 linel fixed bin, /* (out) line length, 0 => oo */ 2 23 2 flags unaligned, 2 24 3 seg bit(1), /* 1 => msf, 0 => stream */ 2 25 3 read bit(1), /* 0 => openi, 1 => not */ 2 26 3 write bit(1), /* 0 => openo, 1 => not */ 2 27 3 gc_mark bit(1), /* for use by the garbage collector */ 2 28 3 interactive bit(1), /* 1 => input => this is the tty 2 29* output => flush buff after each op */ 2 30 3 must_reopen bit(1), /* 1 => has been saved and not reopend yet */ 2 31 3 nlsync bit(1), /* 1 => there is a NL in the buffer (output streams only) */ 2 32 3 charmode bit(1), /* enables instant ios_$write */ 2 33 3 extra_nl_done bit(1), /* 1 => last char output was extra NL for chrct */ 2 34 3 fixnum_mode bit(1), /* to be used with in and out functions */ 2 35 3 image_mode bit(1), /* just suppresses auto-cr */ 2 36 3 not_yet_used bit(25), 2 37 2 function fixed bin(71), /* EOF function (input), or endpagefn (output) <<< gc-able >>> */ 2 38 2 namelist fixed bin(71), /* list of names, car is directory pathname <<< gc-able >>> */ 2 39 2 name char(32) unaligned, /* stream name or entry name */ 2 40 2 pagel fixed bin, /* number of lines per page */ 2 41 2 linenum fixed bin, /* current line number, starting from 0 */ 2 42 2 pagenum fixed bin, /* current page number, starting from 0 */ 2 43 2 44 flag_reset_mask bit(36) aligned static init( /* anded into flags with each char */ 2 45 "111011110111111111"b); 2 46 2 47 /* END INCLUDE FILE lisp_iochan.incl.pl1 */ 85 3 1 3 2 /* BEGIN INCLUDE FILE lisp_error_codes.incl.pl1 */ 3 3 3 4 /* This contains codes to be stored on the unmkd pdl before calling 3 5* lisp_error_. These codes, at ab|-2,x7, are used by lisp_error_ 3 6* as an index into lisp_error_table_. */ 3 7 3 8 dcl ( 3 9 undefined_atom init(100), /* - correctable */ 3 10 undefined_function init(101), /* - correctable */ 3 11 too_many_args init(102), /* uncorrectable */ 3 12 too_few_args init(103), /* .. */ 3 13 file_system_error init(104), /* (obsolete) */ 3 14 bad_argument init(105), /* uncorrectable arg reject */ 3 15 undefined_subr init(106), 3 16 bad_function init(107), /* "bad functional form" */ 3 17 bad_bv init(108), /* attempt to bind non-variable */ 3 18 unseen_go_tag init(109), /* correctable -> unevaled new tag */ 3 19 throw_to_no_catch init(110), /* .. */ 3 20 nonfixedarg init(111), /* correctable */ 3 21 parenmissing init(112), /* uncorr reader error */ 3 22 doterror init(113), /* .. */ 3 23 illobj init(114), /* .. */ 3 24 badmacro init(115), /* .. */ 3 25 shortreadlist init(116), /* .. */ 3 26 badreadlist init(117), /* .. */ 3 27 array_bound_error init(118), /* corr -> (array sub1 sub2...) */ 3 28 car_cdr_error init(119), /* uncorr - car or cdr of number */ 3 29 bad_arg_correctable init(120), /* correctable arg reject */ 3 30 bad_prog_op init(121), /* uncorr fail-act: go or return */ 3 31 no_lexpr init(122), /* uncorr fail-act: args or setarg */ 3 32 wrong_no_args init(123), /* correctable wna -> new expr value */ 3 33 bad_ibase init(124), /* corr */ 3 34 bad_base init(125), /* corr */ 3 35 bad_input_source init(126), /* corr - retry i/o */ 3 36 bad_output_dest init(127), /* .. */ 3 37 nihil_ex_nihile init(128), /* uncorr - attempt to setq nil */ 3 38 not_pdl_ptr init(131), /* corr arg reject - for pdl ptr args */ 3 39 bad_f_fcn init(134), /* compiled call to fsubr with evaled args */ 3 40 overflow_err init(135), /* arithmetic overflow. */ 3 41 mismatch_super_parens init(136), /* uncorr reader error */ 3 42 no_left_super_paren init(137), /* .. */ 3 43 flonum_too_big init(138), /* .. */ 3 44 quoterror init(139), /* .. */ 3 45 badreadtable init(140), /* .. */ 3 46 badobarray init(141), /* .. */ 3 47 atan_0_0_err init(142), /* (atan 0 0) doesn't work */ 3 48 unable_to_float init(143), /* corr arg reject - (float x) */ 3 49 division_by_zero init(144), /* uncorr (should really be corr) */ 3 50 eof_in_object init(145), /* corr fail-act -> keep reading anyway */ 3 51 cant_filepos init(146), /* corr fail-act -> new expr value */ 3 52 filepos_oob init(147), /* .. */ 3 53 file_sys_fun_err init(148), /* corr f.s. err -> new expr value */ 3 54 stars_left_in_name init(149), /* .. */ 3 55 io_wrong_direction init(150), /* .. */ 3 56 file_is_closed init(151), /* .. */ 3 57 reopen_inconsistent init(152), /* .. */ 3 58 bad_entry_name init(153), /* .. */ 3 59 bad_do_format init(154), /* bad do format in interp. */ 3 60 not_an_array init(155), /* bad array-type arg */ 3 61 not_alpha_array init(156), /* bad all-alphabetic array */ 3 62 include_file_error init(157), /* %include barfed */ 3 63 stack_loss_error init(158), /* stack overflew */ 3 64 underflow_fault init(159), 3 65 zerodivide_fault init(160), 3 66 bad_array_subscript init(161), 3 67 store_not_allowed init(162), 3 68 dead_array_reference init(163), 3 69 cant_subscript_readtable init(164), 3 70 not_same_type init(165), 3 71 special_array_type init(166), 3 72 array_too_big init(167), 3 73 argument_must_be_array init(168), 3 74 store_function_misused init(169) 3 75 ) fixed bin static; 3 76 3 77 /* END INCLUDE FILE lisp_error_codes.incl.pl1 */ 86 4 1 /* BEGIN INCLUDE FILE ... object_info.incl.pl1 4 2*coded February 8, 1972 by Michael J. Spier */ 4 3 /* modified May 26, 1972 by M. Weaver */ 4 4 /* modified 15 April, 1975 by M. Weaver */ 4 5 4 6 declare 1 object_info aligned based, /* structure containing object info based, returned by object_info_ */ 4 7 2 version_number fixed bin, /* version number of current structure format (=2) */ 4 8 2 textp pointer, /* pointer to beginning of text section */ 4 9 2 defp pointer, /* pointer to beginning of definition section */ 4 10 2 linkp pointer, /* pointer to beginning of linkage section */ 4 11 2 statp pointer, /* pointer to beginning of static section */ 4 12 2 symbp pointer, /* pointer to beginning of symbol section */ 4 13 2 bmapp pointer, /* pointer to beginning of break map (may be null) */ 4 14 2 tlng fixed bin, /* length in words of text section */ 4 15 2 dlng fixed bin, /* length in words of definition section */ 4 16 2 llng fixed bin, /* length in words of linkage section */ 4 17 2 ilng fixed bin, /* length in words of static section */ 4 18 2 slng fixed bin, /* length in words of symbol section */ 4 19 2 blng fixed bin, /* length in words of break map */ 4 20 2 format, /* word containing bit flags about object type */ 4 21 3 old_format bit(1) unaligned, /* on if segment isn't in new format, i.e. has old style object map */ 4 22 3 bound bit(1) unaligned, /* on if segment is bound */ 4 23 3 relocatable bit(1) unaligned, /* on if seg has relocation info in its first symbol block */ 4 24 3 procedure bit(1) unaligned, /* on if segment is an executable object program */ 4 25 3 standard bit(1) unaligned, /* on if seg is in standard format (more than just standard map) */ 4 26 3 gate bit(1) unaligned, /* on if segment is a gate */ 4 27 3 separate_static bit(1) unaligned, /* on if static not in linkage */ 4 28 3 links_in_text bit(1) unaligned, /* on if there are threaded links in text */ 4 29 3 perprocess_static bit (1) unaligned, /* on if static is not to be per run unit */ 4 30 3 pad bit(27) unaligned, 4 31 2 entry_bound fixed bin, /* entry bound if segment is a gate */ 4 32 2 textlinkp pointer, /* ptr to first link in text */ 4 33 4 34 /* LIMIT OF BRIEF STRUCTURE */ 4 35 4 36 2 compiler char(8) aligned, /* name of processor which generated segment */ 4 37 2 compile_time fixed bin(71), /* clock reading of date/time object was generated */ 4 38 2 userid char(32) aligned, /* standard Multics id of creator of object segment */ 4 39 2 cvers aligned, /* generator version name in printable char string form */ 4 40 3 offset bit(18) unaligned, /* offset of name in words relative to base of symbol section */ 4 41 3 length bit(18) unaligned, /* length of name in characters */ 4 42 2 comment aligned, /* printable comment concerning generator or generation of segment */ 4 43 3 offset bit(18) unaligned, /* offset of comment in words relative to base of symbol section */ 4 44 3 length bit(18) unaligned, /* length of comment in characters */ 4 45 2 source_map fixed bin, /* offset, relative to base of symbol section, of source map structure */ 4 46 4 47 /* LIMIT OF DISPLAY STRUCTURE */ 4 48 4 49 2 rel_text pointer, /* pointer to text section relocation info */ 4 50 2 rel_def pointer, /* pointer to definition section relocation info */ 4 51 2 rel_link pointer, /* pointer to linkage section relocation info */ 4 52 2 rel_static pointer, /* pointer to static section relocation info */ 4 53 2 rel_symbol pointer, /* pointer to symbol section relocation info */ 4 54 2 text_boundary fixed bin, /* specifies mod of text section base boundary */ 4 55 2 static_boundary fixed bin, /* specifies mod of internal static base boundary */ 4 56 /* currently not used by system */ 4 57 2 default_truncate fixed bin, /* offset rel to symbp for binder to automatically trunc. symb sect. */ 4 58 2 optional_truncate fixed bin; /* offset rel to symbp for binder to optionally trunc. symb sect. */ 4 59 4 60 declare object_info_version_2 fixed bin int static init(2); 4 61 4 62 /* END INCLUDE FILE ... object_info.incl.pl1 */ 87 5 1 /* MACLISP Compiled SUBR Block */ 5 2 5 3 dcl 1 subr_block_head based aligned, /* this is the first part of the subr block */ 5 4 2 next_compiled_block ptr, /* for xctblt */ 5 5 2 instructions(4) bit(36), /* the common entry code */ 5 6 2 subr_code_link_offset bin(17) unal, /* points to subr code link */ 5 7 2 rest_of_tsplp bit(18) unal, /* tsplp ,ic* */ 5 8 2 gcmark bit(18) unal, /* for garbage collector to remember seeing this block */ 5 9 2 gc_length fixed bin(17) unal, /* number garbage collectable objects */ 5 10 2 constants(1000) fixed bin(71); /* the compiled constants */ 5 11 5 12 /* alternate declaration of above */ 5 13 5 14 dcl 1 subr_block_head_overlay based aligned, 5 15 2 first_word bit(36), 5 16 2 second_word aligned, 5 17 3 padding bit(28) unaligned, 5 18 3 no_links_are_snapped bit(1) unaligned, /* "1"b if no itp links in this block have been snapped */ 5 19 3 more_padding bit(7) unaligned; 5 20 5 21 5 22 5 23 dcl 1 lisp_subr_links(1000) based aligned, /* the subr links follow the constants, and are the last gc'ed items */ 5 24 2 itp_base bit(3) unal, 5 25 2 itp_info bit(27) unal, /* produced by compiler */ 5 26 2 itp_mod bit(6) unal, 5 27 2 link_opr_tv_offset bit(18) unal, 5 28 2 mbz bit(12) unal, 5 29 2 further_mod bit(6) unal; /* when itp; this is indirect */ 5 30 5 31 5 32 dcl 1 subr_entries(1000) based aligned, /* these are next in block, not gc'able */ 5 33 2 nargs bit(18) unal, 5 34 2 code_offset bit(18) unal, /* offset of entrypoint in object segment */ 5 35 2 head_offset bin(17) unal, /* offset to common entry sequence in subr_block_head */ 5 36 2 rest_of_tsx0 bit(18) unal; /* tsx0 ,ic */ 5 37 5 38 5 39 dcl 1 link_to_subr_code based aligned, /* used by lisp_linker_ to find object segment */ 5 40 2 itp_to_linker ptr, /* points to linker, reset by linker to point to base of object seg */ 5 41 2 compilation_time fixed bin(71), /* used to verify linking to correct segment */ 5 42 2 name_length fixed bin(24), /* length of subroutines name...both segname and ename */ 5 43 2 name char(0 refer(link_to_subr_code.name_length)) unal; 5 44 5 45 dcl instructions_for_subr (4) bit(36) static init("000000000000000100110010111000001111"b, 5 46 "001111111111111100110101000001001111"b, 5 47 "001111111111111110010101010001001111"b, 5 48 "111111111111111110111010000000001000"b), 5 49 tsplp_ic_ind bit(18) static init("110111000000010100"b), 5 50 tsx0_ic bit(18) static init("111000000000000100"b); 5 51 5 52 dcl 1 array_links (1000) aligned based, /* come after entries, before link_to_subr_code */ 5 53 2 instruction bit(36) aligned, /* tspbp to array_link_snap operator 5 54* or eppbb *+2,* when snapped */ 5 55 2 control_word unaligned, /* controls what to snap to */ 5 56 3 type fixed bin(8), /* 0=S-expr, 2=fixnum, 3=flonum */ 5 57 3 ndims fixed bin(8), 5 58 3 atomic_symbol fixed bin(17), /* offset in constants to symbol which names array */ 5 59 2 pointer pointer; /* -> array_info block when snapped */ 5 60 5 61 dcl 1 array_link_count aligned based, /* comes after array_links, before link_to_subr_code */ 5 62 2 unused bit(36), 5 63 2 number_of_array_links fixed bin(17) unaligned, 5 64 2 must_be_zero bit(18) unaligned; /* 0 to distinguish from tsx0 in subr block with no array links */ 5 65 5 66 /* End of description of Compiled SUBR Block */ 88 6 1 /* include file lisp_stack_fmt.incl.pl1 -- 6 2* describes the format of the pushdown list 6 3* used by the lisp evaluator and lisp subrs 6 4* for passing arguments, saving atom bindings, 6 5* and as temporaries */ 6 6 6 7 dcl 6 8 temp(10000) fixed bin(71) aligned based, 6 9 6 10 temp_ptr(10000) ptr aligned based, 6 11 1 push_down_list_ptr_types(10000) based aligned, 6 12 2 junk bit(21) unaligned, 6 13 2 temp_type bit(9) unaligned, 6 14 2 more_junk bit(42) unaligned, 6 15 6 16 1 pdl_ptr_types36(10000) based aligned, 6 17 2 temp_type36 bit(36), 6 18 2 junk bit(36), 6 19 6 20 1 binding_block aligned based, 6 21 2 top_block bit(18) unaligned, 6 22 2 bot_block bit(18) unaligned, /* these two are rel pointers into the marked PDL */ 6 23 2 back_ptr bit(18) unaligned, /* relative pointer into unmarked PDL for last binding block. */ 6 24 2 rev_ptr bit(18) unaligned, /* relative pointer to reversal bb which reversed this one, init to 0 */ 6 25 6 26 1 bindings(10000) based aligned, /* format fof bindings on stack */ 6 27 2 old_val fixed bin(71) aligned, 6 28 2 atom fixed bin(71) aligned; 6 29 6 30 6 31 6 32 /* end include file lisp_stack_fmt.incl.pl1 */ 89 7 1 /* MACLISP symbol section for compiled SUBR */ 7 2 7 3 dcl 1 symbol_root based aligned, /* starts off the LISP symbol section */ 7 4 7 5 2 version fixed bin, /* 2 for this dcl (new-arrays version) */ 7 6 2 number_objects fixed bin, /* number of objects which are to be made at fasload time */ 7 7 2 objects unal, 7 8 3 fixnum_blockp bit(18) unal, /* pointers to blocks describing variaous type classes of objects */ 7 9 3 flonum_blockp bit(18) unal, 7 10 3 string_blockp bit(18) unal, 7 11 3 bignum_blockp bit(18) unal, 7 12 3 atsym_blockp bit(18) unal, 7 13 3 cons_blockp bit(18) unal, 7 14 2 subr_block_size fixed bin(18), /* number of double word items to be put in subr block */ 7 15 2 subr_block_items unal, /* pointers to blocks indicating which objects to place in subr block */ 7 16 3 entry_blockp bit(18) unal, 7 17 3 const_blockp bit(18) unal, 7 18 3 links_blockp bit(18) unal, 7 19 2 action_blockp bit(18) unal, /* points to array of operations to be done at fasload time, in order */ 7 20 2 array_links_blockp bit(18) unal; /* points at block of array links */ 7 21 7 22 7 23 dcl 1 fixnum_block based aligned, 7 24 2 count fixed bin(18), 7 25 2 fixnums(0 refer(fixnum_block.count)) fixed bin(35); 7 26 7 27 dcl 1 flonum_block based aligned, 7 28 2 count fixed bin(18), 7 29 2 flonums(0 refer(flonum_block.count)) float bin(27); 7 30 7 31 dcl 1 string_block based aligned, 7 32 2 count fixed bin(18), 7 33 2 string_offset(0 refer(string_block.count)) bit(18) unal; /* pointers to string representation */ 7 34 7 35 7 36 dcl 1 atsym_block based aligned, 7 37 2 count fixed bin(18), 7 38 2 atsym_offset(0 refer(atsym_block.count)) bit(18) unal; /* pointers to atom names */ 7 39 7 40 dcl 1 bignum_block based aligned, 7 41 2 count fixed bin(18), 7 42 2 bignum_offsets(0 refer(bignum_block.count)) bit(18) unal; 7 43 7 44 dcl 1 cons_block based aligned, 7 45 2 count fixed bin(18), 7 46 2 conses(0 refer(cons_block.count)) unal, 7 47 3 car bin(17), 7 48 3 cdr bin(17); 7 49 7 50 dcl 1 string_chars based aligned, 7 51 2 flags unal, 7 52 3 uninterned_atom bit(1), 7 53 3 padding bit(10), 7 54 2 length fixed bin(24)unal, 7 55 2 chars char(0 refer (string_chars.length)) unaligned; 7 56 7 57 dcl 1 entry_block based aligned, 7 58 2 count fixed bin(18), 7 59 2 entry_info(0 refer(entry_block.count)) unal, 7 60 3 nargs bit(18), 7 61 3 entrypoint bit(18); 7 62 7 63 dcl 1 const_block based aligned, 7 64 2 count fixed bin(18), 7 65 2 constants (0 refer(const_block.count)) fixed bin(17) unal; 7 66 7 67 dcl 1 links_block based aligned, 7 68 2 count fixed bin(18), 7 69 2 link_info(0 refer(links_block.count)) bit(27); 7 70 7 71 dcl 1 array_links_block based aligned, 7 72 2 count fixed bin(18), 7 73 2 array_link(0 refer(array_links_block.count)), 7 74 3 control_word bit(36); /* rest is filled in at load time. 7 75* this word has type, ndims, symbol offset. */ 7 76 7 77 dcl 1 action_block based aligned, 7 78 2 count fixed bin(18), 7 79 2 actions(0 refer(action_block.count)) unal, /* each action described as one of these objects */ 7 80 3 action_code fixed bin(17) unal, 7 81 3 operand fixed bin(17) unal; /* offset of constant which is used in operation */ 7 82 7 83 /* End of description of MACLISP Compiled symbol tree */ 90 8 1 /* BEGIN INCLUDE SEGMENT ... symbol_block.incl.pl1 8 2*coded February 8, 1972 by Michael J. Spier */ 8 3 8 4 /* last modified may 3, 1972 by M. Weaver */ 8 5 8 6 declare 1 sb aligned based(sblkp), /* structure describing a standard symbol block */ 8 7 2 decl_vers fixed bin, /* version number of current structure format */ 8 8 2 identifier char(8) aligned, /* symbolic code to define purpose of this symb block */ 8 9 2 gen_version_number fixed bin, /* positive integer designating version of object generator */ 8 10 2 gen_creation_time fixed bin(71), /* clock reading of date/time generator was created */ 8 11 2 obj_creation_time fixed bin(71), /* clock reading of date/time object was generated */ 8 12 2 generator char(8) aligned, /* name of processor which generated segment */ 8 13 2 gen_name_offset bit(18) unaligned, /* offset of generator name in words rel to base of symbol block */ 8 14 2 gen_name_length bit(18) unaligned, /* length of printable generator version name in characters */ 8 15 2 uid_offset bit(18) unaligned, /* offset of creator id in words rel to base of symbol block */ 8 16 2 uid_length bit(18) unaligned, /* length of standard Multics id of object creator in characters */ 8 17 2 comment_offset bit(18) unaligned, /* offset of comment in words relative to base of symbol block */ 8 18 2 comment_length bit(18) unaligned, /* length of printable generator comment in characters */ 8 19 2 tbound bit(18) unaligned, /* specifies mod of text section base boundary */ 8 20 2 stat_bound bit(18) unaligned, /* specifies mod of internal static base boundary */ 8 21 2 source_map bit(18) unaligned, /* offset relative to base of symbol block of source map structure */ 8 22 2 area_ptr bit(18) unaligned, /* offset of block info in words relative to base of symbol block */ 8 23 2 symb_base bit(18) unaligned, /* back pointer (rel to base of symb block) to base of symb section */ 8 24 2 block_size bit(18) unaligned, /* size in words of entire symbol block */ 8 25 2 next_block bit(18) unaligned, /* if ^= "0"b, is thread (rel to base of symb section) to next symb block */ 8 26 2 rel_text bit(18) unaligned, /* offset rel to base of symbol block of text sect relocation info */ 8 27 2 rel_def bit(18) unaligned, /* offset rel to base of symb block of def section relocation info */ 8 28 2 rel_link bit(18) unaligned, /* offset rel to base of symb block of link sect relocation info */ 8 29 2 rel_symb bit(18) unaligned, /* offset rel to base of symb block of symb sect relocation info */ 8 30 2 default_truncate bit(18) unaligned, /* offset RTBOSB for binder to automatically trunc. symb sect. */ 8 31 2 optional_truncate bit(18) unaligned; /* offset RTBOSB for binder to optionally truncate symb section */ 8 32 8 33 /* END INCLUDE SEGMENT ... symbol_block.incl.pl1 */ 91 92 9 1 /* lisp number format -- overlaid on standard its pointer. */ 9 2 9 3 9 4 dcl 1 fixnum_fmt based aligned, 9 5 2 type_info bit(36) aligned, 9 6 2 fixedb fixed bin, 9 7 9 8 1 flonum_fmt based aligned, 9 9 2 type_info bit(36) aligned, 9 10 2 floatb float bin, 9 11 9 12 fixnum_type bit(36) aligned static init("000000000000000000000100000000100111"b), 9 13 flonum_type bit(36) aligned static init("000000000000000000000010000000100111"b); 9 14 9 15 /* end of lisp number format */ 9 16 93 10 1 /* Include file lisp_atom_fmt.incl.pl1; 10 2* describes internal format of atoms in the lisp system 10 3* D.Reed 4/1/71 */ 10 4 10 5 dcl 1 atom aligned based, /* overlay for atom fomat */ 10 6 2 value fixed bin(71), /* atom's value */ 10 7 2 plist fixed bin(71), /* property list */ 10 8 2 pnamel fixed bin, /* length of print name */ 10 9 2 pname char(1 refer(pnamel)), /* print name of atom */ 10 10 10 11 1 atom_ptrs based aligned, /* for use of plist and value of atom as ptrs */ 10 12 2 value ptr, 10 13 2 plist ptr, 10 14 10 15 1 atom_double_words based aligned, /* overlay for atom pointer checking */ 10 16 2 value bit(72), 10 17 2 plist bit(72); 10 18 10 19 /* end of include file lisp_atom_fmt.incl.pl1 */ 94 11 1 /* Include file lisp_common_vars.incl.pl1; 11 2* describes the external static variables which may be referenced 11 3* by lisp routines. 11 4* D. Reed 4/1/71 */ 11 5 11 6 dcl 1 lisp_static_vars_$lisp_static_vars_ external, 11 7 2 cclist_ptr ptr, /* pointer to list of constants kept 11 8* by compiled programs */ 11 9 2 garbage_collect_soon bit(1) aligned, /* if this is on we should garbage collect soon */ 11 10 11 11 lisp_static_vars_$err_recp ptr ext aligned, /* pointer to error data */ 11 12 err_recp ptr defined (lisp_static_vars_$err_recp), 11 13 eval_frame ptr defined (lisp_static_vars_$eval_frame), /* info kept by eval if *rset t */ 11 14 lisp_static_vars_$eval_frame ptr ext static, 11 15 lisp_static_vars_$prog_frame ptr ext aligned, 11 16 lisp_static_vars_$err_frame ptr ext aligned, 11 17 lisp_static_vars_$catch_frame ptr ext aligned, 11 18 lisp_static_vars_$unwp_frame ptr ext aligned, 11 19 lisp_static_vars_$stack_ptr ptr ext aligned, 11 20 lisp_static_vars_$t_atom fixed bin(71) ext aligned, 11 21 lisp_static_vars_$top_level label ext, /* top level read_eval_print loop */ 11 22 lisp_static_vars_$unmkd_ptr ptr ext aligned, 11 23 lisp_static_vars_$binding_top ptr ext aligned, 11 24 lisp_static_vars_$obarray fixed bin(71) aligned ext, 11 25 obarray fixed bin(71) defined (lisp_static_vars_$obarray), 11 26 lisp_static_vars_$array_atom fixed bin(71) aligned ext, 11 27 array_atom fixed bin(71) defined (lisp_static_vars_$array_atom), 11 28 binding_top ptr defined (lisp_static_vars_$binding_top), 11 29 unmkd_ptr ptr defined (lisp_static_vars_$unmkd_ptr), 11 30 stack_ptr ptr defined (lisp_static_vars_$stack_ptr), 11 31 lisp_static_vars_$nil ext static fixed bin(71) aligned, 11 32 nil fixed bin(71) defined (lisp_static_vars_$nil), 11 33 lisp_static_vars_$tty_input_chan ext static ptr, /* used by the reader */ 11 34 lisp_static_vars_$tty_output_chan ext static ptr, /*used by print*/ 11 35 tty_input_chan ptr def (lisp_static_vars_$tty_input_chan), 11 36 tty_output_chan ptr def (lisp_static_vars_$tty_output_chan), 11 37 lisp_static_vars_$iochan_list external pointer, /* list of all open iochans */ 11 38 nil_ptr ptr based(addr(lisp_static_vars_$nil)) aligned, 11 39 prog_frame ptr def (lisp_static_vars_$prog_frame), /* 3 ptrs for use of lisp_prog_fns_ */ 11 40 err_frame ptr def (lisp_static_vars_$err_frame), /* they point out frames in unmkd pdl */ 11 41 catch_frame ptr def (lisp_static_vars_$catch_frame), 11 42 unwp_frame ptr def (lisp_static_vars_$unwp_frame), 11 43 t_atom_ptr ptr aligned based(addr(lisp_static_vars_$t_atom)), 11 44 t_atom fixed bin(71) defined (lisp_static_vars_$t_atom); /* pointer to atom t */ 11 45 dcl lisp_static_vars_$user_intr_array(20) fixed bin(71) aligned ext static, /* -> atoms whose values are intr service functions */ 11 46 user_intr_array (20) fixed bin(71) aligned def (lisp_static_vars_$user_intr_array), 11 47 lisp_static_vars_$star_rset fixed bin(71) aligned ext static, 11 48 star_rset fixed bin(71) aligned def (lisp_static_vars_$star_rset); 11 49 11 50 11 51 /* end include file lisp_common_vars.incl.pl1 */ 95 12 1 /* BEGIN INCLUDE FILE lisp_control_chars.incl.pl1 */ 12 2 12 3 /* Last modified D. Reed 6/29/72 */ 12 4 12 5 dcl lisp_static_vars_$ctrlD ext fixed bin(71), 12 6 ctrlD fixed bin(71) defined (lisp_static_vars_$ctrlD); 12 7 12 8 dcl lisp_static_vars_$ctrlQ ext fixed bin(71), 12 9 ctrlQ fixed bin(71) defined (lisp_static_vars_$ctrlQ); 12 10 12 11 dcl lisp_static_vars_$ctrlR ext fixed bin(71), 12 12 ctrlR fixed bin(71) defined (lisp_static_vars_$ctrlR); 12 13 12 14 dcl lisp_static_vars_$ctrlW ext fixed bin(71), 12 15 ctrlW fixed bin(71) defined (lisp_static_vars_$ctrlW); 12 16 12 17 /* END INCLUDE FILE lisp_control_chars.incl.pl1 */ 12 18 96 13 1 /* Include file lisp_ptr_fmt.incl.pl1; 13 2* describes the format of lisp pointers as 13 3* a bit string overlay on the double word ITS pair 13 4* which allows lisp to access some unused bits in 13 5* the standard ITS pointer format. It should be noted that 13 6* this is somewhat of a kludge, since 13 7* it is quite machine dependent. However, to store type 13 8* fields in the pointer, saves 2 words in each cons, 13 9* plus some efficiency problems. 13 10* 13 11* D.Reed 4/1/71 */ 13 12 /* modified to move type field to other half of ptr */ 13 13 /* D.Reed 5/31/72 */ 13 14 13 15 13 16 dcl based_ptr ptr aligned based; /* for dealing with lisp values as pointers */ 13 17 dcl lisp_ptr_type bit(36) aligned based, /* for more efficient checking of type bits */ 13 18 1 lisp_ptr based aligned, /* structure of double word pointer in lisp */ 13 19 2 segno bit(18) unaligned, /* segment number pointed to by pointer */ 13 20 2 ringnum bit(3) unaligned, /* ring mumber for validation */ 13 21 2 type bit(9) unaligned, /* type field */ 13 22 2 itsmod bit(6) unaligned, 13 23 2 offset fixed bin(17) unaligned, /* offset in segment of object pointed to */ 13 24 2 chain bit(18) unaligned, /* normally 0, but may be set to chain pointers together */ 13 25 13 26 /* manifest constant strings for testing above type field */ 13 27 13 28 ( 13 29 Cons init("000000000"b), /* a pointer to a list has a zero type field */ 13 30 Fixed init("100000000"b), /* a fixed point number, stored in second word of the ptr */ 13 31 Float init("010000000"b), /* a floating number, also stored in the second word of the ptr */ 13 32 Atsym init("001000000"b), /* this bit on means a ptr to an atomic symbol */ 13 33 Atomic init("111111111"b), /* any bit on means an atomic data type */ 13 34 Bignum init("000001000"b), /* a multiple-precision number */ 13 35 Bigfix init("000001000"b), /* a fixed point bignum (only kind for now) */ 13 36 Numeric init("110000000"b), /* either type immediate number. Both bits on 13 37* means a special internal uncollectable weird object */ 13 38 Uncollectable init("110000000"b), /* not looked through by garbage collector */ 13 39 String init("000100000"b), /* pointer to lisp character string - length word, chars */ 13 40 Subr init("000010000"b), /* pointer to compiled (or builtin) subroutine (linkage) code */ 13 41 System_Subr init("000000100"b), /* Subr bit must be on too, indicates ptr into lisp_subr_tv_ */ 13 42 Array init("000000010"b), /* Subr bit must be on too, indicates ptr to a lisp array */ 13 43 File init("000000001"b) /* pointer to a file object (iochan block) */ 13 44 ) bit(9) static, 13 45 13 46 /* 36 bit manifest constant strings for testing lisp_ptr_type */ 13 47 13 48 13 49 ( 13 50 Cons36 init("000000000000000000000000000000"b), 13 51 Fixed36 init("000000000000000000000100000000"b), 13 52 Float36 init("000000000000000000000010000000"b), 13 53 Atsym36 init("000000000000000000000001000000"b), 13 54 Atomic36 init("000000000000000000000111111100"b), 13 55 Bignum36 init("000000000000000000000000001000"b), 13 56 System_Subr36 13 57 init("000000000000000000000000000100"b), 13 58 Bigfix36 init("000000000000000000000000001000"b), 13 59 Numeric36 init("000000000000000000000110000000"b), /* does not check for bignum */ 13 60 NotConsOrAtsym36 13 61 init("000000000000000000000110111111"b), 13 62 SubrNumeric36 13 63 init("000000000000000000000110010000"b), /* used in garbage collector, for quick check */ 13 64 String36 init("000000000000000000000000100000"b), 13 65 Subr36 init("000000000000000000000000010000"b), 13 66 File36 init("000000000000000000000000000001"b), 13 67 Array36 init("000000000000000000000000000010"b)) bit(36) aligned static, 13 68 13 69 /* undefined pointer value is double word of zeros */ 13 70 13 71 Undefined bit(72) static init(""b); 13 72 13 73 /* end of include file lisp_ptr_fmt.incl.pl1 */ 97 14 1 /* Include file lisp_bignum_fmt.incl.pl1 */ 14 2 14 3 dcl 1 lisp_bignum based aligned, /* structure describing lisp big number */ 14 4 2 sign bit(18) unaligned, /* either all ones, or all zeros */ 14 5 2 prec fixed bin(17) unaligned, /* number of words in this number's precision */ 14 6 2 words(0 refer(lisp_bignum.prec)) fixed bin(35); /* 35 significant bits per word. */ 14 7 14 8 /* End include file lisp_bognum_fmt.incl.pl1 */ 98 15 1 /***** BEGIN INCLUDE FILE lisp_string_fmt.incl.pl1 ***** 15 2* describes format of storage for lisp 15 3* character strings. 15 4* D. Reed 4/1/71 */ 15 5 15 6 dcl 1 lisp_string based aligned, 15 7 2 string_length fixed bin, 15 8 2 string char(1 refer(string_length)); 15 9 15 10 /***** END INCLUDE FILE lisp_string_fmt.incl.pl1 */ 99 16 1 /* Include file lisp_cons_fmt.incl.pl1; 16 2* defines the format for a cons within the lisp system 16 3* D.Reed 4/1/71 */ 16 4 16 5 dcl consptr ptr, 16 6 1 cons aligned based (consptr), /* structure defining format for cons */ 16 7 2 car fixed bin(71), 16 8 2 cdr fixed bin(71), 16 9 16 10 1 cons_ptrs aligned based (consptr), /* for using car and cdr as pointers */ 16 11 2 car ptr, 16 12 2 cdr ptr, 16 13 16 14 16 15 1 cons_types aligned based (consptr), /* structure for extracting types out of cons */ 16 16 2 padding bit(21) unaligned, 16 17 2 car bit(9) unaligned, 16 18 2 padding2 bit(63) unaligned, 16 19 2 cdr bit(9) unaligned, 16 20 2 padend bit(42) unaligned; 16 21 16 22 dcl 1 cons_types36 aligned based, 16 23 2 car bit(36), 16 24 2 pada bit(36), 16 25 2 cdr bit(36), 16 26 2 padd bit(36); 16 27 16 28 16 29 /* end include file lisp_cons_fmt.incl.pl1 */ 100 101 102 103 104 105 /* get argument and locate segment we are to load */ 106 107 stack = addrel(stack_ptr, -2); 108 stack_ptr = addr(stack -> temp(3)); 109 stack -> temp(2) = stack -> temp(1); 110 call lisp_io_control_$openi; /* open the file */ 111 112 if ^ stack -> temp_ptr(2) -> iochan.flags.seg then go to load_ascii_file; 113 114 /* validate files object segment-ness */ 115 116 uname = unique_chars_ (""b); 117 ename = stack -> temp_ptr(2) -> iochan.name; 118 call hcs_$initiate_count 119 ((addr (stack -> temp_ptr(2) -> iochan.namelist) -> based_ptr -> cons_ptrs.car -> atom.pname), 120 ename, uname, bit_count, (0), tempp, code); 121 if tempp = null then go to fserror; 122 oi.version_number = object_info_version_2; 123 124 call object_info_$brief(tempp, bit_count, addr (oi), code); 125 if code ^= 0 then go to load_ascii_file; 126 127 call hcs_$make_ptr (null (), ename, "symbol_table", sblkp, code); 128 /* This croque gets the linkage section combined */ 129 130 131 call get_definition_ (oi.defp, ename, "symbol_table", tempp, code); 132 if code ^= 0 then do; 133 fserror: unm = unmkd_ptr; 134 unmkd_ptr = addrel(unm,2); 135 unm -> error_struc.code1 = file_sys_fun_err; 136 unm -> error_struc.code2 = code; 137 stack_ptr = addr(stack->temp(5)); 138 stack -> temp(4) = nil; 139 stack -> temp(3) = stack -> temp(1); 140 call lisp_get_atom_("load", stack -> temp(2)); 141 call lisp_alloc_$cons; 142 call lisp_alloc_$cons; 143 call lisp_error_; 144 call lisp_io_control_$close; 145 stack -> temp(1) = stack -> temp(2); 146 stack_ptr = addr(stack -> temp(2)); 147 return; 148 end; 149 150 sblkp = addrel (oi.symbp, tempp -> definition.value); 151 152 if sblkp -> sb.generator ^= "lisp" | /* make sure is lisp obj seg!! */ 153 sblkp -> sb.gen_version_number ^= 2 then do; /* must be old defs file crock */ 154 dcl 1 err_msg static aligned structure, /* make msg to type out */ 155 2 lth fixed bin(8) unaligned init(56), 156 2 msg char(56) unaligned init( 157 "This format of object segment no longer supported - load"), 158 packed_ptr unaligned pointer; 159 160 packed_ptr = addr(err_msg); 161 unspec(code) = unspec(packed_ptr); /* kludge it up for convert_status_code_ */ 162 go to fserror; 163 end; 164 165 call bind_io_atoms; 166 stack = addr(stack->temp(9)); 167 /* protect the bindings carefully */ 168 symrtp = addrel(sblkp, sblkp -> sb.area_ptr); /* get pointer to lisp's data */ 169 170 171 /* we must now create the data which will be used in this loading phase */ 172 173 stack_ptr = addr(stack -> temp(symrtp -> symbol_root.number_objects + 3)); 174 stack -> temp(2) = nil; /* first object */ 175 object_ptr = addr(stack -> temp(3)); 176 177 /* now create all the fixnums needed in this phase */ 178 179 blockp = addrel(symrtp, symrtp -> symbol_root.objects.fixnum_blockp); 180 181 do i = 1 to blockp -> fixnum_block.count; 182 object_ptr -> fixnum_fmt.type_info = fixnum_type; 183 object_ptr -> fixnum_fmt.fixedb = blockp -> fixnum_block.fixnums(i); 184 object_ptr = addr(object_ptr -> objects(1)); 185 end; 186 187 /* flonums */ 188 189 blockp = addrel(symrtp, symrtp -> symbol_root.objects.flonum_blockp); 190 191 do i = 1 to blockp -> flonum_block.count; 192 object_ptr -> flonum_fmt.type_info = flonum_type; 193 object_ptr -> flonum_fmt.floatb = blockp -> flonum_block.flonums(i); 194 object_ptr = addr(object_ptr -> objects(1)); 195 end; 196 197 /* strings */ 198 199 blockp = addrel(symrtp, symrtp -> symbol_root.objects.string_blockp); 200 201 do i = 1 to blockp -> string_block.count; 202 tempp = addrel(symrtp, blockp -> string_block.string_offset(i)); 203 alloc_size = 2*divide(tempp -> string_chars.length+11,8,17,0); 204 call lisp_alloc_(alloc_size, object_ptr -> objects(0)); 205 object_ptr -> based_ptr -> lisp_string.string_length = tempp -> string_chars.length; 206 object_ptr -> lisp_ptr_type = object_ptr -> lisp_ptr_type | String36; 207 object_ptr -> based_ptr -> lisp_string.string = tempp -> string_chars.chars; 208 object_ptr = addr(object_ptr -> objects(1)); 209 end; 210 211 /* bignums */ 212 213 blockp = addrel(symrtp, symrtp -> symbol_root.objects.bignum_blockp); 214 215 do i = 1 to blockp -> bignum_block.count; 216 217 tempp = addrel (symrtp, blockp -> bignum_block.bignum_offsets(i)); 218 alloc_size = 2*divide(1+tempp -> lisp_bignum.prec,2,17,0); 219 call lisp_alloc_(alloc_size, object_ptr -> objects(0)); 220 object_ptr -> based_ptr -> lisp_bignum.sign = tempp -> lisp_bignum.sign; 221 object_ptr -> based_ptr -> lisp_bignum.prec = tempp -> lisp_bignum.prec; 222 object_ptr -> based_ptr -> lisp_bignum.words = tempp -> lisp_bignum.words; 223 object_ptr -> lisp_ptr_type = object_ptr -> lisp_ptr_type | Bignum36; 224 object_ptr = addr(object_ptr -> objects(1)); 225 end; 226 227 /* atsyms */ 228 blockp = addrel(symrtp, symrtp -> symbol_root.objects.atsym_blockp); 229 230 do i = 1 to blockp -> atsym_block.count; 231 232 tempp = addrel(symrtp, blockp -> atsym_block.atsym_offset(i)); 233 if tempp->string_chars.flags.uninterned_atom 234 then do; 235 call lisp_alloc_(2*divide(tempp->string_chars.length+27,8,17,0), object_ptr->objects(0)); 236 object_ptr -> lisp_ptr_type = object_ptr -> lisp_ptr_type | Atsym36; 237 object_ptr -> based_ptr -> atom.value = 0; 238 object_ptr -> based_ptr -> atom.plist = nil; 239 object_ptr -> based_ptr -> atom.pnamel = tempp -> string_chars.length; 240 object_ptr -> based_ptr -> atom.pname = tempp -> string_chars.chars; 241 end; 242 else call lisp_get_atom_(tempp -> string_chars.chars, object_ptr -> objects(0)); 243 object_ptr = addr(object_ptr -> objects(1)); 244 end; 245 246 /* now make the conses of these items which are used in this loading phase */ 247 248 blockp = addrel(symrtp, symrtp -> symbol_root.objects.cons_blockp); 249 tempp = stack_ptr; 250 251 do i = 1 to blockp -> cons_block.count; 252 stack_ptr = addr(tempp -> temp(3)); /* room for args to cons */ 253 tempp -> temp(1) = stack -> objects(blockp -> cons_block.conses(i).car+1); 254 tempp -> temp(2) = stack -> objects(blockp -> cons_block.conses(i).cdr+1); 255 call lisp_alloc_$cons; 256 object_ptr -> objects(0) = tempp -> temp(1); 257 object_ptr = addr(object_ptr -> objects(1)); 258 end; 259 260 object_ptr = addr(stack -> temp(2)); 261 262 if symrtp -> symbol_root.version >= 2 then do; /* count array links */ 263 array_links_blockp = addrel(symrtp, symrtp -> symbol_root.array_links_blockp); 264 number_of_array_links = array_links_blockp -> array_links_block.count; 265 if number_of_array_links ^= 0 266 then array_link_space = 4*number_of_array_links + 2; 267 else array_link_space = 0; 268 end; 269 else number_of_array_links, array_link_space = 0; 270 271 /* now create the subr block for this object segment */ 272 273 if symrtp -> symbol_root.subr_block_size = 0 then go to no_subr_block; 274 ent_length = length (rtrim (ename)); 275 276 alloc_size = symrtp -> symbol_root.subr_block_size*2+13+divide(ent_length+3,4,17,0)+array_link_space; 277 278 call lisp_static_man_$allocate (blockp, alloc_size); 279 280 blockp -> subr_block_head.instructions = instructions_for_subr; 281 blockp -> subr_block_head.subr_code_link_offset = 2*symrtp -> symbol_root.subr_block_size+2+array_link_space; 282 blockp -> subr_block_head.gcmark = "0"b; 283 blockp -> subr_block_head.rest_of_tsplp = tsplp_ic_ind; 284 constp = addrel(symrtp, symrtp -> symbol_root.const_blockp); 285 linksp = addrel(symrtp, symrtp -> symbol_root.links_blockp); 286 entryp = addrel(symrtp, symrtp -> symbol_root.entry_blockp); 287 blockp -> subr_block_head.gc_length = constp -> const_block.count + linksp -> links_block.count; 288 289 /* now fill in constants to be placed in subr block for use of compiled code */ 290 291 do i = 1 to constp -> const_block.count; 292 constant_index = constp -> const_block.constants(i); 293 blockp -> subr_block_head.constants(i) = 294 object_ptr -> objects(constant_index_format.constant_x); 295 if constant_index_format.load_time then do; /*load-time eval*/ 296 tempp = stack_ptr; 297 stack_ptr = addr(tempp -> temp(2)); 298 tempp -> temp(1) = blockp -> subr_block_head.constants(i); 299 call lisp_$eval; 300 blockp -> subr_block_head.constants(i) = tempp -> temp(1); 301 stack_ptr = tempp; 302 end; 303 end; 304 305 /* now fill in the itp links to other subroutines */ 306 307 call generate_links; 308 309 generate_links: proc; 310 linkp = addr(blockp -> subr_block_head.constants(constp -> const_block.count+1)); 311 312 do i = 1 to linksp -> links_block.count; 313 linkp -> lisp_subr_links(i).itp_base = "001"b; /* ab */ 314 linkp -> lisp_subr_links(i).itp_info = linksp -> links_block.link_info(i); 315 linkp -> lisp_subr_links(i).itp_mod = "100001"b; /* itp */ 316 linkp -> lisp_subr_links(i).link_opr_tv_offset = "000000000000011010"b; /* 26 decimal */ 317 linkp -> lisp_subr_links(i).mbz = "0"b; 318 linkp -> lisp_subr_links(i).further_mod = "010000"b; /* indirect */ 319 end; 320 end generate_links; 321 322 323 /* now fill in the entry point code for each subroutine */ 324 325 entrp = addr(linkp -> lisp_subr_links(linksp -> links_block.count+1)); 326 327 offset_head = -2*(linksp -> links_block.count+constp -> const_block.count)-7; 328 do i = 1 to entryp -> entry_block.count; 329 entrp -> subr_entries(i).nargs = entryp -> entry_block.entry_info(i).nargs; 330 entrp -> subr_entries(i).code_offset = entryp -> entry_block.entry_info(i).entrypoint; 331 entrp -> subr_entries(i).head_offset = offset_head; 332 offset_head = offset_head - 2; 333 entrp -> subr_entries(i).rest_of_tsx0 = tsx0_ic; 334 end; 335 336 array_linksp = addr(entrp -> subr_entries(entryp -> entry_block.count+1)); 337 if number_of_array_links ^= 0 then call generate_array_links; 338 tempp = array_linksp; /* next free doubleword */ 339 340 generate_array_links: procedure; 341 342 do i = 1 to number_of_array_links; 343 array_linksp -> array_links(i).instruction = call_array_link_snap_opr; 344 unspec(array_linksp -> array_links(i).control_word) = 345 array_links_blockp -> array_links_block.control_word(i); 346 array_linksp -> array_links(i).pointer = null; 347 end; 348 array_linksp = addr(array_linksp -> array_links(i)); 349 array_linksp -> array_link_count.number_of_array_links = number_of_array_links; 350 array_linksp -> array_link_count.must_be_zero = ""b; 351 array_linksp = addrel(array_linksp, 2); 352 end generate_array_links; 353 354 call get_definition_ (oi.defp, ename, "*segtop", defp, code); 355 if code ^= 0 then go to fserror; 356 tempp -> link_to_subr_code.itp_to_linker = addrel (oi.textp, defp -> definition.value); 357 358 tempp -> lisp_subr_links(1).further_mod = "001000"b; /* x0 */ 359 360 tempp -> link_to_subr_code.compilation_time = sblkp -> sb.obj_creation_time; 361 tempp -> link_to_subr_code.name_length = ent_length; 362 tempp -> link_to_subr_code.name = ename; 363 364 /* thread this block onto list of subr blocks */ 365 366 blockp -> subr_block_head_overlay.no_links_are_snapped = "1"b; /**** CHANGE THIS IF PRE-LINKING IS IMPLEMENTED ****/ 367 blockp -> subr_block_head.next_compiled_block = lisp_static_vars_$subr_block_list; 368 lisp_static_vars_$subr_block_list = blockp; 369 370 no_subr_block: 371 372 /* now that we have completed the subr block, we must execute the action list */ 373 374 tempp = stack_ptr; 375 stack_ptr = addr(tempp -> temp(3)); 376 if symrtp -> symbol_root.subr_block_size > 0 377 then alloc_size = entryp -> entry_block.count; /* how many entries are there to define */ 378 else alloc_size = 0; 379 if alloc_size ^= 0 380 then do; 381 tempp -> temp_ptr(1) = entrp; 382 tempp -> lisp_ptr_type = tempp -> lisp_ptr_type | Subr36; 383 end; 384 385 actionp = addrel(symrtp, symrtp -> symbol_root.action_blockp); 386 387 do i = 1 to actionp -> action_block.count; 388 tempp -> temp(2) = object_ptr -> objects(actionp->action_block.actions(i).operand); 389 go to action(actionp -> action_block.actions(i).action_code); 390 391 action(0): /* evaluate object operand */ 392 call lisp_$eval; 393 go to endaction; 394 395 action(1): /* define operand as subr */ 396 stack_ptr = addr(tempp -> temp(7)); 397 tempp -> temp(4) = subr; 398 go to putprop; 399 400 action(2): /* define operand as lsubr */ 401 stack_ptr = addr(tempp -> temp(7)); 402 tempp ->temp(4) = lsubr; 403 go to putprop; 404 405 action(3): /* define operand as fsubr */ 406 stack_ptr = addr(tempp -> temp(7)); 407 tempp -> temp(4) = fsubr; 408 putprop: tempp -> temp(3) = tempp -> temp(1); /* get next subr */ 409 remloop: 410 tempp -> temp(5) = tempp -> temp(2); 411 tempp -> temp(6) = tempp -> temp(4); 412 call lisp_property_fns_$remprop; 413 if tempp -> temp(5) ^= nil 414 then do; stack_ptr = addr(tempp->temp(7)); go to remloop; end; 415 416 if lisp_static_vars_$defun->atom.value ^= 0 & 417 lisp_static_vars_$defun -> atom.value ^= nil 418 then do; 419 stack_ptr = addr(tempp->temp(7)); 420 tempp->temp(5) = tempp->temp(2); 421 tempp->temp(6) = lisp_static_vars_$expr_hash; 422 call lisp_property_fns_$remprop; 423 end; 424 stack_ptr = addr(tempp->temp(5)); 425 call lisp_property_fns_$putprop; 426 alloc_size = alloc_size - 1; 427 if alloc_size > 0 428 then tempp -> lisp_ptr.offset = tempp->lisp_ptr.offset+2; 429 else tempp -> temp(1) = nil; /* don't confuxe gc'er */ 430 endaction: 431 end; 432 433 tempp -> temp(1) = nil; /* since this points to a nonno */ 434 435 /* carefully undo what was done */ 436 stack = addrel(stack,-16); 437 call unbind_io_atoms; 438 stack_ptr = addr(stack -> temp(3)); 439 call lisp_io_control_$close; 440 441 stack_ptr = addr(stack -> temp(2)); 442 stack -> temp(1) = t_atom; 443 return; 444 445 446 /* part to cause ascii file to be loaded */ 447 448 load_ascii_file: 449 stack -> flonum_fmt.type_info = flonum_type; 450 stack -> fixnum_fmt.fixedb = 0; /* illegal float number */ 451 452 call bind_io_atoms; 453 bind_io_atoms: proc; 454 stack_ptr = addr(stack -> temp(9)); /* room for bindings */ 455 unm = unmkd_ptr; 456 unmkd_ptr = addrel(unm,2); 457 stack -> bindings(2).atom = infile; 458 stack -> bindings(3).atom = ctrlQ; 459 stack -> bindings(4).atom = instack; 460 stack -> bindings(2).old_val = addr(infile) -> based_ptr -> atom.value; 461 stack -> bindings(3).old_val = addr(ctrlQ) -> based_ptr -> atom.value; 462 stack -> bindings(4).old_val = addr(instack) -> based_ptr -> atom.value; 463 unm -> binding_block.top_block = rel(addr(stack -> bindings(5))); 464 unm -> binding_block.bot_block = rel(addr(stack -> bindings(2))); 465 unm -> binding_block.back_ptr = rel(binding_top); 466 binding_top = unm; 467 addr(infile) -> based_ptr -> atom.value = stack -> temp(2); 468 addr(ctrlQ) -> based_ptr -> atom.value = t_atom; 469 addr(instack) -> based_ptr -> atom.value = nil; 470 return; 471 472 unbind_io_atoms: entry; 473 474 addr(infile) -> based_ptr -> atom.value = stack -> bindings(2).old_val; 475 addr(ctrlQ) -> based_ptr -> atom.value = stack -> bindings(3).old_val; 476 addr(instack) -> based_ptr -> atom.value = stack -> bindings(4).old_val; 477 binding_top = ptr(binding_top, unm -> binding_block.back_ptr); 478 unmkd_ptr = unm; 479 end bind_io_atoms; 480 loop: stack_ptr = addr(stack -> temp(11)); 481 stack -> temp(9) = stack -> temp(1); /* eof detector */ 482 addr(stack -> temp(10)) -> fixnum_fmt.type_info = fixnum_type; 483 addr(stack -> temp(10)) -> fixedb = -2; 484 call lisp_reader_$read; 485 if stack -> temp(9) = stack -> temp(1) 486 then do; 487 stack -> temp(9) = addr(infile) -> based_ptr -> atom.value; 488 if addr(instack) -> based_ptr -> atom.value ^= nil /* have inpushed, so keep going */ 489 then do; 490 call lisp_io_control_$close; 491 go to loop; 492 end; 493 else call lisp_io_control_$close; 494 call unbind_io_atoms; 495 stack -> temp(1) = t_atom; 496 stack_ptr = addr(stack ->temp(2)); 497 return; 498 end; 499 call lisp_$eval; 500 go to loop; 501 502 /* entry to do the work of (sstatus uuolinks) */ 503 504 unsnap_all_links: entry; 505 506 do blockp = lisp_static_vars_$subr_block_list 507 repeat (blockp -> subr_block_head.next_compiled_block) 508 while (blockp ^= null); /* do loop for all subr blocks */ 509 510 /* a great deal of time can be saved by first checking if there are 511* any links in this subr block that need to be unsnapped */ 512 513 if blockp -> subr_block_head_overlay.no_links_are_snapped 514 then go to skip_this_block; 515 516 if addrel(blockp, blockp -> subr_block_head.subr_code_link_offset + 6) -> lisp_ptr.itsmod 517 ^= "100011"b /* if not its pointer */ 518 then do; /* then must snap link to text section */ 519 on condition(lisp_linkage_error) go to skip_this_block; 520 call lisp_linker_(addrel(blockp, blockp -> subr_block_head.subr_code_link_offset + 6)); 521 revert condition(lisp_linkage_error); 522 end; 523 524 /* Grab the symbol root pointer */ 525 526 unspec (tempp) = unspec (addrel (blockp, blockp -> subr_block_head.subr_code_link_offset + 6) -> based_ptr) 527 & "077777777777777777000000"b3; 528 tempp = ptr (tempp, 0); /* object info seems to care */ 529 call hcs_$status_mins (tempp, (0), bit_count, code); 530 if code ^= 0 then go to skip_this_block; 531 oi.version_number = object_info_version_2; 532 call object_info_$brief (tempp, bit_count, addr (oi), code); 533 if code ^= 0 then go to skip_this_block; 534 call get_definition_ (oi.defp, 535 addrel(blockp, blockp -> subr_code_link_offset + 6) -> link_to_subr_code.name, "symbol_table",tempp, code); 536 if code ^= 0 then go to skip_this_block; 537 538 539 sblkp = addrel (oi.symbp, tempp -> definition.value); 540 symrtp = addrel(sblkp, sblkp -> sb.area_ptr); 541 if symrtp -> symbol_root.subr_block_size = 0 then go to skip_this_block; 542 543 linksp = addrel(symrtp, symrtp -> symbol_root.links_blockp); /* -> data to reinitialize links with */ 544 constp = addrel(symrtp, symrtp -> symbol_root.const_blockp); 545 546 call generate_links; 547 if symrtp -> symbol_root.version >= 2 then do; /* unsnap array links too */ 548 array_links_blockp = addrel(symrtp, symrtp -> symbol_root.array_links_blockp); 549 number_of_array_links = array_links_blockp -> array_links_block.count; 550 if number_of_array_links ^= 0 then do; 551 array_linksp = addrel(blockp, blockp -> subr_code_link_offset+6-2); 552 array_linksp = addrel(array_linksp, -4 * array_linksp -> array_link_count.number_of_array_links); 553 call generate_array_links; 554 end; 555 end; 556 557 skip_this_block: 558 revert condition(lisp_linkage_error); /* may have been left enabled if it was signalled above - anyway doesn't cost anything */ 559 blockp -> subr_block_head_overlay.no_links_are_snapped = "1"b; 560 end; /* end of do loop for each subr block */ 561 return; 562 563 end lisp_load_; 564 SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/18/00 1125.7 lisp_load_.pl1 >udd>sm>ds>w>ml>lisp_load_.pl1 84 1 11/24/86 1326.9 definition.incl.pl1 >ldd>incl>definition.incl.pl1 85 2 03/27/82 0537.0 lisp_iochan.incl.pl1 >ldd>incl>lisp_iochan.incl.pl1 86 3 03/27/82 0537.0 lisp_error_codes.incl.pl1 >ldd>incl>lisp_error_codes.incl.pl1 87 4 08/05/77 1122.5 object_info.incl.pl1 >ldd>incl>object_info.incl.pl1 88 5 03/27/82 0537.0 lisp_comp_subr_block.incl.pl1 >ldd>incl>lisp_comp_subr_block.incl.pl1 89 6 03/27/82 0537.0 lisp_stack_fmt.incl.pl1 >ldd>incl>lisp_stack_fmt.incl.pl1 90 7 03/27/82 0536.9 lisp_symb_tree.incl.pl1 >ldd>incl>lisp_symb_tree.incl.pl1 91 8 05/06/74 1852.6 symbol_block.incl.pl1 >ldd>incl>symbol_block.incl.pl1 93 9 03/27/82 0537.0 lisp_nums.incl.pl1 >ldd>incl>lisp_nums.incl.pl1 94 10 03/27/82 0537.1 lisp_atom_fmt.incl.pl1 >ldd>incl>lisp_atom_fmt.incl.pl1 95 11 03/27/82 0537.0 lisp_common_vars.incl.pl1 >ldd>incl>lisp_common_vars.incl.pl1 96 12 03/27/82 0537.0 lisp_control_chars.incl.pl1 >ldd>incl>lisp_control_chars.incl.pl1 97 13 03/27/82 0537.0 lisp_ptr_fmt.incl.pl1 >ldd>incl>lisp_ptr_fmt.incl.pl1 98 14 03/27/82 0537.0 lisp_bignum_fmt.incl.pl1 >ldd>incl>lisp_bignum_fmt.incl.pl1 99 15 03/27/82 0536.9 lisp_string_fmt.incl.pl1 >ldd>incl>lisp_string_fmt.incl.pl1 100 16 03/27/82 0537.0 lisp_cons_fmt.incl.pl1 >ldd>incl>lisp_cons_fmt.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. Atsym36 constant bit(36) initial dcl 13-17 ref 236 Bignum36 constant bit(36) initial dcl 13-17 ref 223 String36 constant bit(36) initial dcl 13-17 ref 206 Subr36 constant bit(36) initial dcl 13-17 ref 382 action_block based structure level 1 dcl 7-77 action_blockp 7(18) based bit(18) level 2 packed packed unaligned dcl 7-3 ref 385 action_code 1 based fixed bin(17,0) array level 3 packed packed unaligned dcl 7-77 ref 389 actionp 000110 automatic pointer dcl 14 set ref 385* 387 388 389 actions 1 based structure array level 2 packed packed unaligned dcl 7-77 addr builtin function dcl 17 ref 108 118 124 124 137 146 160 166 173 175 184 194 208 224 243 252 257 260 293 295 297 310 325 336 348 375 395 400 405 414 419 424 438 441 454 460 461 462 463 464 467 468 469 474 475 476 480 482 483 487 488 496 532 532 addrel builtin function dcl 17 ref 107 134 150 168 179 189 199 202 213 217 228 232 248 263 284 285 286 351 356 385 436 456 516 520 520 526 534 539 540 543 544 548 551 552 alloc_size 000244 automatic fixed bin(18,0) dcl 36 set ref 203* 204* 218* 219* 276* 278* 376* 378* 379 426* 426 427 area_ptr 16(18) based bit(18) level 2 packed packed unaligned dcl 8-6 ref 168 540 array_link 1 based structure array level 2 dcl 7-71 array_link_count based structure level 1 dcl 5-61 array_link_space 000136 automatic fixed bin(18,0) dcl 18 set ref 265* 267* 269* 276 281 array_links based structure array level 1 dcl 5-52 set ref 348 array_links_block based structure level 1 dcl 7-71 array_links_blockp 000134 automatic pointer dcl 18 in procedure "lisp_load_" set ref 263* 264 344 548* 549 array_links_blockp 10 based bit(18) level 2 in structure "symbol_root" packed packed unaligned dcl 7-3 in procedure "lisp_load_" ref 263 548 array_linksp 000140 automatic pointer dcl 18 set ref 336* 338 343 344 346 348* 348 349 350 351* 351 551* 552* 552 552 atom 2 based fixed bin(71,0) array level 2 in structure "bindings" dcl 6-7 in procedure "lisp_load_" set ref 457* 458* 459* atom based structure level 1 dcl 10-5 in procedure "lisp_load_" atsym_block based structure level 1 dcl 7-36 atsym_blockp 4 based bit(18) level 3 packed packed unaligned dcl 7-3 ref 228 atsym_offset 1 based bit(18) array level 2 packed packed unaligned dcl 7-36 ref 232 back_ptr 1 based bit(18) level 2 packed packed unaligned dcl 6-7 set ref 465* 477 based_ptr based pointer dcl 13-16 ref 118 205 207 220 221 222 237 238 239 240 460 461 462 467 468 469 474 475 476 487 488 526 bignum_block based structure level 1 dcl 7-40 bignum_blockp 3(18) based bit(18) level 3 packed packed unaligned dcl 7-3 ref 213 bignum_offsets 1 based bit(18) array level 2 packed packed unaligned dcl 7-40 ref 217 binding_block based structure level 1 dcl 6-7 binding_top defined pointer dcl 11-6 set ref 465 466* 477* 477 bindings based structure array level 1 dcl 6-7 set ref 463 464 bit_count 000247 automatic fixed bin(24,0) dcl 36 set ref 118* 124* 529* 532* blockp 000124 automatic pointer dcl 14 set ref 179* 181 183 189* 191 193 199* 201 202 213* 215 217 228* 230 232 248* 251 253 254 278* 280 281 282 283 287 293 298 300 310 366 367 368 506* 506* 513 516 516 520 520 520 520 526 526 534 534 551 551 559* 560 bot_block 0(18) based bit(18) level 2 packed packed unaligned dcl 6-7 set ref 464* call_array_link_snap_opr 000010 constant bit(36) initial packed unaligned dcl 18 ref 343 car 1 based fixed bin(17,0) array level 3 in structure "cons_block" packed packed unaligned dcl 7-44 in procedure "lisp_load_" ref 253 car based pointer level 2 in structure "cons_ptrs" dcl 16-5 in procedure "lisp_load_" ref 118 cdr 1(18) based fixed bin(17,0) array level 3 packed packed unaligned dcl 7-44 ref 254 chars 1 based char level 2 packed packed unaligned dcl 7-50 set ref 207 240 242* code 000232 automatic fixed bin(35,0) dcl 36 set ref 118* 124* 125 127* 131* 132 136 161* 354* 355 529* 530 532* 533 534* 536 code1 based fixed bin(35,0) level 2 dcl 32 set ref 135* code2 1 based fixed bin(35,0) level 2 dcl 32 set ref 136* code_offset 0(18) based bit(18) array level 2 packed packed unaligned dcl 5-32 set ref 330* compilation_time 2 based fixed bin(71,0) level 2 dcl 5-39 set ref 360* cons_block based structure level 1 dcl 7-44 cons_blockp 4(18) based bit(18) level 3 packed packed unaligned dcl 7-3 ref 248 cons_ptrs based structure level 1 dcl 16-5 conses 1 based structure array level 2 packed packed unaligned dcl 7-44 const_block based structure level 1 dcl 7-63 const_blockp 6(18) based bit(18) level 3 packed packed unaligned dcl 7-3 ref 284 544 constant_index 000143 automatic fixed bin(17,0) dcl 24 set ref 292* 293 295 constant_index_format based structure level 1 dcl 24 constant_x 0(19) based fixed bin(16,0) level 2 packed packed unaligned dcl 24 ref 293 constants 10 based fixed bin(71,0) array level 2 in structure "subr_block_head" dcl 5-3 in procedure "lisp_load_" set ref 293* 298 300* 310 constants 1 based fixed bin(17,0) array level 2 in structure "const_block" packed packed unaligned dcl 7-63 in procedure "lisp_load_" ref 292 constp 000122 automatic pointer dcl 14 set ref 284* 287 291 292 310 327 544* control_word 1 based bit(36) array level 3 in structure "array_links_block" dcl 7-71 in procedure "lisp_load_" ref 344 control_word 1 based structure array level 2 in structure "array_links" packed packed unaligned dcl 5-52 in procedure "lisp_load_" set ref 344* count based fixed bin(18,0) level 2 in structure "string_block" dcl 7-31 in procedure "lisp_load_" ref 201 count based fixed bin(18,0) level 2 in structure "links_block" dcl 7-67 in procedure "lisp_load_" ref 287 312 325 327 count based fixed bin(18,0) level 2 in structure "entry_block" dcl 7-57 in procedure "lisp_load_" ref 328 336 376 count based fixed bin(18,0) level 2 in structure "flonum_block" dcl 7-27 in procedure "lisp_load_" ref 191 count based fixed bin(18,0) level 2 in structure "cons_block" dcl 7-44 in procedure "lisp_load_" ref 251 count based fixed bin(18,0) level 2 in structure "action_block" dcl 7-77 in procedure "lisp_load_" ref 387 count based fixed bin(18,0) level 2 in structure "bignum_block" dcl 7-40 in procedure "lisp_load_" ref 215 count based fixed bin(18,0) level 2 in structure "atsym_block" dcl 7-36 in procedure "lisp_load_" ref 230 count based fixed bin(18,0) level 2 in structure "const_block" dcl 7-63 in procedure "lisp_load_" ref 287 291 310 327 count based fixed bin(18,0) level 2 in structure "array_links_block" dcl 7-71 in procedure "lisp_load_" ref 264 549 count based fixed bin(18,0) level 2 in structure "fixnum_block" dcl 7-23 in procedure "lisp_load_" ref 181 ctrlQ defined fixed bin(71,0) dcl 12-8 set ref 458 461 468 475 definition based structure level 1 dcl 1-12 defp 4 000144 automatic pointer level 2 in structure "oi" dcl 30 in procedure "lisp_load_" set ref 131* 354* 534* defp 000132 automatic pointer dcl 14 in procedure "lisp_load_" set ref 354* 356 ename 000233 automatic char(32) packed unaligned dcl 36 set ref 117* 118* 127* 131* 274 354* 362 ent_length 000243 automatic fixed bin(24,0) dcl 36 set ref 274* 276 361 entrp 000112 automatic pointer dcl 14 set ref 325* 329 330 331 333 336 381 entry_block based structure level 1 dcl 7-57 entry_blockp 6 based bit(18) level 3 packed packed unaligned dcl 7-3 ref 286 entry_info 1 based structure array level 2 packed packed unaligned dcl 7-57 entryp 000114 automatic pointer dcl 14 set ref 286* 328 329 330 336 376 entrypoint 1(18) based bit(18) array level 3 packed packed unaligned dcl 7-57 ref 330 err_msg 000010 internal static structure level 1 dcl 154 set ref 160 error_struc based structure level 1 dcl 32 file_sys_fun_err constant fixed bin(17,0) initial dcl 3-8 ref 135 fixedb 1 based fixed bin(17,0) level 2 dcl 9-4 set ref 183* 450* 483* fixnum_block based structure level 1 dcl 7-23 fixnum_blockp 2 based bit(18) level 3 packed packed unaligned dcl 7-3 ref 179 fixnum_fmt based structure level 1 dcl 9-4 fixnum_type constant bit(36) initial dcl 9-4 ref 182 482 fixnums 1 based fixed bin(35,0) array level 2 dcl 7-23 ref 183 flags based structure level 2 in structure "string_chars" packed packed unaligned dcl 7-50 in procedure "lisp_load_" flags 15 based structure level 2 in structure "iochan" packed packed unaligned dcl 2-13 in procedure "lisp_load_" floatb 1 based float bin(27) level 2 dcl 9-4 set ref 193* flonum_block based structure level 1 dcl 7-27 flonum_blockp 2(18) based bit(18) level 3 packed packed unaligned dcl 7-3 ref 189 flonum_fmt based structure level 1 dcl 9-4 flonum_type constant bit(36) initial dcl 9-4 ref 192 448 flonums 1 based float bin(27) array level 2 dcl 7-27 ref 193 fsubr defined fixed bin(71,0) dcl 73 ref 407 further_mod 1(30) based bit(6) array level 2 packed packed unaligned dcl 5-23 set ref 318* 358* gc_length 7(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 5-3 set ref 287* gcmark 7 based bit(18) level 2 packed packed unaligned dcl 5-3 set ref 282* gen_version_number 3 based fixed bin(17,0) level 2 dcl 8-6 ref 152 generator 10 based char(8) level 2 dcl 8-6 ref 152 get_definition_ 000050 constant entry external dcl 36 ref 131 354 534 hcs_$initiate_count 000042 constant entry external dcl 36 ref 118 hcs_$make_ptr 000044 constant entry external dcl 36 ref 127 hcs_$status_mins 000046 constant entry external dcl 36 ref 529 head_offset 1 based fixed bin(17,0) array level 2 packed packed unaligned dcl 5-32 set ref 331* i 000245 automatic fixed bin(18,0) dcl 36 set ref 181* 183* 191* 193* 201* 202* 215* 217* 230* 232* 251* 253 254* 291* 292 293 298 300* 312* 313 314 314 315 316 317 318* 328* 329 329 330 330 331 333* 342* 343 344 344 346* 348 387* 388 389* infile defined fixed bin(71,0) dcl 36 set ref 457 460 467 474 487 instack defined fixed bin(71,0) dcl 36 set ref 459 462 469 476 488 instruction based bit(36) array level 2 dcl 5-52 set ref 343* instructions 2 based bit(36) array level 2 dcl 5-3 set ref 280* instructions_for_subr 000004 constant bit(36) initial array packed unaligned dcl 5-45 ref 280 iochan based structure level 1 dcl 2-13 itp_base based bit(3) array level 2 packed packed unaligned dcl 5-23 set ref 313* itp_info 0(03) based bit(27) array level 2 packed packed unaligned dcl 5-23 set ref 314* itp_mod 0(30) based bit(6) array level 2 packed packed unaligned dcl 5-23 set ref 315* itp_to_linker based pointer level 2 dcl 5-39 set ref 356* itsmod 0(30) based bit(6) level 2 packed packed unaligned dcl 13-17 ref 516 length 0(11) based fixed bin(24,0) level 2 in structure "string_chars" packed packed unaligned dcl 7-50 in procedure "lisp_load_" ref 203 205 207 235 239 240 242 242 length builtin function dcl 17 in procedure "lisp_load_" ref 274 link_info 1 based bit(27) array level 2 dcl 7-67 ref 314 link_opr_tv_offset 1 based bit(18) array level 2 packed packed unaligned dcl 5-23 set ref 316* link_to_subr_code based structure level 1 dcl 5-39 linkp 000116 automatic pointer dcl 14 set ref 310* 313 314 315 316 317 318 325 links_block based structure level 1 dcl 7-67 links_blockp 7 based bit(18) level 3 packed packed unaligned dcl 7-3 ref 285 543 linksp 000120 automatic pointer dcl 14 set ref 285* 287 312 314 325 327 543* lisp_$eval 000064 constant entry external dcl 36 ref 299 391 499 lisp_alloc_ 000052 constant entry external dcl 36 ref 204 219 235 lisp_alloc_$cons 000054 constant entry external dcl 36 ref 141 142 255 lisp_bignum based structure level 1 dcl 14-3 lisp_error_ 000034 constant entry external dcl 36 ref 143 lisp_get_atom_ 000102 constant entry external dcl 36 ref 140 242 lisp_io_control_$close 000060 constant entry external dcl 36 ref 144 439 490 493 lisp_io_control_$openi 000056 constant entry external dcl 36 ref 110 lisp_linkage_error 000260 stack reference condition dcl 80 ref 519 521 557 lisp_linker_ 000036 constant entry external dcl 36 ref 520 lisp_property_fns_$putprop 000070 constant entry external dcl 36 ref 425 lisp_property_fns_$remprop 000072 constant entry external dcl 36 ref 412 422 lisp_ptr based structure level 1 dcl 13-17 lisp_ptr_type based bit(36) dcl 13-17 set ref 206* 206 223* 223 236* 236 382* 382 lisp_reader_$read 000062 constant entry external dcl 36 ref 484 lisp_static_man_$allocate 000100 constant entry external dcl 36 ref 278 lisp_static_vars_$binding_top 000122 external static pointer dcl 11-6 set ref 465 465 466* 466 477* 477 477 477 lisp_static_vars_$ctrlQ 000126 external static fixed bin(71,0) dcl 12-8 ref 458 458 461 461 468 468 475 475 lisp_static_vars_$defun 000074 external static pointer dcl 36 ref 416 416 lisp_static_vars_$expr_hash 000076 external static fixed bin(71,0) dcl 36 ref 421 lisp_static_vars_$fsubr 000110 external static fixed bin(71,0) dcl 73 ref 407 407 lisp_static_vars_$infile 000030 external static fixed bin(71,0) dcl 36 ref 457 457 460 460 467 467 474 474 487 487 lisp_static_vars_$instack 000032 external static fixed bin(71,0) dcl 36 ref 459 459 462 462 469 469 476 476 488 488 lisp_static_vars_$lsubr 000106 external static fixed bin(71,0) dcl 73 ref 402 402 lisp_static_vars_$nil 000124 external static fixed bin(71,0) dcl 11-6 ref 138 138 174 174 238 238 413 413 416 416 429 429 433 433 469 469 488 488 lisp_static_vars_$stack_ptr 000114 external static pointer dcl 11-6 set ref 107 107 108* 108 137* 137 146* 146 173* 173 249 249 252* 252 296 296 297* 297 301* 301 370 370 375* 375 395* 395 400* 400 405* 405 414* 414 419* 419 424* 424 438* 438 441* 441 454* 454 480* 480 496* 496 lisp_static_vars_$subr 000104 external static fixed bin(71,0) dcl 73 ref 397 397 lisp_static_vars_$subr_block_list 000112 external static pointer dcl 80 set ref 367 368* 506 lisp_static_vars_$t_atom 000116 external static fixed bin(71,0) dcl 11-6 ref 442 442 468 468 495 495 lisp_static_vars_$unmkd_ptr 000120 external static pointer dcl 11-6 set ref 133 133 134* 134 455 455 456* 456 478* 478 lisp_string based structure level 1 dcl 15-6 lisp_subr_links based structure array level 1 dcl 5-23 set ref 325 load_time 0(18) based bit(1) level 2 packed packed unaligned dcl 24 ref 295 lsubr defined fixed bin(71,0) dcl 73 ref 402 mbz 1(18) based bit(12) array level 2 packed packed unaligned dcl 5-23 set ref 317* must_be_zero 1(18) based bit(18) level 2 packed packed unaligned dcl 5-61 set ref 350* name 5 based char level 2 in structure "link_to_subr_code" packed packed unaligned dcl 5-39 in procedure "lisp_load_" set ref 362* 534* name 22 based char(32) level 2 in structure "iochan" packed packed unaligned dcl 2-13 in procedure "lisp_load_" ref 117 name_length 4 based fixed bin(24,0) level 2 dcl 5-39 set ref 361* 362 534 534 namelist 20 based fixed bin(71,0) level 2 dcl 2-13 set ref 118 nargs based bit(18) array level 2 in structure "subr_entries" packed packed unaligned dcl 5-32 in procedure "lisp_load_" set ref 329* nargs 1 based bit(18) array level 3 in structure "entry_block" packed packed unaligned dcl 7-57 in procedure "lisp_load_" ref 329 next_compiled_block based pointer level 2 dcl 5-3 set ref 367* 560 nil defined fixed bin(71,0) dcl 11-6 ref 138 174 238 413 416 429 433 469 488 no_links_are_snapped 1(28) based bit(1) level 3 packed packed unaligned dcl 5-14 set ref 366* 513 559* null builtin function dcl 17 ref 121 127 127 346 506 number_objects 1 based fixed bin(17,0) level 2 dcl 7-3 ref 173 number_of_array_links 000142 automatic fixed bin(17,0) dcl 18 in procedure "lisp_load_" set ref 264* 265 265 269* 337 342 349 549* 550 number_of_array_links 1 based fixed bin(17,0) level 2 in structure "array_link_count" packed packed unaligned dcl 5-61 in procedure "lisp_load_" set ref 349* 552 obj_creation_time 6 based fixed bin(71,0) level 2 dcl 8-6 ref 360 object_info based structure level 1 dcl 4-6 object_info_$brief 000066 constant entry external dcl 36 ref 124 532 object_info_version_2 constant fixed bin(17,0) initial dcl 4-60 ref 122 531 object_ptr 000106 automatic pointer dcl 14 set ref 175* 182 183 184* 184 192 193 194* 194 204 205 206 206 207 208* 208 219 220 221 222 223 223 224* 224 235 236 236 237 238 239 240 242 243* 243 256 257* 257 260* 293 388 objects 2 based structure level 2 in structure "symbol_root" packed packed unaligned dcl 7-3 in procedure "lisp_load_" objects based fixed bin(71,0) array dcl 36 in procedure "lisp_load_" set ref 184 194 204* 208 219* 224 235* 242* 243 253 254 256* 257 293 388 offset 1 based fixed bin(17,0) level 2 packed packed unaligned dcl 13-17 set ref 427* 427 offset_head 000246 automatic fixed bin(17,0) dcl 36 set ref 327* 331 332* 332 oi 000144 automatic structure level 1 dcl 30 set ref 124 124 532 532 old_val based fixed bin(71,0) array level 2 dcl 6-7 set ref 460* 461* 462* 474 475 476 operand 1(18) based fixed bin(17,0) array level 3 packed packed unaligned dcl 7-77 ref 388 packed_ptr 000266 automatic pointer packed unaligned dcl 154 set ref 160* 161 plist 2 based fixed bin(71,0) level 2 dcl 10-5 set ref 238* pname 5 based char level 2 dcl 10-5 set ref 118 240* pnamel 4 based fixed bin(17,0) level 2 dcl 10-5 set ref 118 239* 240 pointer 2 based pointer array level 2 dcl 5-52 set ref 346* prec 0(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 14-3 set ref 218 221* 221 222 ptr builtin function dcl 17 ref 477 528 rest_of_tsplp 6(18) based bit(18) level 2 packed packed unaligned dcl 5-3 set ref 283* rest_of_tsx0 1(18) based bit(18) array level 2 packed packed unaligned dcl 5-32 set ref 333* rtrim builtin function dcl 17 ref 274 sb based structure level 1 dcl 8-6 sblkp 000126 automatic pointer dcl 14 set ref 127* 150* 152 152 168 168 360 539* 540 540 second_word 1 based structure level 2 dcl 5-14 seg 15 based bit(1) level 3 packed packed unaligned dcl 2-13 ref 112 sign based bit(18) level 2 packed packed unaligned dcl 14-3 set ref 220* 220 stack 000102 automatic pointer dcl 14 set ref 107* 108 109 109 112 117 118 137 138 139 139 140 145 145 146 166* 166 173 174 175 253 254 260 436* 436 438 441 442 448 450 454 457 458 459 460 461 462 463 464 467 474 475 476 480 481 481 482 483 485 485 487 495 496 stack_ptr defined pointer dcl 11-6 set ref 107 108* 137* 146* 173* 249 252* 296 297* 301* 370 375* 395* 400* 405* 414* 419* 424* 438* 441* 454* 480* 496* string 1 based char level 2 dcl 15-6 set ref 207* string_block based structure level 1 dcl 7-31 string_blockp 3 based bit(18) level 3 packed packed unaligned dcl 7-3 ref 199 string_chars based structure level 1 dcl 7-50 string_length based fixed bin(17,0) level 2 dcl 15-6 set ref 205* 207 string_offset 1 based bit(18) array level 2 packed packed unaligned dcl 7-31 ref 202 subr defined fixed bin(71,0) dcl 73 ref 397 subr_block_head based structure level 1 dcl 5-3 subr_block_head_overlay based structure level 1 dcl 5-14 subr_block_items 6 based structure level 2 packed packed unaligned dcl 7-3 subr_block_size 5 based fixed bin(18,0) level 2 dcl 7-3 ref 273 276 281 376 541 subr_code_link_offset 6 based fixed bin(17,0) level 2 packed packed unaligned dcl 5-3 set ref 281* 516 520 520 526 534 551 subr_entries based structure array level 1 dcl 5-32 set ref 336 symbol_root based structure level 1 dcl 7-3 symbp 12 000144 automatic pointer level 2 dcl 30 set ref 150 539 symrtp 000130 automatic pointer dcl 14 set ref 168* 173 179 179 189 189 199 199 202 213 213 217 228 228 232 248 248 262 263 263 273 276 281 284 284 285 285 286 286 376 385 385 540* 541 543 543 544 544 547 548 548 t_atom defined fixed bin(71,0) dcl 11-6 ref 442 468 495 temp based fixed bin(71,0) array dcl 6-7 set ref 108 109* 109 137 138* 139* 139 140* 145* 145 146 166 173 174* 175 252 253* 254* 256 260 297 298* 300 375 388* 395 397* 400 402* 405 407* 408* 408 409* 409 411* 411 413 414 419 420* 420 421* 424 429* 433* 438 441 442* 454 467 480 481* 481 482 483 485 485 487* 495* 496 temp_ptr based pointer array dcl 6-7 set ref 112 117 118 381* tempp 000100 automatic pointer dcl 14 set ref 118* 121 124* 131* 150 202* 203 205 207 217* 218 220 221 222 232* 233 235 239 240 242 249* 252 253 254 256 296* 297 298 300 301 338* 356 358 360 361 362 370* 375 381 382 382 388 395 397 400 402 405 407 408 408 409 409 411 411 413 414 419 420 420 421 424 427 427 429 433 526* 528* 528 529* 532* 534* 539 textp 2 000144 automatic pointer level 2 dcl 30 set ref 356 top_block based bit(18) level 2 packed packed unaligned dcl 6-7 set ref 463* tsplp_ic_ind constant bit(18) initial packed unaligned dcl 5-45 ref 283 tsx0_ic constant bit(18) initial packed unaligned dcl 5-45 ref 333 type_info based bit(36) level 2 in structure "fixnum_fmt" dcl 9-4 in procedure "lisp_load_" set ref 182* 482* type_info based bit(36) level 2 in structure "flonum_fmt" dcl 9-4 in procedure "lisp_load_" set ref 192* 448* uname 000250 automatic char(32) packed unaligned dcl 36 set ref 116* 118* uninterned_atom based bit(1) level 3 packed packed unaligned dcl 7-50 ref 233 unique_chars_ 000040 constant entry external dcl 36 ref 116 unm 000104 automatic pointer dcl 14 set ref 133* 134 135 136 455* 456 463 464 465 466 477 478 unmkd_ptr defined pointer dcl 11-6 set ref 133 134* 455 456* 478* value 1 based bit(18) level 2 in structure "definition" packed packed unaligned dcl 1-12 in procedure "lisp_load_" ref 150 356 539 value based fixed bin(71,0) level 2 in structure "atom" dcl 10-5 in procedure "lisp_load_" set ref 237* 416 416 460 461 462 467* 468* 469* 474* 475* 476* 487 488 version based fixed bin(17,0) level 2 dcl 7-3 ref 262 547 version_number 000144 automatic fixed bin(17,0) level 2 dcl 30 set ref 122* 531* words 1 based fixed bin(35,0) array level 2 dcl 14-3 set ref 222* 222 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. Array internal static bit(9) initial packed unaligned dcl 13-17 Array36 internal static bit(36) initial dcl 13-17 Atomic internal static bit(9) initial packed unaligned dcl 13-17 Atomic36 internal static bit(36) initial dcl 13-17 Atsym internal static bit(9) initial packed unaligned dcl 13-17 Bigfix internal static bit(9) initial packed unaligned dcl 13-17 Bigfix36 internal static bit(36) initial dcl 13-17 Bignum internal static bit(9) initial packed unaligned dcl 13-17 Cons internal static bit(9) initial packed unaligned dcl 13-17 Cons36 internal static bit(36) initial dcl 13-17 File internal static bit(9) initial packed unaligned dcl 13-17 File36 internal static bit(36) initial dcl 13-17 Fixed internal static bit(9) initial packed unaligned dcl 13-17 Fixed36 internal static bit(36) initial dcl 13-17 Float internal static bit(9) initial packed unaligned dcl 13-17 Float36 internal static bit(36) initial dcl 13-17 NotConsOrAtsym36 internal static bit(36) initial dcl 13-17 Numeric internal static bit(9) initial packed unaligned dcl 13-17 Numeric36 internal static bit(36) initial dcl 13-17 String internal static bit(9) initial packed unaligned dcl 13-17 Subr internal static bit(9) initial packed unaligned dcl 13-17 SubrNumeric36 internal static bit(36) initial dcl 13-17 System_Subr internal static bit(9) initial packed unaligned dcl 13-17 System_Subr36 internal static bit(36) initial dcl 13-17 Uncollectable internal static bit(9) initial packed unaligned dcl 13-17 Undefined internal static bit(72) initial packed unaligned dcl 13-17 argument_must_be_array internal static fixed bin(17,0) initial dcl 3-8 array_atom defined fixed bin(71,0) dcl 11-6 array_bound_error internal static fixed bin(17,0) initial dcl 3-8 array_too_big internal static fixed bin(17,0) initial dcl 3-8 atan_0_0_err internal static fixed bin(17,0) initial dcl 3-8 atom_double_words based structure level 1 dcl 10-5 atom_ptrs based structure level 1 dcl 10-5 bad_arg_correctable internal static fixed bin(17,0) initial dcl 3-8 bad_argument internal static fixed bin(17,0) initial dcl 3-8 bad_array_subscript internal static fixed bin(17,0) initial dcl 3-8 bad_base internal static fixed bin(17,0) initial dcl 3-8 bad_bv internal static fixed bin(17,0) initial dcl 3-8 bad_do_format internal static fixed bin(17,0) initial dcl 3-8 bad_entry_name internal static fixed bin(17,0) initial dcl 3-8 bad_f_fcn internal static fixed bin(17,0) initial dcl 3-8 bad_function internal static fixed bin(17,0) initial dcl 3-8 bad_ibase internal static fixed bin(17,0) initial dcl 3-8 bad_input_source internal static fixed bin(17,0) initial dcl 3-8 bad_output_dest internal static fixed bin(17,0) initial dcl 3-8 bad_prog_op internal static fixed bin(17,0) initial dcl 3-8 badmacro internal static fixed bin(17,0) initial dcl 3-8 badobarray internal static fixed bin(17,0) initial dcl 3-8 badreadlist internal static fixed bin(17,0) initial dcl 3-8 badreadtable internal static fixed bin(17,0) initial dcl 3-8 cant_filepos internal static fixed bin(17,0) initial dcl 3-8 cant_subscript_readtable internal static fixed bin(17,0) initial dcl 3-8 car_cdr_error internal static fixed bin(17,0) initial dcl 3-8 catch_frame defined pointer dcl 11-6 cons based structure level 1 dcl 16-5 cons_types based structure level 1 dcl 16-5 cons_types36 based structure level 1 dcl 16-22 consptr automatic pointer dcl 16-5 ctrlD defined fixed bin(71,0) dcl 12-5 ctrlR defined fixed bin(71,0) dcl 12-11 ctrlW defined fixed bin(71,0) dcl 12-14 dead_array_reference internal static fixed bin(17,0) initial dcl 3-8 division_by_zero internal static fixed bin(17,0) initial dcl 3-8 doterror internal static fixed bin(17,0) initial dcl 3-8 eof_in_object internal static fixed bin(17,0) initial dcl 3-8 err_frame defined pointer dcl 11-6 err_recp defined pointer dcl 11-6 error_table_$segknown external static fixed bin(35,0) dcl 36 eval_frame defined pointer dcl 11-6 file_is_closed internal static fixed bin(17,0) initial dcl 3-8 file_system_error internal static fixed bin(17,0) initial dcl 3-8 filepos_oob internal static fixed bin(17,0) initial dcl 3-8 flag_reset_mask internal static bit(36) initial dcl 2-13 flonum_too_big internal static fixed bin(17,0) initial dcl 3-8 illobj internal static fixed bin(17,0) initial dcl 3-8 include_file_error internal static fixed bin(17,0) initial dcl 3-8 io_wrong_direction internal static fixed bin(17,0) initial dcl 3-8 lisp_static_vars_$array_atom external static fixed bin(71,0) dcl 11-6 lisp_static_vars_$catch_frame external static pointer dcl 11-6 lisp_static_vars_$ctrlD external static fixed bin(71,0) dcl 12-5 lisp_static_vars_$ctrlR external static fixed bin(71,0) dcl 12-11 lisp_static_vars_$ctrlW external static fixed bin(71,0) dcl 12-14 lisp_static_vars_$err_frame external static pointer dcl 11-6 lisp_static_vars_$err_recp external static pointer dcl 11-6 lisp_static_vars_$eval_frame external static pointer dcl 11-6 lisp_static_vars_$iochan_list external static pointer dcl 11-6 lisp_static_vars_$lisp_static_vars_ external static structure level 1 unaligned dcl 11-6 lisp_static_vars_$no_snapped_links external static bit(1) dcl 36 lisp_static_vars_$obarray external static fixed bin(71,0) dcl 11-6 lisp_static_vars_$prog_frame external static pointer dcl 11-6 lisp_static_vars_$star_rset external static fixed bin(71,0) dcl 11-45 lisp_static_vars_$top_level external static label variable dcl 11-6 lisp_static_vars_$tty_input_chan external static pointer dcl 11-6 lisp_static_vars_$tty_output_chan external static pointer dcl 11-6 lisp_static_vars_$unwp_frame external static pointer dcl 11-6 lisp_static_vars_$user_intr_array external static fixed bin(71,0) array dcl 11-45 mismatch_super_parens internal static fixed bin(17,0) initial dcl 3-8 nihil_ex_nihile internal static fixed bin(17,0) initial dcl 3-8 nil_ptr based pointer dcl 11-6 no_left_super_paren internal static fixed bin(17,0) initial dcl 3-8 no_lexpr internal static fixed bin(17,0) initial dcl 3-8 nonfixedarg internal static fixed bin(17,0) initial dcl 3-8 not_alpha_array internal static fixed bin(17,0) initial dcl 3-8 not_an_array internal static fixed bin(17,0) initial dcl 3-8 not_pdl_ptr internal static fixed bin(17,0) initial dcl 3-8 not_same_type internal static fixed bin(17,0) initial dcl 3-8 obarray defined fixed bin(71,0) dcl 11-6 overflow_err internal static fixed bin(17,0) initial dcl 3-8 parenmissing internal static fixed bin(17,0) initial dcl 3-8 pathptr automatic pointer dcl 14 pdl_ptr_types36 based structure array level 1 dcl 6-7 prog_frame defined pointer dcl 11-6 push_down_list_ptr_types based structure array level 1 dcl 6-7 quoterror internal static fixed bin(17,0) initial dcl 3-8 reopen_inconsistent internal static fixed bin(17,0) initial dcl 3-8 shortreadlist internal static fixed bin(17,0) initial dcl 3-8 special_array_type internal static fixed bin(17,0) initial dcl 3-8 stack_loss_error internal static fixed bin(17,0) initial dcl 3-8 star_rset defined fixed bin(71,0) dcl 11-45 stars_left_in_name internal static fixed bin(17,0) initial dcl 3-8 store_function_misused internal static fixed bin(17,0) initial dcl 3-8 store_not_allowed internal static fixed bin(17,0) initial dcl 3-8 t_atom_ptr based pointer dcl 11-6 throw_to_no_catch internal static fixed bin(17,0) initial dcl 3-8 too_few_args internal static fixed bin(17,0) initial dcl 3-8 too_many_args internal static fixed bin(17,0) initial dcl 3-8 tty_input_chan defined pointer dcl 11-6 tty_output_chan defined pointer dcl 11-6 unable_to_float internal static fixed bin(17,0) initial dcl 3-8 undefined_atom internal static fixed bin(17,0) initial dcl 3-8 undefined_function internal static fixed bin(17,0) initial dcl 3-8 undefined_subr internal static fixed bin(17,0) initial dcl 3-8 underflow_fault internal static fixed bin(17,0) initial dcl 3-8 unseen_go_tag internal static fixed bin(17,0) initial dcl 3-8 unwp_frame defined pointer dcl 11-6 user_intr_array defined fixed bin(71,0) array dcl 11-45 wrong_no_args internal static fixed bin(17,0) initial dcl 3-8 zerodivide_fault internal static fixed bin(17,0) initial dcl 3-8 NAMES DECLARED BY EXPLICIT CONTEXT. action 000000 constant label array(0:3) dcl 391 ref 389 bind_io_atoms 002447 constant entry internal dcl 453 ref 165 452 endaction 001711 constant label dcl 430 ref 393 fserror 000322 constant label dcl 133 ref 121 162 355 generate_array_links 002407 constant entry internal dcl 340 ref 337 553 generate_links 002340 constant entry internal dcl 309 ref 307 546 lisp_load_ 000051 constant entry external dcl 6 load_ascii_file 001741 constant label dcl 448 ref 112 125 loop 001746 constant label dcl 480 ref 491 500 no_subr_block 001520 constant label dcl 370 ref 273 putprop 001620 constant label dcl 408 ref 398 403 remloop 001622 constant label dcl 409 ref 414 skip_this_block 002330 constant label dcl 557 ref 513 519 530 533 536 541 unbind_io_atoms 002536 constant entry internal dcl 472 ref 437 494 unsnap_all_links 002031 constant entry external dcl 504 NAMES DECLARED BY CONTEXT OR IMPLICATION. divide builtin function ref 203 218 235 276 rel builtin function ref 463 464 465 unspec builtin function set ref 161 161 344* 526* 526 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3160 3310 2567 3170 Length 4074 2567 130 547 371 20 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME lisp_load_ 268 external procedure is an external procedure. generate_links internal procedure shares stack frame of external procedure lisp_load_. generate_array_links internal procedure shares stack frame of external procedure lisp_load_. bind_io_atoms internal procedure shares stack frame of external procedure lisp_load_. on unit on line 519 64 on unit STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 err_msg lisp_load_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME lisp_load_ 000100 tempp lisp_load_ 000102 stack lisp_load_ 000104 unm lisp_load_ 000106 object_ptr lisp_load_ 000110 actionp lisp_load_ 000112 entrp lisp_load_ 000114 entryp lisp_load_ 000116 linkp lisp_load_ 000120 linksp lisp_load_ 000122 constp lisp_load_ 000124 blockp lisp_load_ 000126 sblkp lisp_load_ 000130 symrtp lisp_load_ 000132 defp lisp_load_ 000134 array_links_blockp lisp_load_ 000136 array_link_space lisp_load_ 000140 array_linksp lisp_load_ 000142 number_of_array_links lisp_load_ 000143 constant_index lisp_load_ 000144 oi lisp_load_ 000232 code lisp_load_ 000233 ename lisp_load_ 000243 ent_length lisp_load_ 000244 alloc_size lisp_load_ 000245 i lisp_load_ 000246 offset_head lisp_load_ 000247 bit_count lisp_load_ 000250 uname lisp_load_ 000266 packed_ptr lisp_load_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp call_ext_out_desc call_ext_out return_mac tra_ext_1 enable_op shorten_stack ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. get_definition_ hcs_$initiate_count hcs_$make_ptr hcs_$status_mins lisp_$eval lisp_alloc_ lisp_alloc_$cons lisp_error_ lisp_get_atom_ lisp_io_control_$close lisp_io_control_$openi lisp_linker_ lisp_property_fns_$putprop lisp_property_fns_$remprop lisp_reader_$read lisp_static_man_$allocate object_info_$brief unique_chars_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. lisp_static_vars_$binding_top lisp_static_vars_$ctrlQ lisp_static_vars_$defun lisp_static_vars_$expr_hash lisp_static_vars_$fsubr lisp_static_vars_$infile lisp_static_vars_$instack lisp_static_vars_$lsubr lisp_static_vars_$nil lisp_static_vars_$stack_ptr lisp_static_vars_$subr lisp_static_vars_$subr_block_list lisp_static_vars_$t_atom lisp_static_vars_$unmkd_ptr LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 6 000050 107 000056 108 000062 109 000064 110 000066 112 000072 116 000077 117 000117 118 000124 121 000176 122 000203 124 000205 125 000224 127 000226 131 000264 132 000320 133 000322 134 000326 135 000331 136 000333 137 000335 138 000340 139 000343 140 000345 141 000363 142 000370 143 000375 144 000402 145 000407 146 000412 147 000415 150 000416 152 000424 160 000436 161 000441 162 000443 165 000444 166 000445 168 000450 173 000456 174 000463 175 000465 179 000467 181 000474 182 000503 183 000505 184 000510 185 000512 189 000514 191 000522 192 000531 193 000533 194 000536 195 000540 199 000542 201 000550 202 000557 203 000570 204 000577 205 000610 206 000615 207 000617 208 000624 209 000627 213 000631 215 000637 217 000647 218 000660 219 000667 220 000700 221 000704 222 000707 223 000720 224 000722 225 000725 228 000727 230 000735 232 000745 233 000756 235 000761 236 001001 237 001003 238 001006 239 001012 240 001016 241 001022 242 001023 243 001046 244 001051 248 001053 249 001061 251 001065 252 001075 253 001101 254 001107 255 001117 256 001123 257 001125 258 001130 260 001132 262 001135 263 001140 264 001146 265 001150 267 001155 268 001156 269 001157 273 001161 274 001164 276 001176 278 001207 280 001220 281 001232 282 001241 283 001243 284 001245 285 001252 286 001257 287 001264 291 001267 292 001277 293 001307 295 001321 296 001324 297 001330 298 001332 299 001334 300 001340 301 001346 303 001351 307 001353 325 001354 327 001360 328 001365 329 001375 330 001403 331 001406 332 001413 333 001415 334 001420 336 001422 337 001426 338 001431 354 001433 355 001465 356 001467 358 001475 360 001500 361 001503 362 001505 366 001510 367 001513 368 001517 370 001520 375 001524 376 001526 378 001534 379 001535 381 001537 382 001541 385 001543 387 001550 388 001557 389 001566 391 001571 393 001576 395 001577 397 001602 398 001604 400 001605 402 001610 403 001612 405 001613 407 001616 408 001620 409 001622 411 001625 412 001627 413 001634 414 001641 414 001643 416 001644 419 001651 420 001653 421 001655 422 001657 424 001663 425 001667 426 001673 427 001675 429 001706 430 001711 433 001713 436 001716 437 001721 438 001722 439 001726 441 001732 442 001736 443 001740 448 001741 450 001743 452 001745 480 001746 481 001752 482 001755 483 001757 484 001761 485 001765 487 001771 488 001775 490 002001 491 002005 493 002006 494 002012 495 002013 496 002016 497 002021 499 002022 500 002027 504 002030 506 002036 513 002046 516 002052 519 002063 520 002103 521 002116 526 002117 528 002131 529 002133 530 002151 531 002153 532 002155 533 002174 534 002176 536 002245 539 002247 540 002255 541 002262 543 002264 544 002271 546 002276 547 002277 548 002302 549 002310 550 002312 551 002313 552 002322 553 002327 557 002330 559 002331 560 002334 561 002337 309 002340 310 002341 312 002346 313 002355 314 002363 315 002371 316 002374 317 002377 318 002401 319 002404 320 002406 340 002407 342 002410 343 002417 344 002423 346 002426 347 002431 348 002433 349 002437 350 002442 351 002444 352 002446 453 002447 454 002450 455 002454 456 002457 457 002462 458 002465 459 002467 460 002471 461 002474 462 002477 463 002502 464 002506 465 002514 466 002521 467 002522 468 002526 469 002531 470 002535 472 002536 474 002537 475 002544 476 002547 477 002552 478 002561 479 002562 ----------------------------------------------------------- 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