THIS FILE IS DAMAGED COMPILATION LISTING OF SEGMENT mexp_ Compiled by: Multics PL/I Compiler, Release 31a, of October 12, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 10/17/88 1007.0 mst Mon Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 14 15 /****^ HISTORY COMMENTS: 16* 1) change(86-10-01,JRGray), approve(86-10-01,MCR7507), 17* audit(86-10-27,RWaters), install(86-11-12,MR12.0-1202): 18* Modified to change argument passing conventions. This is part of the 19* changes for calling via the new subroutine "alm_". 20* END HISTORY COMMENTS */ 21 22 23 mexp_$ignore: procedure (); 24 return; 25 26 /* This program is a simple macro expander for alm programs. */ 27 28 /* Last modified to list skipped iftarget code as comments by E. N. Kittlitz on 8/17/83 */ 29 /* Last modified for changes requested by MTR 175 by EBush on 3/26/81 */ 30 /* Modified to implement "iftarget" and "intarget" by EBush on 2/5/81 */ 31 /* First written "about '70, '71" by Steve Webber, as stand-alone program. */ 32 /* Integrated with ALM, fully EIS-ed, resubroutinized by Bernard Greenberg 3/25/77 33* Also implemented functions 14-22 at that time, and shared-seg buffer stack. */ 34 35 36 dcl next fixed bin (21), 37 code fixed bin (35), 38 entry_no fixed bin (21), 39 WHITE char (2) static init (" ") options (constant), 40 ENDS char (4) static init ("(); 41 ") options (constant), 42 TERMS char (2) static init ("; 43 ") options (constant), 44 discard fixed bin, 45 vc char (12) var, 46 convert_binary_integer_$octal_string entry (fixed bin) returns (char (12) var), 47 cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin), 48 c char (1) aligned, 49 (addr, substr, ptr, unspec, index, null, length) builtin, 50 gtsname char (32) static options (constant) init ("ALM macro expander"), 51 (no_exargs, no_ifargs) fixed bin, 52 alm_finished_the_line bit (1) aligned, 53 cu_$arg_ptr_rel entry (fixed bin, ptr, fixed bin (21), fixed bin (35), ptr), 54 cu_$arg_list_ptr entry returns (ptr), 55 error_table_$noarg fixed bin(35) external, 56 ioa_$general_rs entry (ptr, fixed bin, fixed bin, char (*), fixed bin, bit (1) aligned, bit (1) aligned), 57 targ char (128) var, 58 cbuf1 char (200), cb1b char (cb1l) based (addr (cbuf1)), cb1l fixed bin, 59 temp_ap ptr, temp_al fixed bin (21), 60 input_arg char (temp_al) based (temp_ap), 61 arg_1 char (args (1).len) based (substaddr (il, args (1).start)), 62 QUOTE char (1) aligned static init (""""), 63 max_char_count fixed bin (21), 64 sys_info$max_seg_size ext static fixed bin (35), 65 COMMA_NL char (2) static init (", 66 ") options (constant), 67 NL char (1) static init (" 68 ") options (constant), 69 SIGNATURE char (14) static init ("ALM assJ*@JRn*@Jr&JE0_ez7TOBSWE.pdt JRy $ JzSwßb*@JRj*@Jjz@JZB*@JR6n*J:bn*@JBJ|*J&JEYuzzzr+STDSPPT.pdt JRyת2 $ 8zSwß8*@J*@Jz@J*@J6n*JZn*@J|*Jr&J+EC-zDEVM.pdt J+RyTŸz $ Xz0SwßX<*@J+T*@J+Tz@J+L*@J+t&JP?zNMLPROD.pdt JRy׈$ d@z(Swßn*@J+@*@J6n*J+|*J+l*@Jz@J\*@J&E3||zt 8080ARK.pdt Ry= -$x`z$SwßDJn*@JJD*@Jl6n*J\d|*JLD*@J+ZD*@JbZD*@Jt&LEվz.d8080PROD.pdt LRy@ &$zHSwßV`D*@q6RD*@J,@|* ptD*@JG8*@$j*@q6p*SwßhH*@*@JD*@J0x*@`**@J+P*@p0D*@h6*@Hz@*@L*@L*L*@L*@LD*@L6n*Lz@L&&ESz7ENGSPPT.pdt Ry_ |$z6Swß*@*@*@**@D*@6n*z@&E..z&zNMLARK.pdt RyŸz$dz$Swß\|*@l*@dL*\*@tT*@|lD*@Lt6n*Tz@&&(Ez1NMLARK1.pdt (Ry׀2 $z$Swß*@(*@(*(*@(*@(D*@(6n*(z@(X&9EJzNMLARK2. 3 segx fixed bin (13) unal, /* seg index of expansion buffer */ 135 3 charx fixed bin (21) unal, /* index of first char of that exp. */ 136 2 segarray (10) ptr init ((10) null ()), /* temp seg array */ 137 2 segarray_free (10) fixed bin (21) init ((10) 1), /* charx of first unused char in each buffer tempseg */ 138 2 unique_generator fixed bin init (0), 139 2 unique_generator1 fixed bin init (0), 140 2 unique_changed bit (1) init ("0"b); /* "1"b if used &U in this expansion */ 141 142 dcl 1 arguments(eb_data_$alm_arg_count) based(eb_data_$alm_arg_ptr), 143 2 arg_ptr ptr, 144 2 arg_len fixed bin(21); 145 146 dcl segarray_of_one (1) ptr auto; 147 dcl segarray_of_two ptr dim (2) based (addr (bct.segarray)); 148 dcl system_free_area area based (sfap); 149 150 dcl get_system_free_area_ entry returns (ptr); 151 dcl (get_temp_segments_, release_temp_segments_) entry (char (*), (*) ptr, fixed bin (35)); 152 153 dcl (inputs_$run_statement, inputs_$run_statement_nolist, inputs_$next_statement, inputs_$next_statement_nolist) ext entry; 154 dcl inputs_$get_ptr entry (ptr, fixed bin (21), fixed bin (21), bit (1) aligned); 155 dcl alm_include_file_$macro entry (ptr, fixed bin (21)), 156 alm_include_file_$pop entry; 157 158 dcl prnter_$macro_error entry (char (*), char (*)); 159 dcl prnter_$general_abort entry (char (*)); 160 dcl eb_data_$mexp_env_ptr ptr external, 161 eb_data_$macro_linect fixed bin ext, 162 eb_data_$mexp_argno fixed bin ext, 163 eb_data_$alm_arg_count fixed bin ext, 164 eb_data_$alm_arg_ptr ptr ext; 165 1 1 /* BEGIN INCLUDE FILE ... system_types.incl.pl1 ... 03/23/81 ... W. Olin Sibert */ 1 2 1 3 dcl L68_SYSTEM fixed bin (17) internal static options (constant) init (1); 1 4 dcl ADP_SYSTEM fixed bin (17) internal static options (constant) init (2); 1 5 1 6 dcl SYSTEM_TYPE_NAME (2) char (8) internal static options (constant) init 1 7 ("Level68", "ADP"); 1 8 1 9 /* END INCLUDE FILE ... system_types.incl.pl1 */ 166 2 1 /* Begin include file varcom.incl.pl1. */ 2 2 /* RHG added new variables 9/7/70. */ 2 3 /* RFM added new cells for new object segment format and first-reference trap, 27 March 1972. */ 2 4 /* RFM added include file stuff, then cross referencer stuff, 23 July 1972. */ 2 5 /* Last modified on 07/23/72 at 04:19:25 by R F Mabee. */ 2 6 2 7 declare 1 eb_data_$varcom external aligned, 2 8 2 (brk(2), nbrk(2), sym(8), dsym(8),old_locsym, pc, spc, tpc, 2 9 pclst, p2pcl, old_ndpcls, tvorg, tvcnt, tvlth, litorg, 2 10 litc, deforg, defc, defcnt, stkc, lnkc, lnkno, 2 11 litlst, old_ndltls, lnklst, old_ndlkls, explst, blklst, namlst, 2 12 trplst, xdflst, tvlst, begin_line, tpass1, tpass2, tpostp, 2 13 tinhib, tmmode, txonly, tmm2, txo2, tprot, tcall, 2 14 tmvdef, tpulnk, tfatal, calrho, lreter, passwd, binlin, 2 15 nboxes, box(0:210), myfil, mynam, myblk, mylnk, tpost1 ) fixed bin (26) , 2 16 2 source_printed bit(1) aligned, 2 17 2 (ndpcls, ndltls, ndlkls, ndtvls) ptr, 2 18 2 (basno, value, admod, b29, iaddr, symlnk ) fixed bin (26), 2 19 2 (itxtmod, ilnkmod, entrieslc, include_file_list, include_index, 2 20 first_ref_trap_proc_linkno, first_ref_trap_arg_linkno, 2 21 text_section_length) fixed binary (26), 2 22 2 (include_info_stack, include_name_list_base, include_name_list_top) pointer, 2 23 2 symbol_tree_rel fixed binary (26); 2 24 2 25 /* End of the include file varcom.incl.pl1. */ 167 168 169 /* */ 170 mexp_$init: entry (acode); 171 172 /* Called by ALM at pass1/pass2 init. Allocate control structure, get 2 temp segs. First 173* contains macro definition blocks, second is first expansion output buffer. */ 174 175 sfap = get_system_free_area_ (); /* set up to alloc bct */ 176 allocate bct in (system_free_area); 177 bct.sfap = sfap; /* for later free */ 178 eb_data_$mexp_env_ptr = envp; 179 eb_data_$macro_linect = 0; 180 call get_temp_segments_ (gtsname, segarray_of_two, acode); 181 return; 182 183 mexp_$cleanup: entry; /* relinquish temp segs */ 184 185 /* Called by ALM at pass1/pass2 end, and on cleanup condition. Release control structure and 186* temp segs. */ 187 188 envp = eb_data_$mexp_env_ptr; 189 if envp = null then return; 190 call release_temp_segments_ (gtsname, bct.segarray, (0)); 191 sfap = bct.sfap; 192 free bct in (system_free_area); 193 eb_data_$mexp_env_ptr = null (); 194 return; 195 196 /* */ 197 198 dcl (nparens, i, ci, start, stop, j, iterate) fixed bin (21), 199 found_number bit (1) aligned, 200 si fixed bin (21), 201 mbptr ptr, /* Ptr to macro structure */ 202 save_free fixed bin (21), 203 val fixed bin, 204 semict fixed bin, /* Count of ALM statements by which to run ALM */ 205 t fixed bin (21), 206 type fixed bin, 207 nargs fixed bin, /* Number of macro args */ 208 nchars fixed bin (21), 209 ia fixed bin, 210 ml char (macro_len) based (mp), /* The Macro Definition Text. */ 211 macro_len fixed bin (21), 212 ob char (max_char_count) based (obp), /* The Output Buffer */ 213 currob char (next - 1) based (obp), /* Currently filled portion of Output Buffer */ 214 il char (nchars) based (tp), /* The Input Source */ 215 end_index fixed bin (21), 216 (save_segx, save_segx1, save_curlev) fixed bin, (save_charx, save_charx1) fixed bin (21), 217 match bit (1) aligned, 218 iftarget_cond bit (1) aligned, 219 (var_start, var_end) fixed bin (21), 220 opcode char (32) aligned, 221 iftarget_str char(24) varying, 222 iftarget_error fixed bin(35), 223 iftarget_value fixed bin(17), 224 system_type_ external entry(char(*), char(*), fixed bin(17), fixed bin(35)), 225 com_err_ external entry options(variable), 226 eb_data_$who_am_I external static char(12), 227 iterate_arg_no fixed bin (21), 228 (obp, mp, tp) ptr; 229 230 /* */ 231 232 /* Data structure used by expander--- macro is structure in temp seg (1). */ 233 234 dcl 1 ifargs (0: 99) aligned like args; /* Ptr/len array for pseudoop args */ 235 236 dcl 1 iterargs (0: 99) aligned like args based (iap), iap ptr; /* Bound to either args or exargs for &( */ 237 238 dcl 1 exargs (0: 99) aligned like args; /* Ptr/len array for decomposed argument */ 239 240 dcl 1 args (0: 99) aligned, /* Ptr/len array for macro args */ 241 2 start fixed bin (21), 242 2 len fixed bin (21); 243 244 dcl 1 macro based (mbptr) aligned, /* Definition of a macro, in tempseg (1) */ 245 2 next_macro ptr unal, /* Hash thread on name. */ 246 2 startchar fixed bin (21), /* charx of 1st char, for exp-time err recov. */ 247 2 sourcelen fixed bin (21), /* Length of def in chars, for ditto. */ 248 2 sourcep ptr unal, /* Ptr to sourceseg/expansion of def */ 249 250 2 pad bit (14) unal, 251 2 num_entries fixed bin (21) unal, /* Number of entries in macro.entry */ 252 253 2 name char (32), /* Macro name */ 254 2 entry (1000), /* One entry for control seq and tex up to it. */ 255 3 type fixed bin, /* Type of control sequence, see tbl above */ 256 3 value_1 fixed bin (13) unal, /* Encoded info, value depends on type of ctl seq */ 257 3 first_char fixed bin (21) unal, /* charx of text preceding ctl seq, always valid */ 258 259 3 value_2 fixed bin (13) unal, /* Encoded info, value depends on type of ctl seq */ 260 3 n_chars fixed bin (21) unal; /* Number of chars of text preceding ctl seq, c/b 0. */ 261 262 /* */ 263 264 mexp_$define_macro: entry (a_opcode); /* define a macro. */ 265 266 /* Define a macro. ALM has already picked up the name, and passed it to us, and validated the syntax 267* of the statement, which means that inputs_ is at the end of the statement. We let ALM decompose the 268* "macro" statement so that ALM's rules on valid symbols and delimiters, which will be used when 269* macro is used as opcode, can be applied. */ 270 271 envp = eb_data_$mexp_env_ptr; /* access control frame */ 272 273 do i = 1 to bct.curlevel; /* If source for definition lies in macro expansion, 274* make sure than no buffer space occupied by 275* outstanding macro expansions is ever freed/re-used. */ 276 /* This ensures the validity of ptr/len's to be encoded. */ 277 bct.outstack.segx (i) = bct.curexpseg; 278 bct.outstack.charx (i) = bct.segarray_free (bct.curexpseg); 279 end; 280 281 call get_ptrs; /* Find out where alm is, oughtta be next sta. */ 282 283 call get_hashx ((a_opcode)); /* Compute hash index */ 284 285 call define_macro (a_opcode, (tp), stop + 1, nchars - stop); /* do it */ 286 return; 287 288 /* */ 289 define_macro: proc (mname, mpstart, cistart, amacrolen); 290 291 dcl mp ptr, cifin fixed bin (21); 292 dcl bad_macro bit (1); 293 dcl (almpos, lasteralmpos) fixed bin (21); 294 dcl amacrolen fixed bin (21); 295 dcl condthread fixed bin, condstack (10) fixed bin; 296 dcl mname char (*), cistart fixed bin (21), mpstart ptr, ciprev fixed bin (21); 297 298 dcl ml char (macro_len) based (mp) aligned; 299 dcl (condlevel, itercondlevel) fixed bin; 300 dcl c2 char (2); 301 302 dcl start fixed bin (21); 303 dcl in_iteration fixed bin; 304 305 306 in_iteration = 0; /* Not inside ()'s */ 307 bad_macro = "0"b; /* No known problems, don't trash def. */ 308 condthread = -1; /* Not in []'s */ 309 condlevel = 0; /* Zero levels of outsdg []'s */ 310 macro_len = amacrolen; /* random arg copy, is remaining source len. */ 311 312 eb_data_$macro_linect = 1; /* Triggers inputs_ to increment this, 313* and prwrd_ to print it when > 0. */ 314 mbptr = ptr (bct.segarray (1), bct.macfree); /* This is where def block goes. */ 315 macro.name = mname; /* Copy name to defblock */ 316 317 mp = mpstart; /* Copy to automatic */ 318 macro.sourcep = mp; /* All parms in def block rel to this value */ 319 320 almpos, macro.startchar = cistart; /* Almpos for deferr, startchar for experr. */ 321 lasteralmpos = -1; /* For deferr. */ 322 ci = cistart - 1; /* Prime scan. */ 323 324 /* Break up macro definition text into control sequences separated by text. Each element in 325* macro.entry defines a control sequence and the text preceding it. */ 326 327 do entry_no = 1 by 1; /* iterate until macro defined */ 328 329 /* Locate the next &--- countrol sequence. If there's none, &end must be missing. */ 330 331 start = ci+1; /* get start of the current element */ 332 t = index (substr (ml, start), "&"); 333 if t = 0 | t = macro_len - start + 1 then do; 334 call deferr ("No &end"); 335 go to FI /NMLSPPT.pdt a}Ryג $ 6 z$Swß & D*@a} . | T*a} &|*a} z@a} *@a nBullMCOIN SwßSsyMaint Swß|(delete.HIS.pdt qrx5delete.OperDevel.pdt q: &aMM* z ~SUPPORT.pdt aRy׭ $ z$Swß *@a >*a *@a *@a D*@a > |*a z@a * ~&2Mҫ z 'Bull.pdt 2RyD !$ ` zSwß X *@2 " p*@2 "*@2  `*@2  *2 &Mc 2 2z * new.Bull.pdt MͿŸz$ zlSwß * h D*@2 z@2 p X|*2 hR*2 *@ x *@ P *@ P*@ xD*@ |* R* z@ *&Qt z *BullMCOIN.pdt RyG $ 4 zZSwß 4*@ *@ L *@ * D*@ tQmz !BBBJgZmFWMWKXK  $zSwß D L`* z@ * , F* , D*@ d* <*@ l* \*Qmz t' pdt.ht.temp  $zSwß ** * * *@@j1 BX@r=LSwalD&H &j1z*@j1,SysAdmin j1r*@j1 SysMaint j1*j1z*@j1*@j1*@j1&jVMadata jVRy_ $aj1PnX*@jVzSysDaemon j1d:*@jVRetriever j10db jVnBNetwork_Mailer j1zXOperator j1f*@jVInternet j1fX*@jV,Daemon j1:P,*@jVNetwork_Server j1z*#,,*@jVBX*@jVnOke j1&j[=/ainfo j[M$Ÿzaj1*@j[*@j[WAAnderson j1*@j[z*@j[*@j[M$za0db #zaj1d*@jV4X,*@oI<B,*@oI,*@oI\*@#Tz*@#|*#L*@#$z*@jVFMCTL_1 qZwick MuMultics z  f THoover Multics 8*S*?Oke Multics j9S-SY?Schroth SysMaint g4S*t,?p^Uhl Develcon PKk 22B0WAAnderson SysMaint :VS0'})N``Zwick Multics 8mS*j?A|VLMyers OperDevelPl>.MPv0PSherwood OperDevelPyd 0 687 then do; /* pop curr. macro. */ 688 689 /* This save-and-restore song and dance is needed for the following reason: Calling 690* alm_include_file$pop will cause the top regnant expansion (the one the ifend_exit alludes to) 691* to pop available buffer space to start below that expansion, which is below the 692* expansion we just produced, which isn't regnant yet. We can't push our ife output 693* until this old thing is off the stack, or they'd pop in the wrong order. */ 694 695 save_segx = bct.curexpseg; 696 save_charx = bct.segarray_free (save_segx); 697 call alm_include_file_$pop; /* pop mexp and alm */ 698 save_segx1 = bct.curexpseg; 699 save_charx1 = bct.segarray_free (save_segx1); 700 save_curlev = bct.curlevel; 701 bct.curexpseg = save_segx; 702 bct.segarray_free (save_segx) = save_charx; 703 call push_mexp_output_upon_alm; /* Do it. */ 704 if bct.curlevel ^= save_curlev then do; /* Make it ss that pop this pops hole. */ 705 bct.outstack (bct.curlevel).segx = save_segx1; 706 bct.outstack (bct.curlevel).charx = save_charx1; 707 end; 708 return; 709 end; 710 call push_mexp_output_upon_alm; 711 return; 712 end; 713 714 /* */ 715 716 717 if opcode = "warn" then do; /* Assembly-time msg */ 718 if var_start > 0 then call scan_args (args, nargs, var_start, var_end - var_start +1, code); 719 else args (1).len = 0; 720 if var_start ^> 0 | code ^= 0 then eb_data_$erflgs_overlay.prntf = 1; 721 call inputs_$next_statement; 722 do j = 1 to semict; 723 call inputs_$run_statement; 724 end; 725 temp_ap = addr (arg_1); temp_al = length (arg_1); 726 /* This little bit of obscurity 727* keeps substaddr from being non-quicked, 728* cause compiler would call it after 729* stack was extended for catenate. */ 730 call prnter_$macro_error (SIGNATURE || input_arg, input_arg); 731 return; 732 end; 733 734 735 /* No macros or pseudos match, return an error. */ 736 737 errflag = 1; 738 return; 739 740 /* */ 741 742 expand_macro: procedure; 743 744 /* The value of "opcode" has been found to be a macro name. The vbl "mbptr" points 745* to the macro definition block. The output buffer "ob" has been setup. Run ALM 746* past the invocation, and produce the expansion into ob. */ 747 748 dcl selector_eno fixed bin; 749 dcl tcode fixed bin (35); 750 dcl arg_offset fixed bin; 751 dcl (outstanding_select, outstanding_range) bit (1); 752 dcl (selector_ob_charpos, range_ob_charpos) fixed bin (21); 753 dcl select_answer fixed bin; 754 dcl found_d_error_lying_there bit (1); 755 756 mp = macro.sourcep; 757 outstanding_select, outstanding_range = "0"b; 758 found_d_error_lying_there = (eb_data_$erflgs_overlay.prntd ^= 0); 759 /* If this is pass2, all errors that we are going to find 760* were already found by us in pass1, and collated 761* on coll. tape entry for 1st sPJPSavoy OperDevelPzQW@VyOu0?.@@4 "Jameson Multics Pf5#:LnMA?\nnKrans OperDevelPzާWxDO4?Hussein Multics b;sS:#<? OHwang HFED Tբڸ<x|/܏jDRobinson Multics m|Mq܀) &&N<GMacIsaac UOFC PJ$S%B:TT Gray Multics @@9S+Yq)<pHinatsu Multics 8aS*^S=&?Hole Multics P^==KIAGee Multics * <S4)7  hV Ginter Multics P{.OA(0::  /(!Elhard Multics :S0_?Vhh !"Flegel Multics p8S) w?"#Fudge SysAdmin hHSߡyA #_$Dewar Multics PK8 M0$p%Ehrlenholtz Operator P`Q LRd<H T%B&Bueckert Develnet PKbpi<4NN&&'Collin Multics jSVUM_3j||'(DFreedman UOFC Pt ~N L^<()DGHowe Multics Pu@uNv|&?)*Buker HFED Pdb>-L:1:n* 844 XP (7): /* End of iteration (&)) */ 845 iterate = iterate + 1; 846 entry_no = save_free; 847 go to ANY_ARGS_Q; 848 XP (8): /* Iteration index (&x) */ 849 call outnum ((iterate)); 850 go to A; 851 XP (9): /* Special unique (&U) */ 852 i = bct.unique_generator1; 853 call ouch (".._"); 854 bct.unique_changed = "1"b; 855 go to UNIQUE1; 856 XP (10): /* Command arg (&A) */ 857 if val <= eb_data_$mexp_argno | val > eb_data_$alm_arg_count then code = error_table_$noarg; 858 else do; 859 temp_ap = arguments(val + eb_data_$mexp_argno).arg_ptr; 860 temp_al = arguments(val + eb_data_$mexp_argno).arg_len; 861 call outptr (temp_ap, temp_al); 862 end; 863 go to A; 864 XP (11): /* Arg length (&l) */ 865 call outnum (args (val).len); 866 go to A; 867 XP (12): /* Number of args (&K) */ 868 call outnum ((nargs)); 869 go to A; 870 XP (13): /* Number of iteration args (&k) */ 871 call outnum ((no_exargs)); 872 go to A; 873 XP (14): /* Null expansion (&& or end of macro) */ 874 go to A; 875 XP (15): /* Comparison ops */ 876 XP (19): /* Selector ops (&s) */ 877 if outstanding_select then call experr ("Unused selection"); 878 outstanding_select = "1"b; 879 selector_ob_charpos = next; /* Save for evaluator. */ 880 selector_eno = entry_no; 881 go to A; 882 XP (16): /* Open conditional (&[) */ 883 if ^outstanding_select then do; 884 call experr ("Brackets with no previous selector operation"); 885 select_answer = 1; 886 end; 887 else call pull_apart_select_input; 888 do i = 1 by 1 while (i < select_answer); 889 if macro.entry (entry_no).value_1 <= 0 then i = select_answer; 890 else entry_no = macro.entry (entry_no).value_1; 891 end; 892 go to A; 893 XP (17): /* End of conditional (&]) */ 894 go to A; 895 XP (18): /* Select else (&;) */ 896 do entry_no = entry_no repeat (macro.entry (entry_no).value_1) 897 while (macro.entry (entry_no).value_1 > 0); 898 end; 899 go to A; 900 XP (20): /* Fargs-macro (&F) */ 901 call output_fargs (args, nargs); 902 go to A; 903 XP (21): /* Fargs-iter (&f) */ 904 call output_fargs (exargs, no_exargs); 905 go to A; 906 XP (22): /* Iter over args. (&R) */ 907 if outstanding_range 908 then call experr ("Unused range specifier"); 909 outstanding_range = "1"b; 910 range_ob_charpos = next; 911 go to A; 912 A: 913 end; 914 915 return; 916 917 /* */ 918 output_fargs: proc (aaray, ct); 919 920 /* Used to output sequence of args, for &F and &f requests. val2 is 1 for FQ/fq */ 921 922 923 dcl 1 aaray (0:99) aligned, 924 2 start fixed bin (21), 925 2 len fixed bin (21); 926 927 dcl ct fixed bin; 928 dcl qsw bit (1); 929 dcl k fixed bin; 930 931 qsw = (macro.entry (entry_no).value_2 = 1); 932 do k = macro.entry (entry_no).value_1 to ct by 1; 933 if qsw then call ouch ("("); 934 call outptr (substaddr (il, aaray (k).start), (aaray (k).len)); 935 if qsw then call ouch (")"); 936 if k < ct then call ouch (","); 937 end; 938 end output_fargs; 939 940 /* */ 941 942 pull_apart_select_input: proc; /* Gets stuff out of output buffer to make selector clauses. */ 943 944 /* Used to get whatever input is needed out of expansion (ob) for &[. Defines based/adjustable "ebuf" 945* as portion of ob between where it was when selector appeared (selector_ob_charpos) and the &[. */ 946 947 dcl ep ptr, ebuf char (elen) based (ep), elen fixed bin (21); 948 dcl (s, t1, t2) fixed bin; 949 dcl comx fixed bin; 950 951 ep = substaddr (ob, selector_ob_charpos); 952 elen = length (currob) - selector_ob_charpos + 1; 953 954 if macro.entry (selector_eno).type = type_SELECT then 955 select_answer = collect_ob_num (1, elen); 956 else do; 957 comx = index (ebuf, ","); 958 if comx = 0 then do; 959 call experr ("No comma for conditional after expansion"); 960 select_answer = 0; 961 end; 962 else do; 963 s = macro.entry (selector_eno).value_1; /* Type of comparison */ 964 /* Remember that EQ and NE are char, others num. */ 965 if s <= NE then do; /* String compares, &=, &^= */ 966 if substr (ebuf, 1, comx - 1) = substr (ebuf, comx + 1) then select_answer = 1; 967 else select_answer = 2; 968 if s = NE then select_answer = 3 - select_answer; /* NE inverts test */ 969 end; 970 else do; /* Numeric compares, EQ and NE dont get used. */ 971 t1 = collect_ob_num (1, comx - 1); 972 t2 = collect_ob_num (comx + 1, elen); 973 if ((t1 = t2) & s = EQ) | ((t1 ^= t2) & s = NE) | ((t1 < t2) & s = LT) 974 | ((t1 <= t2) & s = LE) | ((t1 > t2) & s = GT) | ((t1 >= t2) & s = GE) 975 then select_answer = 1; /* TRUE */ 976 else select_answer = 2; /* FALSE */ 977 end; 978 end; 979 end; 980 next = selector_ob_charpos; 981 outstanding_select = "0"b; 982 return; 983 984 get_ob_rangeargs: entry (v1, v2); /* collect m and n, as in &Rm,n into v1, v2 */ 985 986 dcl (v1, v2) fixed bin; 987 988 ep = substaddr (ob, range_ob_charpos); 989 elen = length (currob) - range_ob_charpos + 1; 990 comx = index (ebuf, ","); 991 if comx = 0 then comx = elen + 1; 992 v1 = collect_ob_num (1, comx - 1); 993 v2 = collect_ob_num (comx + 1, elen); 994 next = range_ob_charpos; 995 outstanding_range = "0"b; 996 return; 997 998 /* */ 999 collect_ob_num: proc (fx, lx) returns (fixed bin); 1000 1001 /* This routine collects a decimal number at ebuf|fx until ebuf|lx, returning it. Note 1002* that cases of no digits, bad input, and large number of leading zeros are handled. */ 1003 1004 dcl (i, fx, lx) fixed bin (21); 1005 dcl d fixed bin init (0), c char (1) aligned; 1006 1007 do i = fx to lx; 1008 c = substr (ebuf, i); 1009 if c < "0" | c > "9" then do; 1010 call experr ("Bad numeric input to selector"); 1011 return (0); 1012 end; 1013 d = 10*d + fixed (unspec (c), 9) - 48; 1014 end; 1015 return (d); 1016 1017 end collect_ob_num; 1018 1019 end pull_apart_select_input; 1020 1021 experr: proc options (variable, non_quick); /* expansion error */ 1022 1023 /* Called by all expansion-time errors with formline_ arguments. Tries to figure out what 1024* _l_i_n_e of macro def contains the error, as ALM lists the expanded lines way after we have 1025* the whole expansion out the door, and user needs some hint. For this purpose 1026* only is macro.startchar maintained. */ 1027 1028 1029 dcl apos fixed bin (21), alct fixed bin (18); 1030 dcl vs char (200) varying; 1031 dcl nlx fixed bin (21); 1032 dcl mdef char (macro.sourcelen + macro.startchar - 1) based (macro.sourcep); 1033 dcl zzzzz9 pic "zzzzz9"; 1034 dcl errpos fixed bin (21); 1035 1036 if ^found_d_error_lying_there /* if this is news, .e., pass 1 */ 1037 then eb_data_$erflgs_overlay.prntd = 1; /* then make an error */ 1038 1039 call ioa_$general_rs (cu_$arg_list_ptr (), 1, 2, cbuf1, cb1l, "0"b, "0"b); 1040 1041 errpos = macro.entry (entry_no).first_char + macro.entry (entry_no).n_chars; 1042 apos = macro.startchar; 1043 nlx = index (substr (mdef, apos), NL); 1044 do alct = 1 by 1 while (^(nlx = 0 | apos + nlx > errpos)); 1045 nlx = index (substr (mdef, apos), NL); 1046 apos = apos + nlx; 1047 end; 1048 1049 zzzzz9 = alct; 1050 vs = cb1b || " in line " || ltrim (zzzzz9) || " of macro " || rtrim (macro.name) || "."; 1051 call prnter_$macro_error ("Macro expansion error: " || vs, 1052 "**** **** **** MACRO EXPANSION ERROR: " || vs); 1053 return; 1054 1055 end experr; 1056 1057 end expand_macro; 1058 /* */ 1059 mexp_$reset_macro: entry; 1060 1061 /* ALM calls this when the ALM input scanner, inputs_, runs off the end of something that was 1062* given to him by push_mexp_output_upon_alm below. */ 1063 1064 1065 envp = eb_data_$mexp_env_ptr; 1066 call pop_mexp_level; 1067 return; 1068 1069 1070 push_mexp_output_upon_alm: procedure; 1071 1072 /* Redefine free space in segment containing ob not to include ob. Stack the description 1073* of what free space will be when this is popped (which is what it is now). Tell ALM 1074* to push the string "ob" upon its input stack. ALM will call mexp_$reset_macro 1075* when he (the input scanner, inputs_) runs off the end of it. */ 1076 1077 1078 if bct.curlevel >= hbound (bct.outstack, 1) then 1079 call genabort ("Macro depth exceeds ^d.", bct.curlevel); 1080 if length (currob) <= 0 then return; /* Don't output empty buffers */ 1081 if substr (currob, length (currob), 1) ^= NL then call ouch (NL); 1082 /* Make sure lines dont spill, listing happens. */ 1083 call alm_include_file_$macro (addr (currob), length (currob)); 1084 bct.curlevel = bct.curlevel + 1; 1085 bct.outstack (bct.curlevel).segx = bct.curexpseg; 1086 bct.outstack (bct.curlevel).charx = bct.segarray_free (bct.curexpseg); 1087 bct.segarray_free (bct.curexpseg) = bct.segarray_free (bct.curexpseg) + length (currob); 1088 return; 1089 1090 end push_mexp_output_upon_alm; 1091 1092 pop_mexp_level: procedure; 1093 1094 /* Return current expansion's space to free space in its segment. If this brings us 1095* to bottom of segment other than the first, go back a segment, for free space now starts 1096* there. */ 1097 1098 1099 if bct.curlevel = 0 then 1100 call genabort ("Macro stack underflow. Contact assembler maintainers."); 1101 1102 bct.curexpseg = bct.outstack (bct.curlevel).segx; 1103 bct.segarray_free (bct.curexpseg) = bct.outstack (bct.curlevel).charx; 1104 bct.curlevel = bct.curlevel - 1; 1105 if bct.curexpseg > 2 & bct.segarray_free (bct.curexpseg) = 1 1106 then bct.curexpseg = bct.curexpseg - 1; 1107 return; 1108 1109 end pop_mexp_level; 1110 1111 1112 /* */ 1113 1114 1115 /* This procedure, with all its entries, generates all text in the 1116* output buffer, ob. It takes responsibility for moving it when it 1117* must be grown. */ 1118 1119 outptr: proc (aoutp, aoutl); /* Output aoutp->char(aoutl) to ob */ 1120 1121 dcl (aoutp, outp) ptr; 1122 dcl outstring char (outl) based (outp); 1123 dcl save_obp ptr, save_obl fixed bin (21); 1124 dcl (aoutl, outl) fixed bin (21); 1125 dcl str char (*); 1126 dcl num fixed bin (21); 1127 dcl zzzzzzz9 picture "zzzzzzz9"; 1128 dcl cbuf char (8); 1129 1130 outl = aoutl; 1131 outp = aoutp; 1132 go to outpr_join; 1133 1134 ouch: entry (str); /* Output value of "str" to ob */ 1135 1136 outl = length (str); 1137 outp = addr (str); 1138 go to outpr_join; 1139 1140 outnum: entry (num); /* Output canonical number to ob */ 1141 1142 zzzzzzz9 = num; 1143 outl = length (ltrim (zzzzzzz9)); 1144 cbuf = ltrim (zzzzzzz9); 1145 outp = addr (cbuf); 1146 1147 1148 outpr_join: 1149 if length (outstring) = 0 then return; 1150 1151 if length (currob) + length (outstring) > length (ob) then do; 1152 save_obp = addr (currob); 1153 save_obl = length (currob); 1154 call make_new_outbuf$force; 1155 next = save_obl + 1; 1156 currob = save_obp -> currob; 1157 end; 1158 1159 substr (ob, next, length (outstring)) = outstring; 1160 next = next + length (outstring); 1161 1162 return; 1163 1164 end outptr; 1165 1166 /* 1167**/ 1168 substaddr: proc (chs, ix) returns (ptr); 1169 dcl chxa (length (chs)) char (1) unal based; /* for char addressing */ 1170 dcl chs char (*), ix fixed bin (21); 1171 return (addr (addr (chs) -> chxa (ix))); 1172 end substaddr; 1173 1174 make_new_outbuf: proc; 1175 1176 /* This procedure defines the based/adjustable output buffer "ob" as the remainder of the 1177* current output buffer segment. If $force is called, it is because a string that 1178* outptr/ouch/outnum wants to put in ob won't fit. So ob is redefined to the next 1179* buffer segment, and the old ob copied. The vbl "next" is the next available char pos 1180* in current ob. */ 1181 1182 1183 dcl segx fixed bin; 1184 dcl force bit (1); 1185 1186 force = "0"b; 1187 go to mnob_join; 1188 1189 make_new_outbuf$force: entry; 1190 1191 force = "1"b; 1192 mnob_join: 1193 1194 segx = bct.curexpseg; 1195 if force then segx, bct.curexpseg = segx + 1; 1196 if bct.segarray (segx) = null then do; 1197 call get_temp_segments_ (gtsname, segarray_of_one, (0)); 1198 bct.segarray (segx) = segarray_of_one (1); 1199 end; 1200 obp = substaddr (bct.segarray (segx) -> ob, bct.segarray_free (segx)); 1201 max_char_count = sys_info$max_seg_size * 4 - bct.segarray_free (segx) + 1; 1202 next = 1; 1203 1204 end make_new_outbuf; 1205 /* */ 1206 1207 scan_args: proc (array, no_args, firstx, count, acode); 1208 1209 /* This routine scans the "count" chars at il|firstx according to the rules of 1210* macro arguments. Processing of nested parens, line breaks and continuations, and 1211* commas is all done here. */ 1212 1213 1214 dcl 1 array (0: 99) aligned, 1215 2 first fixed bin (21), 1216 2 size fixed bin (21); 1217 1218 dcl acode fixed bin (35); 1219 1220 dcl c2 char (2) aligned; 1221 1222 dcl no_args fixed bin, 1223 (firstx, count, arg_start, last) fixed bin (21); 1224 1225 array (*).size = 0; 1226 acode = 0; 1227 arg_start, ci = firstx; 1228 last = ci + count - 1; 1229 no_args = 0; 1230 GET_ANOTHER_ARG: 1231 c2 = substr (il, ci-1, 2); 1232 if c2 = COMMA_NL | c2 = ", " | c2 = ", " | c2 = ",""" | c2 = ",;" then do; 1233 /* Continue on next ALM statement. */ 1234 if addr (array) ^= addr (exargs) then /* At top level */ 1235 call skip_to_next_line; 1236 else do; 1237 stop = stop - 1; 1238 start = ci + 1; 1239 end; 1240 if stop > nchars then return; 1241 semict = semict + 1; /* schedule almrunning */ 1242 if stop > nchars then return; 1243 t = verify (substr (il, start, stop-start+1), WHITE)-1; /* skip white space */ 1244 if t < 0 then ci = stop+1; 1245 else ci = start + t; 1246 arg_start = ci; /* save start of variable field */ 1247 call soc; /* skip to end of variable field */ 1248 if stop = ci-1 then last = ci-2; 1249 else last = ci-1; 1250 ci = arg_start; 1251 goto GET_ANOTHER_ARG; 1252 end; 1253 1254 else if substr (il, ci, 1) = "(" then do; /* watch out for args with parens */ 1255 nparens = 1; /* skip till no more parens at this level */ 1256 do ci = ci+1 to last while (nparens > 0); 1257 if substr (il, ci, 1) = "(" then nparens = nparens + 1; 1258 else if substr (il, ci, 1) = ")" then nparens = nparens - 1; 1259 end; 1260 if nparens > 0 then do; 1261 acode = 1; 1262 return; 1263 end; 1264 1265 no_args = no_args + 1; 1266 array.first (no_args) = arg_start+1; /* copy information about where the arg is */ 1267 array.size (no_args) = ci - arg_start - 2; 1268 goto NEXT_ARG; 1269 end; 1270 1271 else do; /* argument didn' start with paren */ 1272 t = index (substr (il, ci, last-ci+1), ",")-1; 1273 if t < 0 then ci = last + 1; 1274 else ci = ci + t; 1275 1276 no_args = no_args + 1; 1277 array.first (no_args) = arg_start; 1278 array.size (no_args) = ci - arg_start; 1279 NEXT_ARG: ci, arg_start = ci+1; 1280 if arg_start <= last+1 then goto GET_ANOTHER_ARG; 1281 end; 1282 return; 1283 1284 1285 end scan_args; 1286 /* */ 1287 1288 1289 skip_to_next_line: proc; 1290 1291 /* This procedure sets "stop" to be the charindex of the last char of the 1292* (possibly multi-ALM-statement) macro or pseudoop invocation. The 1293* only legal ALM-statement breaks are those in parens. The vbl "semict" is incremented 1294* to tell larger routines how many times to call inputs_$run/next_statement to 1295* skip ALM's input scanner (inputs_) over that many ALM statements. Note: 1296* If _w_e don't know that some semicolon-containing thing is actually an ACC string 1297* etc., ALM doesn't know _e_i_t_h_e_r, annd considers it a statement break, 'cause 1298* he's skipping statements, not semanticating them. */ 1299 1300 1301 start = stop+1; /* get start of next line */ 1302 dcl nparens fixed bin; 1303 1304 nparens = 0; 1305 stop = start; 1306 more: t = search (substr (il, stop), ENDS)-1; 1307 if t < 0 then do; 1308 stop = nchars + 1; 1309 return; 1310 end; 1311 stop = stop + t; 1312 if substr (il, stop, 1) = "(" then nparens = nparens + 1; 1313 else if substr (il, stop, 1) = ")" then nparens = nparens - 1; 1314 else if substr (il, stop, 1) = ";" & nparens > 0 then semict = semict + 1; 1315 else if substr (il, stop, 1) = NL & nparens > 0 then semict = semict + 1; 1316 /* Ignore statement breaks inside parens */ 1317 else return; 1318 stop = stop + 1; 1319 go to more; 1320 1321 end; 1322 1323 get_hashx: procedure (name); /* Generate hash index */ 1324 1325 dcl name char (32) aligned; 1326 dcl fb35 fixed bin (35), (mod, abs) builtin; 1327 1328 unspec (fb35) = bool (substr (unspec (name), 1, 36), bool (substr (unspec (name), 37, 36), 1329 bool (substr (unspec (name), 73, 36), substr (unspec (name), 109, 36), "0110"b), "0110"b), "0110"b); 1330 1331 hashx = abs (mod (fb35, 127)); 1332 if ^substr (bct.hashx_used, hashx + 1, 1) then do; 1333 substr (bct.hashx_used, hashx + 1, 1) = "1"b; 1334 bct.macroptr (hashx) = null; 1335 end; 1336 return; 1337 1338 end; 1339 /* */ 1340 sob: proc; 1341 1342 /* This procedure moves ci to first non-white character. */ 1343 1344 1345 t = verify (substr (il, ci, stop-ci+1), WHITE)-1; 1346 ci = ci + t; 1347 return; 1348 1349 end; 1350 soc: proc; 1351 1352 /* This procedure moves ci over non-white characters to next whitespace. */ 1353 1354 1355 dcl nparens fixed bin; 1356 1357 nparens = 0; 1358 more: t = search (substr (il, ci, stop-ci+1), "() """)-1; 1359 if t < 0 then do; 1360 ci = stop+1; 1361 return; 1362 end; 1363 ci = ci + t; 1364 c = substr (il, ci, 1); 1365 if c = "(" then nparens = nparens + 1; 1366 else if c = ")" then nparens = nparens - 1; 1367 else if nparens = 0 then return; 1368 ci = ci + 1; 1369 goto more; 1370 1371 end; 1372 1373 1374 1375 get_ptrs: proc; /* Set mexp ptrs from ALM */ 1376 1377 /* This procedure sets our variables from ALM's input scanner, inputs_. Inputs_ 1378* usually scans up to and beyond a break. We set variables to first char he hasn't 1379* scanned. "alm_finished_the_line" is inputs_'s "ibrk = inl" state, in which 1380* he has scanned the last semi/nl on a statement, but inputs_$next_statement 1381* hasn't been called yet. */ 1382 1383 1384 dcl (offset, sourcelen) fixed bin (21); 1385 1386 call inputs_$get_ptr (tp, offset, sourcelen, alm_finished_the_line); 1387 1388 nchars = offset + sourcelen; 1389 stop = offset; 1390 ci, start = stop + 1; 1391 return; 1392 end get_ptrs; 1393 1394 /* */ 1395 1396 genabort: proc options (variable, non_quick); 1397 1398 call ioa_$general_rs (cu_$arg_list_ptr (), 1, 2, cbuf1, cb1l, "0"b, "0"b); 1399 call prnter_$general_abort (cb1b); 1400 end genabort; 1401 /* */ 3 1 3 2 /* Last modified by EBush on 2/5/81 to add prnta */ 3 3 3 4 3 5 declare 1 eb_data_$erflgs ext aligned, 3 6 2 flgvec (36) fixed bin (17) aligned ; 3 7 3 8 3 9 declare 1 eb_data_$erflgs_overlay ext aligned, /* overlays the FLGVEC */ 3 10 2 (prnte, prntf, prntm, prntn, prnto, prntp, 3 11 prntr, prnts, prntt, prntu, prntx, prntb, 3 12 prntc, prntd, prnta, prnt5, prnt6, prnt7, 3 13 tstsw(18) ) fixed bin (17) aligned ; 3 14 3 15 1402 1403 end mexp_$ignore; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/17/88 0938.9 mexp_.pl1 >spec>install>1170>mexp_.pl1 166 1 06/19/81 2115.0 system_types.incl.pl1 >ldd>include>system_types.incl.pl1 167 2 10/21/74 1242.9 varcom.incl.pl1 >ldd>include>varcom.incl.pl1 1402 3 07/17/81 1911.5 erflgs.incl.pl1 >ldd>include>erflgs.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. COMMA_NL constant char(2) initial packed unaligned dcl 36 ref 1232 COMPARISON_CHARS 000031 constant char(4) initial packed unaligned dcl 83 ref 357 COMPARISON_ENCODE 000026 constant char(12) initial packed unaligned dcl 84 ref 374 ENDS 000060 constant char(4) initial packed unaligned dcl 36 ref 1306 EQ constant fixed bin(17,0) initial dcl 85 ref 973 GE constant fixed bin(17,0) initial dcl 85 ref 973 GT constant fixed bin(17,0) initial dcl 85 ref 973 L68_SYSTEM constant fixed bin(17,0) initial dcl 1-3 ref 647 659 LE constant fixed bin(17,0) initial dcl 85 ref 973 LT constant fixed bin(17,0) initial dcl 85 ref 973 MEXP_CTL_CHARS 000035 constant char(22) initial packed unaligned dcl 79 ref 350 NE constant fixed bin(17,0) initial dcl 85 ref 965 968 973 NL 000047 constant char(1) initial packed unaligned dcl 36 set ref 526 527 576 1043 1045 1081 1081* 1315 QUOTE 000010 internal static char(1) initial dcl 36 set ref 576 676 676 683 683 SIGNATURE 000043 constant char(14) initial packed unaligned dcl 36 ref 730 TERMS constant char(2) initial packed unaligned dcl 36 ref 525 TRIVIAL_ENCODES 000032 constant char(9) initial packed unaligned dcl 82 ref 364 WHITE constant char(2) initial packed unaligned dcl 36 ref 1243 1345 a_opcode parameter char packed unaligned dcl 549 set ref 264 283 285* 548 561 aaray parameter structure array level 1 dcl 923 set ref 918 abs builtin function dcl 1326 ref 1331 acode parameter fixed bin(35,0) dcl 122 in procedure "mexp_$ignore" set ref 170 180* acode parameter fixed bin(35,0) dcl 1218 in procedure "scan_args" set ref 1207 1226* 1261* addr builtin function dcl 36 ref 180 472 534 534 676 676 683 683 725 821 838 1050 1083 1083 1137 1145 1152 1171 1171 1234 1234 1399 alct 000101 automatic fixed bin(18,0) dcl 1029 set ref 1044* 1049 alm_finished_the_line 000113 automatic bit(1) dcl 36 set ref 568 1386* alm_include_file_$macro 000046 constant entry external dcl 155 ref 1083 alm_include_file_$pop 000050 constant entry external dcl 155 ref 697 almpos 001520 automatic fixed bin(21,0) dcl 293 set ref 320* 525 526 527 529 532 540 541* 541 amacrolen parameter fixed bin(21,0) dcl 294 ref 289 310 aoutl parameter fixed bin(21,0) dcl 1124 ref 1119 1130 aoutp parameter pointer dcl 1121 ref 1119 1131 apos 000100 automatic fixed bin(21,0) dcl 1029 set ref 1042* 1043 1044 1045 1046* 1046 arg_1 based char packed unaligned dcl 36 set ref 725 725 arg_len 2 based fixed bin(21,0) array level 2 dcl 142 ref 631 860 arg_offset 001572 automatic fixed bin(17,0) dcl 750 set ref 812 812 812 822* 823 823* 823 825 826 827 839* arg_ptr based pointer array level 2 dcl 142 ref 630 859 arg_start 001755 automatic fixed bin(21,0) dcl 1222 set ref 1227* 1246* 1250 1266 1267 1277 1278 1279* 1280 args 001166 automatic structure array level 1 dcl 240 set ref 496 497 497 718* 771* 821 900* arguments based structure array level 1 unaligned dcl 142 array parameter structure array level 1 dcl 1214 set ref 1207 1234 bad_macro 001517 automatic bit(1) packed unaligned dcl 292 set ref 307* 460 533* bct based structure level 1 dcl 125 set ref 176 192 c 001560 automatic char(1) dcl 486 in procedure "get_numeric_value_could_be_0" set ref 491* 492 492 494 c 000110 automatic char(1) dcl 36 in procedure "mexp_$ignore" set ref 347* 350 357 359* 364 371 424* 425 425 574* 576 576 576 1364* 1365 1366 c 001672 automatic char(1) dcl 1005 in procedure "collect_ob_num" set ref 1008* 1009 1009 1013 c2 001754 automatic char(2) dcl 1220 in procedure "scan_args" set ref 1230* 1232 1232 1232 1232 1232 c2 001540 automatic char(2) packed unaligned dcl 300 in procedure "define_macro" set ref 369* 370 370 370 371 371* 373 373* 374 cb1b based char packed unaligned dcl 36 set ref 534 534 1050 1399* cb1l 000237 automatic fixed bin(17,0) dcl 36 set ref 521* 534 534 1039* 1050 1398* 1399 1399 cbuf 001726 automatic char(8) packed unaligned dcl 1128 set ref 1144* 1145 cbuf1 000155 automatic char(200) packed unaligned dcl 36 set ref 521* 534 534 1039* 1050 1398* 1399 cha 000101 automatic char(1) packed unaligned dcl 518 set ref 526* 526* 527 charx 410(14) based fixed bin(21,0) array level 3 packed packed unaligned dcl 125 set ref 278* 706* 1086* 1103 chs parameter char packed unaligned dcl 1170 set ref 1168 1171 chxa based char(1) array packed unaligned dcl 1169 set ref 1171 ci 000256 automatic fixed bin(21,0) dcl 198 set ref 322* 331 338* 338 345 347 356 362* 362 369 370* 370 424 426* 426 436* 436 444 451 453 490* 490 490* 491* 527 571* 574 577 579 580 1227* 1228 1230 1238 1244* 1245* 1246 1248 1248 1249 1250* 1254 1256* 1256* 1257 1258* 1267 1272 1272 1273* 1274* 1274 1278 1279 1279* 1345 1345 1346* 1346 1358 1358 1360* 1363* 1363 1364 1368* 1368 1390* cifin 001516 automatic fixed bin(21,0) dcl 291 set ref 444* 445 451 458 ciprev 001535 automatic fixed bin(21,0) dcl 296 set ref 453* 458 cistart parameter fixed bin(21,0) dcl 296 ref 289 320 322 445 code 000101 automatic fixed bin(35,0) dcl 36 set ref 617* 622 637* 638 718* 720 856* com_err_ 000074 constant entry external dcl 198 ref 650 comx 001660 automatic fixed bin(17,0) dcl 949 set ref 957* 958 966 966 971 972 990* 991 991* 992 993 condlevel 001536 automatic fixed bin(17,0) dcl 299 set ref 309* 378 380* 380 385 389 392 393* 393 394 397 400 407 412 443 condstack 001523 automatic fixed bin(17,0) array dcl 295 set ref 378 378 378 385* 392 condthread 001522 automatic fixed bin(17,0) dcl 295 set ref 308* 385 386* 390 392* 398 399* convert_binary_integer_$octal_string 000012 constant entry external dcl 36 ref 806 count parameter fixed bin(21,0) dcl 1222 ref 1207 1228 ct parameter fixed bin(17,0) dcl 927 ref 918 932 936 cu_$arg_list_ptr 000016 constant entry external dcl 36 ref 521 521 1039 1039 1398 1398 curexpseg 3 based fixed bin(17,0) initial level 2 dcl 125 set ref 176* 277 278 695 698 701* 1085 1086 1087 1087 1102* 1103 1105 1105 1105* 1105 1192 1195* curlevel 406 based fixed bin(17,0) initial level 2 dcl 125 set ref 176* 273 614 619 686 700 704 705 706 1078 1078* 1084* 1084 1085 1086 1099 1102 1103 1104* 1104 currob based char packed unaligned dcl 198 set ref 952 989 1080 1081 1081 1083 1083 1083 1083 1087 1151 1152 1153 1156* 1156 cv_dec_check_ 000014 constant entry external dcl 36 ref 637 d 001671 automatic fixed bin(17,0) initial dcl 1005 set ref 1005* 1013* 1013 1015 discard 000103 automatic fixed bin(17,0) dcl 36 set ref 637* eb_data_$alm_arg_count 000064 external static fixed bin(17,0) dcl 160 ref 629 856 eb_data_$alm_arg_ptr 000066 external static pointer dcl 160 ref 630 631 859 860 eb_data_$erflgs_overlay 000100 external static structure level 1 dcl 3-9 eb_data_$macro_linect 000060 external static fixed bin(17,0) dcl 160 set ref 179* 312* 456* eb_data_$mexp_argno 000062 external static fixed bin(17,0) dcl 160 ref 629 856 859 860 eb_data_$mexp_env_ptr 000056 external static pointer dcl 160 set ref 178* 188 193* 271 563 1065 eb_data_$varcom 000070 external static structure level 1 dcl 2-7 eb_data_$who_am_I 000076 external static char(12) packed unaligned dcl 198 set ref 650* ebuf based char packed unaligned dcl 947 ref 957 966 966 990 1008 elen 001654 automatic fixed bin(21,0) dcl 947 set ref 952* 954* 957 966 966 972* 989* 990 991 993* 1008 end_index 000301 automatic fixed bin(21,0) dcl 198 set ref 616* 675 686 entry 15 based structure array level 2 dcl 244 set ref 472 entry_no 000102 automatic fixed bin(21,0) dcl 36 set ref 327* 340 345 354 361 374 386 390 391 398 399 403 404 414 415 417 420 420 427 429 430 435* 458 458 461* 465 466 472 786* 787 787 787 789 790 817 841* 846* 880 889 890* 890 895* 895 895* 898 931 932 1041 1041 envp 000244 automatic pointer dcl 121 set ref 176* 177 178 180 188* 189 190 191 192 271* 273 277 277 278 278 278 314 314 467 471 472 563* 588 614 619 686 695 696 698 699 700 701 702 704 705 705 706 706 764 765 765 766 799 802 802 804 809 851 854 1065* 1078 1078 1078 1084 1084 1085 1085 1085 1086 1086 1086 1086 1087 1087 1087 1087 1099 1102 1102 1102 1103 1103 1103 1103 1104 1104 1105 1105 1105 1105 1105 1192 1195 1196 1198 1200 1200 1201 1332 1333 1334 ep 001652 automatic pointer dcl 947 set ref 951* 957 966 966 988* 990 1008 errflag parameter fixed bin(1,0) dcl 549 set ref 548 562* 737* error_table_$noarg 000020 external static fixed bin(35,0) dcl 36 ref 856 errpos 000170 automatic fixed bin(21,0) dcl 1034 set ref 1041* 1044 exargs 000656 automatic structure array level 1 dcl 238 set ref 833* 838 903* 1234 fb35 002000 automatic fixed bin(35,0) dcl 1326 set ref 1328* 1331 first parameter fixed bin(21,0) array level 2 dcl 1214 set ref 1266* 1277* first_char 16(14) based fixed bin(21,0) array level 3 packed packed unaligned dcl 244 set ref 340* 787 787 1041 first_time_thru parameter bit(1) packed unaligned dcl 549 set ref 548 648 651* firstx parameter fixed bin(21,0) dcl 1222 ref 1207 1227 force 001745 automatic bit(1) packed unaligned dcl 1184 set ref 1186* 1191* 1195 found_d_error_lying_there 001600 automatic bit(1) packed unaligned dcl 754 set ref 758* 1036 found_number 000263 automatic bit(1) dcl 198 set ref 355 489* 493* fx parameter fixed bin(21,0) dcl 1004 ref 999 1007 get_system_free_area_ 000026 constant entry external dcl 150 ref 175 get_temp_segments_ 000030 constant entry external dcl 151 ref 180 1197 gsw 000102 automatic bit(1) initial packed unaligned dcl 519 set ref 513* 519* 537 gtsname 000050 constant char(32) initial packed unaligned dcl 36 set ref 180* 190* 1197* hashx 000250 automatic fixed bin(17,0) dcl 123 set ref 467 471 588 1331* 1332 1333 1334 hashx_used 402 based bit(127) initial level 2 dcl 125 set ref 176* 1332 1333* i 001670 automatic fixed bin(21,0) dcl 1004 in procedure "collect_ob_num" set ref 1007* 1008* i 000255 automatic fixed bin(21,0) dcl 198 in procedure "mexp_$ignore" set ref 273* 277 278* 488* 494* 494 496 497* 498* 500 799* 804* 806 809* 831* 832 833* 851* 888* 888* 889* ia 000277 automatic fixed bin(17,0) dcl 198 set ref 629* 630 631* iap 000654 automatic pointer dcl 236 set ref 812 812 812 821* 838* ifargs 000344 automatic structure array level 1 dcl 234 set ref 617* iftarget_cond 000310 automatic bit(1) dcl 198 set ref 606* 676 677 682 iftarget_error 000332 automatic fixed bin(35,0) dcl 198 set ref 655* 656 iftarget_str 000323 automatic varying char(24) dcl 198 set ref 654* 655 iftarget_value 000333 automatic fixed bin(17,0) dcl 198 set ref 655* 659* 661 il based char packed unaligned dcl 198 set ref 574 609 626 666 677* 677* 684* 684* 686 725* 725* 794* 794* 812* 812* 934* 934* 1230 1243 1254 1257 1258 1272 1306 1312 1313 1314 1315 1345 1358 1364 in_iteration 001542 automatic fixed bin(17,0) dcl 303 set ref 306* 365 394 400 405 406* 410* 410 411 431 441 index builtin function dcl 36 ref 332 350 357 364 374 609 957 990 1043 1045 1272 input_arg based char packed unaligned dcl 36 set ref 632 730 730* inputs_$get_ptr 000044 constant entry external dcl 154 ref 1386 inputs_$next_statement 000040 constant entry external dcl 153 ref 614 721 762 inputs_$next_statement_nolist 000042 constant entry external dcl 153 ref 615 inputs_$run_statement 000034 constant entry external dcl 153 ref 452 529 540 619 723 775 inputs_$run_statement_nolist 000036 constant entry external dcl 153 ref 620 679 681 ioa_$general_rs 000022 constant entry external dcl 36 ref 521 1039 1398 iterargs based structure array level 1 dcl 236 iterate 000262 automatic fixed bin(21,0) dcl 198 set ref 782* 812 812 812 819* 841 844* 844 848 iterate_arg_no 000334 automatic fixed bin(21,0) dcl 198 set ref 830* 831 833 834* itercondlevel 001537 automatic fixed bin(17,0) dcl 299 set ref 394 400 407* 412 ix parameter fixed bin(21,0) dcl 1170 ref 1168 1171 j 000261 automatic fixed bin(21,0) dcl 198 set ref 609* 610 616 618* 722* 774* jx 000100 automatic fixed bin(21,0) dcl 518 set ref 525* 526 526 527 541 k 001641 automatic fixed bin(17,0) dcl 929 set ref 932* 934 934 934 936* last 001756 automatic fixed bin(21,0) dcl 1222 set ref 1228* 1248* 1249* 1256 1272 1273 1280 lasteralmpos 001521 automatic fixed bin(21,0) dcl 293 set ref 321* 529 532* 540 len 1 001166 automatic fixed bin(21,0) array level 2 in structure "args" dcl 240 in procedure "mexp_$ignore" set ref 719* 725 725 772* 781* 794* 831 864* len 1 parameter fixed bin(21,0) array level 2 in structure "aaray" dcl 923 in procedure "output_fargs" ref 934 len 1 000344 automatic fixed bin(21,0) array level 2 in structure "ifargs" dcl 234 in procedure "mexp_$ignore" set ref 626 666 len 1 based fixed bin(21,0) array level 2 in structure "iterargs" dcl 236 in procedure "mexp_$ignore" set ref 812* length builtin function dcl 36 ref 725 952 989 1080 1081 1083 1083 1087 1136 1143 1148 1151 1151 1151 1153 1159 1160 lx parameter fixed bin(21,0) dcl 1004 ref 999 1007 macfree 407 based fixed bin(17,0) initial level 2 dcl 125 set ref 176* 314 472* macro based structure level 1 dcl 244 macro_len 000300 automatic fixed bin(21,0) dcl 198 set ref 310* 332 333 347 356 369 424 491 525 526 787 787 787 787 macroptr 4 based pointer array level 2 dcl 125 set ref 467 471* 588 1334* match 000307 automatic bit(1) dcl 198 set ref 628* 629 632* 634* 634 638* 639* 639 661* 662* 662 666* 667* 668* 668 676 677 686 max_char_count 000243 automatic fixed bin(21,0) dcl 36 set ref 951 951 988 988 1151 1159 1200 1200 1201* mbptr 000266 automatic pointer dcl 198 set ref 314* 315 318 320 340 345 354 361 374 390 391 398 404 414 415 417 420 420 427 429 430 435 445 458 458 462 465 466 467 471 472 534 588* 588* 589* 595 756 786 787 787 787 789 790 841 889 890 895 898 931 932 954 963 1041 1041 1042 1043 1043 1043 1045 1045 1045 1050 mdef based char packed unaligned dcl 1032 ref 1043 1045 ml based char dcl 298 in procedure "define_macro" ref 332 347 356 369 424 491 525 526 ml based char packed unaligned dcl 198 in procedure "mexp_$ignore" set ref 787* 787* mname parameter char packed unaligned dcl 296 ref 289 315 mod builtin function dcl 1326 ref 1331 mp 001514 automatic pointer dcl 291 in procedure "define_macro" set ref 317* 318 332 347 356 369 424 491 525 526 mp 000340 automatic pointer dcl 198 in procedure "mexp_$ignore" set ref 756* 787 787 mpstart parameter pointer dcl 296 ref 289 317 451 n_chars 17(14) based fixed bin(21,0) array level 3 packed packed unaligned dcl 244 set ref 345* 420* 420 458* 458 462* 787 1041 name parameter char(32) dcl 1325 in procedure "get_hashx" ref 1323 1328 1328 1328 1328 name 5 based char(32) level 2 in structure "macro" dcl 244 in procedure "mexp_$ignore" set ref 315* 534 589 1050 nargs 000275 automatic fixed bin(17,0) dcl 198 set ref 718* 771* 772* 794 827 867 900* nchars 000276 automatic fixed bin(21,0) dcl 198 set ref 285 574 609 626 666 677 677 677 677 684 684 684 684 686 725 725 725 725 794 794 794 794 812 812 812 812 934 934 934 934 1230 1240 1242 1243 1254 1257 1258 1272 1306 1308 1312 1313 1314 1315 1345 1358 1364 1388* next 000100 a@}̩ ~2r [ 54`"4DE]@#|SwX SvD5545&H*&*EO05TTaLtools_gm.mail *EOL1G`HE$ a:}̩&q>jzzarrSamanani.mbx qRy7GQIa}̩*@(qD4nSysDaemon }̩*@q4Samanani }̩(`Multics }̩*@(q@|&CEO0]adissent.trans CEOL9G $ a}̩*@C*CTF&CEO0Va~vfile.status.trans CEOLjG $ >a}̩r*C*@C&CEO0UNNaFfrank.copyright CEOLMG $ laY}̩x*@Cj*C,&CEO0\a|govt_time_est.mail CEOLVGQ $ a 9}̩*@C*C&i@aMigration_Issues.forum i>udd>mi>mtgs>migration.forum}̩fJ*CX*@C&CEO0Qa;serb.mail CEOLGw $ va%}̩nR*Ch*@Cr&i@&&ameetings i>udd>Multics>Samanani}̩~b*C`*C&CEO0X\\aTVserb.trans CEOLGw $ zap-}̩*@C&*@5T&CEO0Yabeta.compin CEOKG?$ va}}̩z*C>"*CbH&a>Zenvironment.forum i>site>forum_dir>env.forum}̩F**C0*@ 1159 1160 outstack 410 based structure array level 2 dcl 125 set ref 1078 outstanding_range 001574 automatic bit(1) packed unaligned dcl 751 set ref 757* 820 906 909* 995* outstanding_select 001573 automatic bit(1) packed unaligned dcl 751 set ref 757* 875 878* 882 981* outstring based char packed unaligned dcl 1122 ref 1148 1151 1159 1159 1160 prnta 16 000100 external static fixed bin(17,0) level 2 dcl 3-9 set ref 645* prntd 15 000100 external static fixed bin(17,0) level 2 dcl 3-9 set ref 528* 530* 758 1036* prnter_$general_abort 000054 constant entry external dcl 159 ref 1399 prnter_$macro_error 000052 constant entry external dcl 158 ref 534 730 1051 prntf 1 000100 external static fixed bin(17,0) level 2 dcl 3-9 set ref 611* 658* 720* 778* ptr builtin function dcl 36 ref 314 qsw 001640 automatic bit(1) packed unaligned dcl 928 set ref 931* 933 935 range_ob_charpos 001576 automatic fixed bin(21,0) dcl 752 set ref 910* 988* 989 994 release_temp_segments_ 000032 constant entry external dcl 151 ref 190 s 001655 automatic fixed bin(17,0) dcl 948 set ref 963* 965 968 973 973 973 973 973 973 save_charx 000305 automatic fixed bin(21,0) dcl 198 set ref 696* 702 save_charx1 000306 automatic fixed bin(21,0) dcl 198 set ref 699* 706 save_curlev 000304 automatic fixed bin(17,0) dcl 198 set ref 700* 704 save_free 000270 automatic fixed bin(21,0) dcl 198 set ref 403* 414 415 817* 841 846 save_obl 001722 automatic fixed bin(21,0) dcl 1123 set ref 1153* 1155 save_obp 001720 automatic pointer dcl 1123 set ref 1152* 1156 save_segx 000302 automatic fixed bin(17,0) dcl 198 set ref 695* 696 701 702 save_segx1 000303 automatic fixed bin(17,0) dcl 198 set ref 698* 699 705 segarray 554 based pointer initial array level 2 dcl 125 set ref 176* 180 190* 314 1196 1198* 1200 segarray_free 600 based fixed bin(21,0) initial array level 2 dcl 125 set ref 176* 278 696 699 702* 1086 1087* 1087 1103* 1105 1200* 1201 segarray_of_one 000252 automatic pointer array dcl 146 set ref 1197* 1198 segarray_of_two based pointer array dcl 147 set ref 180* segx 001744 automatic fixed bin(17,0) dcl 1183 in procedure "make_new_outbuf" set ref 1192* 1195 1195* 1196 1198 1200 1200 1201 segx 410 based fixed bin(13,0) array level 3 in structure "bct" packed packed unaligned dcl 125 in procedure "mexp_$ignore" set ref 277* 705* 1085* 1102 select_answer 001577 automatic fixed bin(17,0) dcl 753 set ref 885* 888 889 954* 960* 966* 967* 968* 968 973* 976* selector_eno 001570 automatic fixed bin(17,0) dcl 748 set ref 880* 954 963 selector_ob_charpos 001575 automatic fixed bin(21,0) dcl 752 set ref 879* 951* 952 980 semict 000272 automatic fixed bin(17,0) dcl 198 set ref 564* 618 722 774 1241* 1241 1314* 1314 1315* 1315 sfap based pointer initial level 2 in structure "bct" dcl 125 in procedure "mexp_$ignore" set ref 176* 177* 191 sfap 000246 automatic pointer dcl 121 in procedure "mexp_$ignore" set ref 175* 176 177 191* 192 si 000264 automatic fixed bin(21,0) dcl 198 set ref 348* 353* 491 size 1 parameter fixed bin(21,0) array level 2 dcl 1214 set ref 1225* 1267* 1278* sourcelen 002027 automatic fixed bin(21,0) dcl 1384 in procedure "get_ptrs" set ref 1386* 1388 sourcelen 2 based fixed bin(21,0) level 2 in structure "macro" dcl 244 in procedure "mexp_$ignore" set ref 445* 1043 1045 sourcep 3 based pointer level 2 packed packed unaligned dcl 244 set ref 318* 756 1043 1045 start parameter fixed bin(21,0) array level 2 in structure "aaray" dcl 923 in procedure "output_fargs" set ref 934* 934* start based fixed bin(21,0) array level 2 in structure "iterargs" dcl 236 in procedure "mexp_$ignore" set ref 812* 812* start 001541 automatic fixed bin(21,0) dcl 302 in procedure "define_macro" set ref 331* 332 333 340 345 start 000257 automatic fixed bin(21,0) dcl 198 in procedure "mexp_$ignore" set ref 571 677* 677* 677 684* 684* 684 1238* 1243 1243 1245 1301* 1305 1390* start 000344 automatic fixed bin(21,0) array level 2 in structure "ifargs" dcl 234 in procedure "mexp_$ignore" set ref 626 666 start 001166 automatic fixed bin(21,0) array level 2 in structure "args" dcl 240 in procedure "mexp_$ignore" set ref 725* 725* 794* 794* 833* startchar 1 based fixed bin(21,0) level 2 dcl 244 set ref 320* 1042 1043 1045 stop 000260 automatic fixed bin(21,0) dcl 198 set ref 285 285 580 609 616 675 677 684 1237* 1237 1240 1242 1243 1244 1248 1301 1305* 1306 1308* 1311* 1311 1312 1313 1314 1315 1318* 1318 1345 1358 1360 1389* 1390 str parameter char packed unaligned dcl 1125 set ref 1134 1136 1137 substr builtin function dcl 36 set ref 332 347 356 369 373 373* 424 491 525 526 574 606 609 626 666 686 807 807 966 966 1008 1043 1045 1081 1159* 1230 1243 1254 1257 1258 1272 1306 1312 1313 1314 1315 1328 1328 1328 1328 1332 1333* 1345 1358 1364 sys_info$max_seg_size 000024 external static fixed bin(35,0) dcl 36 ref 1201 system_free_area based area(1024) dcl 148 ref 176 192 system_type_ 000072 constant entry external dcl 198 ref 655 t 000273 automatic fixed bin(21,0) dcl 198 set ref 332* 333 333 338 357* 358 1243* 1244 1245 1272* 1273 1274 1306* 1307 1311 1345* 1346 1358* 1359 1363 t1 001656 automatic fixed bin(17,0) dcl 948 set ref 971* 973 973 973 973 973 973 t2 001657 automatic fixed bin(17,0) dcl 948 set ref 972* 973 973 973 973 973 973 targ 000114 automatic varying char(128) dcl 36 set ref 626* 632 637 654 666 target_value parameter fixed bin(17,0) dcl 549 set ref 548 647* 661 tcode 001571 automatic fixed bin(35,0) dcl 749 set ref 771* 772* 777 833* 834 temp_al 000242 automatic fixed bin(21,0) dcl 36 set ref 631* 632 725* 730 730 730 860* 861* temp_ap 000240 automatic pointer dcl 36 set ref 630* 632 725* 730 730 859* 861* tp 000342 automatic pointer dcl 198 set ref 285 451 574 609 626 666 677 677 684 684 686 725 725 794 794 812 812 934 934 1230 1243 1254 1257 1258 1272 1306 1312 1313 1314 1315 1345 1358 1364 1386* tpass1 61 000070 external static fixed bin(26,0) level 2 dcl 2-7 ref 645 656 type 000274 automatic fixed bin(17,0) dcl 198 in procedure "mexp_$ignore" set ref 350* 351 352* 365 368 375* 377 388 396 402 409 417 417 420 423 423 431 435 790* 791 791 793 type 15 based fixed bin(17,0) array level 3 in structure "macro" dcl 244 in procedure "mexp_$ignore" set ref 435* 465* 790 954 type_CLOSE constant fixed bin(17,0) initial dcl 92 ref 409 type_COMMAND_ARG constant fixed bin(17,0) initial dcl 95 ref 417 type_COMPARE constant fixed bin(17,0) initial dcl 100 ref 368 375 type_ELSE constant fixed bin(17,0) initial dcl 103 ref 396 type_ENDCOND constant fixed bin(17,0) initial dcl 102 ref 388 type_FARGS_ITER constant fixed bin(17,0) initial dcl 106 ref 423 431 type_FARGS_MACRO constant fixed bin(17,0) initial dcl 105 ref 423 type_ITERATE constant fixed bin(17,0) initial dcl 90 ref 365 type_LENGTH constant fixed bin(17,0) initial dcl 96 ref 417 type_MAXTYPE constant fixed bin(17,0) initial dcl 108 ref 791 type_NORMAL constant fixed bin(17,0) initial dcl 86 ref 351 352 type_NULL constant fixed bin(17,0) initial dcl 99 ref 420 465 type_OPEN constant fixed bin(17,0) initial dcl 91 ref 402 type_SELECT constant fixed bin(17,0) initial dcl 104 ref 954 type_STARTCOND constant fixed bin(17,0) initial dcl 101 ref 377 unique_changed 614 based bit(1) initial level 2 dcl 125 set ref 176* 764 766* 854* unique_generator 612 based fixed bin(17,0) initial level 2 dcl 125 set ref 176* 799 802* 802 804 809 unique_generator1 613 based fixed bin(17,0) initial level 2 dcl 125 set ref 176* 765* 765 851 unspec builtin function dcl 36 set ref 494 1013 1328* 1328 1328 1328 1328 v1 parameter fixed bin(17,0) dcl 986 set ref 984 992* v2 parameter fixed bin(17,0) dcl 986 set ref 984 993* val 000271 automatic fixed bin(17,0) dcl 198 set ref 789* 794 794 794 794 830 856 856 859 860 864 value_1 16 based fixed bin(13,0) array level 3 packed packed unaligned dcl 244 set ref 354* 361 374* 390* 391* 398* 404* 414* 417* 430* 789 889 890 895 898 932 963 value_2 17 based fixed bin(13,0) array level 3 packed packed unaligned dcl 244 set ref 415* 427* 429* 841 931 var_end 000312 automatic fixed bin(21,0) dcl 198 set ref 579* 580* 580 617 718 771 var_start 000311 automatic fixed bin(21,0) dcl 198 set ref 567* 577* 607 617* 617 718 718* 718 720 771 771* 771 vc 000104 automatic varying char(12) dcl 36 set ref 806* 807 807 vs 000102 automatic varying char(200) dcl 1030 set ref 1050* 1051 1051 zzzzz9 000166 automatic picture(6) packed unaligned dcl 1033 set ref 1049* 1050 zzzzzzz9 001724 automatic picture(8) packed unaligned dcl 1127 set ref 1142* 1143 1144 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ADP_SYSTEM internal static fixed bin(17,0) initial dcl 1-4 HERE_FOR_DOCU1 internal static char(22) initial packed unaligned dcl 80 HERE_FOR_DOCU2 internal static char(22) initial packed unaligned dcl 81 SYSTEM_TYPE_NAME internal static char(8) initial array packed unaligned dcl 1-6 cu_$arg_ptr_rel 000000 constant entry external dcl 36 eb_data_$erflgs external static structure level 1 dcl 3-5 parameter automatic fixed bin(17,0) dcl 549 type_ITER_INDEX internal static fixed bin(17,0) initial dcl 93 type_NARGS internal static fixed bin(17,0) initial dcl 97 type_NEXT_UNIQUE internal static fixed bin(17,0) initial dcl 89 type_NITER internal static fixed bin(17,0) initial dcl 98 type_PREV_UNIQUE internal static fixed bin(17,0) initial dcl 87 type_RANGECTL internal static fixed bin(17,0) initial dcl 107 type_SPEC_UNIQUE internal static fixed bin(17,0) initial dcl 94 type_UNIQUE internal static fixed bin(17,0) initial dcl 88 NAMES DECLARED BY EXPLICIT CONTEXT. A 005324 constant label dcl 912 ref 797 808 816 843 850 863 866 869 872 873 881 892 893 899 902 905 911 ANY_ARGS_Q 005051 constant label dcl 841 ref 847 BAD_PSEUDO 001376 constant label dcl 611 ref 607 622 FIN_MACRO 003526 constant label dcl 441 ref 335 356 GET_ANOTHER_ARG 007133 constant label dcl 1230 ref 1251 1280 NEXT_ARG 007370 constant label dcl 1279 ref 1268 UNIQUE 004627 constant label dcl 805 ref 801 811 UNIQUE1 004634 constant label dcl 806 ref 855 XP 000000 constant label array(22) dcl 794 ref 793 collect_ob_num 006000 constant entry internal dcl 999 ref 954 971 972 992 993 compare_op 002764 constant label dcl 369 ref 358 deferr 004016 constant entry internal dcl 506 ref 334 441 443 497 deferr_g 004027 constant entry internal dcl 515 ref 359 361 365 371 378 389 397 405 411 412 431 deferr_nlexit 003515 constant label dcl 435 ref 537 define_macro 002435 constant entry internal dcl 289 ref 285 expand_macro 004344 constant entry internal dcl 742 ref 591 experr 006070 constant entry internal dcl 1021 ref 834 875 884 906 959 1010 genabort 007656 constant entry internal dcl 1396 ref 433 791 1078 1099 get_hashx 007476 constant entry internal dcl 1323 ref 283 586 get_numeric_value 003673 constant entry internal dcl 476 ref 404 417 430 get_numeric_value_could_be_0 003706 constant entry internal dcl 482 ref 354 478 get_ob_rangeargs 005666 constant entry internal dcl 984 ref 822 get_ptrs 007626 constant entry internal dcl 1375 ref 281 450 454 566 icerr 003325 constant label dcl 412 ref 394 400 make_new_outbuf 006770 constant entry internal dcl 1174 ref 590 608 make_new_outbuf$force 006773 constant entry internal dcl 1189 ref 1154 mexp_$cleanup 000766 constant entry external dcl 183 mexp_$define_macro 001041 constant entry external dcl 264 mexp_$ignore 000635 constant entry external dcl 23 mexp_$init 000646 constant entry external dcl 170 mexp_$mexp_ 001163 constant entry external dcl 548 mexp_$reset_macro 002422 constant entry external dcl 1059 mnob_join 006776 constant label dcl 1192 ref 1187 more 007555 constant label dcl 1358 in procedure "soc" ref 1369 more 007407 constant label dcl 1306 in procedure "skip_to_next_line" ref 1319 ouch 006632 constant entry internal dcl 1134 ref 805 807 853 933 935 936 1081 outnum 006651 constant entry internal dcl 1140 ref 848 864 867 870 outpr_join 006706 constant label dcl 1148 ref 1132 1138 outptr 006622 constant entry internal dcl 1119 ref 676 677 683 684 787 794 812 861 934 output_fargs 005327 constant entry internal dcl 918 ref 900 903 pop_mexp_level 006555 constant entry internal dcl 1092 ref 1066 pull_apart_select_input 005443 constant entry internal dcl 942 ref 887 push_mexp_output_upon_alm 006455 constant entry internal dcl 1070 ref 592 703 710 r 003753 constant label dcl 496 ref 492 scan_args 007105 constant entry internal dcl 1207 ref 617 718 771 833 skip_to_next_line 007401 constant entry internal dcl 1289 ref 569 674 678 1234 sob 007532 constant entry internal dcl 1340 ref 572 soc 007553 constant entry internal dcl 1350 ref 578 1247 substaddr 006747 constant entry internal dcl 1168 ref 677 677 684 684 725 725 787 787 794 794 812 812 934 934 951 988 1200 NAMES DECLARED BY CONTEXT OR IMPLICATION. bin builtin function ref 494 bool builtin function ref 1328 1328 1328 fixed builtin function ref 472 1013 hbound builtin function ref 378 378 378 496 497 497 1078 ltrim builtin function ref 1050 1143 1144 max builtin function ref 478 min builtin function ref 827 rel builtin function ref 472 rtrim builtin function ref 534 1050 search builtin function ref 525 1306 1358 verify builtin function ref 1243 1345 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 11740 12042 11231 11750 Length 12370 11231 102 312 507 2 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mexp_$ignore 1406 external procedure is an external procedure. define_macro internal procedure shares stack frame of external procedure mexp_$ignore. get_numeric_value internal procedure shares stack frame of external procedure mexp_$ignore. get_numeric_value_could_be_0 internal procedure shares stack frame of external procedure mexp_$ignore. deferr 116 internal procedure is declared options(non_quick), and is declared options(variable). expand_macro internal procedure shares stack frame of external procedure mexp_$ignore. output_fargs internal procedure shares stack frame of external procedure mexp_$ignore. pull_apart_select_input internal procedure shares stack frame of external procedure mexp_$ignore. collect_ob_num internal procedure shares stack frame of external procedure mexp_$ignore. experr 164 internal procedure is declared options(non_quick), and is declared options(variable). push_mexp_output_upon_alm internal procedure shares stack frame of external procedure mexp_$ignore. pop_mexp_level internal procedure shares stack frame of external procedure mexp_$ignore. outptr internal procedure shares stack frame of external procedure mexp_$ignore. substaddr internal procedure shares stack frame of external procedure mexp_$ignore. make_new_outbuf internal procedure shares stack frame of external procedure mexp_$ignore. scan_args internal procedure shares stack frame of external procedure mexp_$ignore. skip_to_next_line internal procedure shares stack frame of external procedure mexp_$ignore. get_hashx internal procedure shares stack frame of external procedure mexp_$ignore. sob internal procedure shares stack frame of external procedure mexp_$ignore. soc internal procedure shares stack frame of external procedure mexp_$ignore. get_ptrs internal procedure shares stack frame of external procedure mexp_$ignore. genabort 104 internal procedure is declared options(non_quick), and is declared options(variable). STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 QUOTE mexp_$ignore STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME deferr 000100 jx deferr 000101 cha deferr 000102 gsw deferr experr 000100 apos experr 000101 alct experr 000102 vs experr 000165 nlx experr 000166 zzzzz9 experr 000170 errpos experr mexp_$ignore 000100 next mexp_$ignore 000101 code mexp_$ignore 000102 entry_no mexp_$ignore 000103 discard mexp_$ignore 000104 vc mexp_$ignore 000110 c mexp_$ignore 000111 no_exargs mexp_$ignore 000112 no_ifargs mexp_$ignore 000113 alm_finished_the_line mexp_$ignore 000114 targ mexp_$ignore 000155 cbuf1 mexp_$ignore 000237 cb1l mexp_$ignore 000240 temp_ap mexp_$ignore 000242 temp_al mexp_$ignore 000243 max_char_count mexp_$ignore 000244 envp mexp_$ignore 000246 sfap mexp_$ignore 000250 hashx mexp_$ignore 000252 segarray_of_one mexp_$ignore 000254 nparens mexp_$ignore 000255 i mexp_$ignore 000256 ci mexp_$ignore 000257 start mexp_$ignore 000260 stop mexp_$ignore 000261 j mexp_$ignore 000262 iterate mexp_$ignore 000263 found_number mexp_$ignore 000264 si mexp_$ignore 000266 mbptr mexp_$ignore 000270 save_free mexp_$ignore 000271 val mexp_$ignore 000272 semict mexp_$ignore 000273 t mexp_$ignore 000274 type mexp_$ignore 000275 nargs mexp_$ignore 000276 nchars mexp_$ignore 000277 ia mexp_$ignore 000300 macro_len mexp_$ignore 000301 end_index mexp_$ignore 000302 save_segx mexp_$ignore 000303 save_segx1 mexp_$ignore 000304 save_curlev mexp_$ignore 000305 save_charx mexp_$ignore 000306 save_charx1 mexp_$ignore 000307 match mexp_$ignore 000310 iftarget_cond mexp_$ignore 000311 var_start mexp_$ignore 000312 var_end mexp_$ignore 000313 opcode mexp_$ignore 000323 iftarget_str mexp_$ignore 000332 iftarget_error mexp_$ignore 000333 iftarget_value mexp_$ignore 000334 iterate_arg_no mexp_$ignore 000336 obp mexp_$ignore 000340 mp mexp_$ignore 000342 tp mexp_$ignore 000344 ifargs mexp_$ignore 000654 iap mexp_$ignore 000656 exargs mexp_$ignore 001166 args mexp_$ignore 001514 mp define_macro 001516 cifin define_macro 001517 bad_macro define_macro 001520 almpos define_macro 001521 lasteralmpos define_macro 001522 condthread define_macro 001523 condstack define_macro 001535 ciprev define_macro 001536 condlevel define_macro 001537 itercondlevel define_macro 001540 c2 define_macro 001541 start define_macro 001542 in_iteration define_macro 001560 c get_numeric_value_could_be_0 001570 selector_eno expand_macro 001571 tcode expand_macro 001572 arg_offset expand_macro 001573 outstanding_select expand_macro 001574 outstanding_range expand_macro 001575 selector_ob_charpos expand_macro 001576 range_ob_charpos expand_macro 001577 select_answer expand_macro 001600 found_d_error_lying_there expand_macro 001640 qsw output_fargs 001641 k output_fargs 001652 ep pull_apart_select_input 001654 elen pull_apart_select_input 001655 s pull_apart_select_input 001656 t1 pull_apart_select_input 001657 t2 pull_apart_select_input 001660 comx pull_apart_select_input 001670 i collect_ob_num 001671 d collect_ob_num 001672 c collect_ob_num 001716 outp outptr 001720 save_obp outptr 001722 save_obl outptr 001723 outl outptr 001724 zzzzzzz9 outptr 001726 cbuf outptr 001744 segx make_new_outbuf 001745 force make_new_outbuf 001754 c2 scan_args 001755 arg_start scan_args 001756 last scan_args 001770 nparens skip_to_next_line 002000 fb35 get_hashx 002016 nparens soc 002026 offset get_ptrs 002027 sourcelen get_ptrs THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. fx1_to_fl2 r_g_a r_e_as r_ne_as alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this_desc return_mac fl2_to_fx1 tra_ext_1 mdfx1 shorten_stack ext_entry ext_entry_desc int_entry trunc_fx2 set_chars_eis index_chars_eis divide_fx1 op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. alm_include_file_$macro alm_include_file_$pop com_err_ convert_binary_integer_$octal_string cu_$arg_list_ptr cv_dec_check_ get_system_free_area_ get_temp_segments_ inputs_$get_ptr inputs_$next_statement inputs_$next_statement_nolist inputs_$run_statement inputs_$run_statement_nolist ioa_$general_rs prnter_$general_abort prnter_$macro_error release_temp_segments_ system_type_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. eb_data_$alm_arg_count eb_data_$alm_arg_ptr eb_data_$erflgs_overlay eb_data_$macro_linect eb_data_$mexp_argno eb_data_$mexp_env_ptr eb_data_$varcom eb_data_$who_am_I error_table_$noarg sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 23 000634 24 000642 170 000643 175 000653 176 000662 177 000736 178 000740 179 000742 180 000743 181 000764 183 000765 188 000773 189 000777 190 001003 191 001025 192 001030 193 001032 194 001035 264 001036 271 001054 273 001060 277 001071 278 001100 279 001105 281 001107 283 001110 285 001120 286 001155 548 001156 561 001176 562 001204 563 001205 564 001211 566 001212 567 001213 568 001215 569 001220 571 001221 572 001223 574 001224 576 001232 577 001243 578 001245 579 001246 580 001251 586 001256 588 001260 589 001272 590 001277 591 001300 592 001301 593 001302 595 001303 601 001306 606 001346 607 001353 608 001355 609 001356 610 001375 611 001376 612 001402 614 001403 615 001414 616 001421 617 001424 618 001432 619 001441 620 001452 621 001457 622 001461 626 001463 627 001475 628 001505 629 001506 630 001521 631 001527 632 001533 633 001542 634 001544 635 001553 636 001554 637 001564 638 001615 639 001621 640 001627 641 001630 643 001640 645 001646 647 001656 648 001660 650 001665 651 001711 654 001716 655 001726 656 001763 658 001773 659 001776 661 002000 662 002005 664 002013 666 002014 667 002026 668 002027 674 002036 675 002037 676 002043 677 002056 678 002113 679 002114 680 002121 681 002122 682 002127 683 002131 684 002140 686 002171 695 002204 696 002206 697 002210 698 002215 699 002220 700 002222 701 002224 702 002226 703 002231 704 002232 705 002236 706 002244 708 002250 710 002251 711 002252 717 002253 718 002257 719 002270 720 002271 721 002301 722 002306 723 002315 724 002322 725 002324 725 002351 730 002356 731 002413 737 002415 738 002420 1059 002421 1065 002427 1066 002433 1067 002434 289 002435 306 002446 307 002447 308 002450 309 002452 310 002453 312 002456 314 002461 315 002466 317 002473 318 002476 320 002477 321 002502 322 002504 327 002507 331 002512 332 002515 333 002534 334 002542 335 002554 338 002555 340 002557 345 002567 347 002574 348 002601 350 002603 351 002614 352 002617 353 002621 354 002623 355 002637 356 002641 357 002647 358 002660 359 002661 361 002700 362 002724 363 002726 364 002727 365 002741 367 002761 368 002762 369 002764 370 002772 371 003003 373 003032 374 003041 375 003066 376 003070 377 003071 378 003073 380 003117 385 003120 386 003123 387 003125 388 003126 389 003130 390 003145 391 003156 392 003164 393 003167 394 003171 395 003177 396 003200 397 003202 398 003217 399 003230 400 003232 401 003237 402 003240 403 003242 404 003244 405 003257 406 003274 407 003276 408 003300 409 003301 410 003303 411 003305 412 003322 414 003340 415 003351 416 003361 417 003362 420 003403 423 003415 424 003421 425 003425 426 003433 427 003434 428 003440 429 003441 430 003445 431 003461 432 003501 433 003502 435 003515 436 003523 438 003524 441 003526 443 003546 444 003563 445 003566 450 003573 451 003574 452 003604 453 003611 454 003613 455 003614 456 003615 458 003617 460 003636 461 003640 462 003642 465 003646 466 003653 467 003657 471 003664 472 003666 473 003672 476 003673 478 003675 482 003706 488 003710 489 003711 490 003712 491 003723 492 003731 493 003737 494 003741 495 003751 496 003753 497 003756 498 004003 500 004004 519 004011 506 004015 513 004024 515 004025 521 004035 525 004112 526 004134 526 004140 527 004145 528 004154 529 004160 530 004167 532 004172 533 004175 534 004177 537 004320 538 004326 540 004327 541 004337 542 004342 544 004343 742 004344 756 004345 757 004350 758 004352 762 004357 764 004363 765 004366 766 004367 771 004370 772 004401 774 004415 775 004425 776 004432 777 004434 778 004436 779 004442 781 004443 782 004444 786 004445 787 004457 789 004522 790 004531 791 004533 793 004552 794 004554 797 004616 799 004617 801 004622 802 004623 804 004625 805 004627 806 004634 807 004652 808 004661 809 004662 811 004666 812 004667 816 004731 817 004732 819 004734 820 004736 821 004740 822 004742 823 004744 824 004750 825 004755 826 004764 827 004766 828 004774 830 004775 831 004777 832 005002 833 005003 834 005023 836 005044 837 005045 838 005046 839 005050 841 005051 843 005062 844 005063 846 005064 847 005066 848 005067 850 005073 851 005074 853 005077 854 005104 855 005107 856 005110 859 005121 860 005127 861 005133 863 005135 864 005136 866 005146 867 005147 869 005153 870 005154 872 005160 873 005161 875 005162 878 005202 879 005204 880 005206 881 005210 882 005211 884 005213 885 005226 886 005230 887 005231 888 005232 889 005237 890 005252 891 005253 892 005255 893 005256 895 005257 898 005271 899 005273 900 005274 902 005276 903 005277 905 005301 906 005302 909 005317 910 005321 911 005323 912 005324 915 005326 918 005327 931 005331 932 005342 933 005353 934 005362 935 005420 936 005427 937 005440 938 005442 942 005443 951 005444 952 005467 954 005474 957 005510 958 005523 959 005524 960 005537 961 005540 963 005541 965 005545 966 005547 967 005565 968 005567 969 005574 971 005575 972 005604 973 005611 976 005660 980 005662 981 005664 982 005665 984 005666 988 005670 989 005713 990 005720 991 005732 992 005736 993 005756 994 005774 995 005776 996 005777 999 006000 1005 006002 1007 006003 1008 006013 1009 006025 1010 006033 1011 006046 1013 006051 1014 006061 1015 006063 1021 006067 1036 006075 1039 006103 1041 006157 1042 006175 1043 006177 1044 006220 1045 006227 1046 006253 1047 006254 1049 006256 1050 006266 1051 006403 1053 006453 1070 006455 1078 006456 1080 006501 1081 006505 1083 006516 1084 006534 1085 006536 1086 006544 1087 006551 1088 006554 1092 006555 1099 006556 1102 006574 1103 006601 1104 006607 1105 006611 1107 006621 1119 006622 1130 006624 1131 006626 1132 006631 1134 006632 1136 006643 1137 006645 1138 006650 1140 006651 1142 006653 1143 006664 1144 006676 1145 006704 1148 006706 1151 006711 1152 006717 1153 006721 1154 006724 1155 006725 1156 006730 1159 006736 1160 006745 1162 006746 1168 006747 1171 006760 1174 006770 1186 006771 1187 006772 1189 006773 1191 006774 1192 006776 1195 007001 1196 007006 1197 007014 1198 007036 1200 007042 1201 007070 1202 007102 1204 007104 1207 007105 1225 007107 1226 007123 1227 007124 1228 007127 1229 007132 1230 007133 1232 007141 1234 007154 1237 007167 1238 007171 1240 007174 1241 007200 1242 007201 1243 007204 1244 007221 1245 007226 1246 007230 1247 007231 1248 007232 1249 007242 1250 007245 1251 007247 1254 007250 1255 007255 1256 007257 1257 007267 1258 007301 1259 007305 1260 007307 1261 007311 1262 007314 1265 007315 1266 007317 1267 007325 1268 007332 1272 007333 1273 007347 1274 007354 1276 007355 1277 007357 1278 007364 1279 007370 1280 007374 1282 007400 1289 007401 1301 007402 1304 007405 1305 007406 1306 007407 1307 007427 1308 007430 1309 007433 1311 007434 1312 007435 1313 007446 1314 007453 1315 007464 1317 007473 1318 007474 1319 007475 1323 007476 1328 007500 1331 007506 1332 007515 1333 007522 1334 007525 1336 007531 1340 007532 1345 007533 1346 007551 1347 007552 1350 007553 1357 007554 1358 007555 1359 007573 1360 007574 1361 007577 1363 007600 1364 007601 1365 007606 1366 007614 1367 007621 1368 007624 1369 007625 1375 007626 1386 007627 1388 007644 1389 007647 1390 007651 1391 007654 1396 007655 1398 007663 1399 007737 1400 007754 ----------------------------------------------------------- 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