COMPILATION LISTING OF SEGMENT expevl_ Compiled by: Multics PL/I Compiler, Release 31a, of October 12, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 10/17/88 1008.1 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 expevl_: 14 proc (tbool, inexp, lc, expevl_answer) ; 15 16 /* 17* Modified 740821 by PG to allow stack-references wherever references are allowed. 18* Modified on 12/07/72 at 20:29:45 by R F Mabee. Fixed up prntr problem for good. 19* Modified by RHG on 17 August 1970 at 1614 to clean up some bad code 20* by RHG on 11 August 1970 at 0537 to get rid of return value (make it a parameter) 21* by RHG on 10 August 1970 at 2139 to allow "^" as substitute for "/" in bool expressions 22* by RHG on 10 August 1970 at 2032 to eliminate calls to prec_ and utils_$(and or xor) 23* by Nate Adleman on June 28, 1970 at 2006 for the new CODTAB 24**/ 25 26 /* EXPEVL: evaluate internal expressions for MA */ 27 28 /* internal expression evaluation routine. this routine evaluates */ 29 /* expressions consisting entirely of internal references using a */ 30 /* stack technique. nested expressions are allowed as normal */ 31 /* subexpressions, and evaluation is done on either an arithmetic */ 32 /* or boolean operator interpretation. the stack is an internal */ 33 /* array of nstk( = 100) locations, sufficient for most expressions. */ 34 35 /* modifications by wagner for multiple location counters, */ 36 /* june 13, 1967. returns in lc the address of the assignment */ 37 /* table entry for the location counter to which inexp is relative. */ 38 /* if call has tbool = 1; (TRUE) then caller must ignore lc. */ 39 40 /* a second stack, lstk, runs parallel to stk. lstk(i) is-- */ 41 42 /* lc if stk(i) is relative to a location counter. */ 43 /* 0 if stk(i) is absolute. */ 44 /* garbage if stk(i) is an operator. */ 45 46 /* then at each arithmetic operator there must be a check */ 47 /* that operands are of consistent types. */ 48 49 50 51 /* INCLUDE FILES USED BY EXPEVL */ 52 1 1 /* Begin include file varcom.incl.pl1. */ 1 2 /* RHG added new variables 9/7/70. */ 1 3 /* RFM added new cells for new object segment format and first-reference trap, 27 March 1972. */ 1 4 /* RFM added include file stuff, then cross referencer stuff, 23 July 1972. */ 1 5 /* Last modified on 07/23/72 at 04:19:25 by R F Mabee. */ 1 6 1 7 declare 1 eb_data_$varcom external aligned, 1 8 2 (brk(2), nbrk(2), sym(8), dsym(8),old_locsym, pc, spc, tpc, 1 9 pclst, p2pcl, old_ndpcls, tvorg, tvcnt, tvlth, litorg, 1 10 litc, deforg, defc, defcnt, stkc, lnkc, lnkno, 1 11 litlst, old_ndltls, lnklst, old_ndlkls, explst, blklst, namlst, 1 12 trplst, xdflst, tvlst, begin_line, tpass1, tpass2, tpostp, 1 13 tinhib, tmmode, txonly, tmm2, txo2, tprot, tcall, 1 14 tmvdef, tpulnk, tfatal, calrho, lreter, passwd, binlin, 1 15 nboxes, box(0:210), myfil, mynam, myblk, mylnk, tpost1 ) fixed bin (26) , 1 16 2 source_printed bit(1) aligned, 1 17 2 (ndpcls, ndltls, ndlkls, ndtvls) ptr, 1 18 2 (basno, value, admod, b29, iaddr, symlnk ) fixed bin (26), 1 19 2 (itxtmod, ilnkmod, entrieslc, include_file_list, include_index, 1 20 first_ref_trap_proc_linkno, first_ref_trap_arg_linkno, 1 21 text_section_length) fixed binary (26), 1 22 2 (include_info_stack, include_name_list_base, include_name_list_top) pointer, 1 23 2 symbol_tree_rel fixed binary (26); 1 24 1 25 /* End of the include file varcom.incl.pl1. */ 53 2 1 2 2 2 3 2 4 /* include file for CONCOM */ 2 5 2 6 declare 1 eb_data_$concom ext aligned, 2 7 2 (ap, ab, bp, bb, lp, lb, sp, sb, 2 8 clunk, clint, clext, clbas, clstk, clndx, clmlc, fdef, 2 9 fmul, fphs, fset, frel, fabs, fbol, fcom, find, 2 10 flocrf, fequrf, fbolrf, fsetrf, fbasrf, fsegrf, fstkrf, fndxrf, 2 11 fmlcrf, onesev, twosev, thrsev, forsev, fivsev, sixsev, allsev, 2 12 symbas(8),mir, mri, mdu, mdl, mx0, mx1, mpc, 2 13 mpci, mfi, mits, mitb, ixtern, intern, iassgn, iserch, 2 14 ixvrvl, ixvrvp, invrvl, invrvp, ibvrvl, ibvrvp, iaccvl, iacivl, 2 15 mcmpq, mcmpx0, mldaq, mldq, mldx0, mnopdu, mstcd, mtra, 2 16 mtnc, mtnz, meabsp, meapap, meapbp, meaplp, meapsp, mstpap, 2 17 mstpbp, mstplp, mstpsp, i1542, i642, i3333, i66, ibb, 2 18 ibsp, nullf, smxer(2), sentry(2),sretrn(2), dzero(2) ) fixed bin (26) aligned ; 2 19 2 20 /* end of the include file for CONCOM */ 54 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 55 4 1 4 2 4 3 4 4 /* include file for CODTAB */ 4 5 4 6 declare 1 eb_data_$codtab ext aligned, 4 7 2 ( inul, isoh, istx, ietx, ieot, ienq, iack, ibel, 4 8 ibs, iht, inl, ivt, iff, icr, irrs, ibrs, 4 9 idle, irht, ihlf, irvt, ihlr, inak, isyn, ietb, 4 10 ican, iem, iss, iesc, ifs, igs, irs, ius, 4 11 isp, ixclm, iquot, ilb, idolr, ipcnt, iampr, iapos, 4 12 ilpar, irpar, istar, iplus, icomma, iminus, ipoint, islash, 4 13 inum, inum_pad(9), icol, isc, ilpb, iequal, irpb, iques, iat, 4 14 ilet, ilet_pad(25), ilsb, irslsh, irsb, icflx, iulin, igrv, illet,illet_pad(25), 4 15 ilbrc, ivlin, irbrc, itldf, idel ) fixed bin (17) ; 4 16 /* NA on June 26, 1970 at 1344 for padded arrays */ 56 5 1 5 2 5 3 5 4 /* the include file CURLC */ 5 5 5 6 declare 1 eb_data_$curlc ext aligned, 5 7 2 curlc fixed bin (17) aligned ; 5 8 5 9 5 10 5 11 /* end of the include file CURLC */ 57 58 /* */ 59 /* EXTERNAL ENTRIES USED BY EXPEVL */ 60 61 declare getid_$getid_ external entry, 62 inputs_$next external entry ; 63 64 /* EXTERNAL FUNCTIONS USED BY EXPEVL */ 65 66 declare glpl_$clh external entry (fixed bin) returns (fixed bin), 67 glpl_$crh external entry (fixed bin) returns (fixed bin), 68 table_$table_ external entry (fixed bin (26), fixed bin (26), fixed bin, fixed bin (26), fixed bin) returns (fixed bin (26)); 69 70 71 /* EXTERNAL DATA USED BY EXPEVL */ 72 73 declare (eb_data_$ilend, eb_data_$ineg, eb_data_$inot) ext fixed bin (35); 74 75 76 /* AUTOMATIC DATA USED BY EXPEVL */ 77 78 declare expevl_answer fixed bin (35) ; 79 80 81 declare (inexp, i, lc, l1, l2, lstk (100), op, rprec, 82 stk (100), tbad, tbool, val, vlc, radix, brk_temp) fixed bin (17); 83 84 declare nstk fixed bin internal static init (100); 85 86 /* */ 87 /* - - - - - NORMAL ENTRY, break in brk, and perhaps symbol in xsym. */ 88 89 label_100: 90 radix = 10 -tbool - tbool ; /* set the radix for numeric constants to 8 or 10 */ 91 expevl_answer = 1; /* TRUE */; 92 tbad = 0; /* FALSE */; 93 i = 1; 94 stk (1) = eb_data_$ilend; 95 go to label_210; 96 97 /* re-entry to get next identifier. */ 98 label_200: 99 call getid_$getid_; 100 label_210: 101 if (brk (1) = inum) then go to label_230; 102 if (sym (1) = 0) then go to label_300; 103 104 /* not number nor void, look up symbol in assignment table. */ 105 label_220: 106 if (table_$table_ (iserch, sym (1), val, clint, vlc) ^= 0) then go to label_400; 107 if (table_$table_ (iserch, sym (1), val, clmlc, vlc) ^= 0) then go to label_400; 108 if (table_$table_ (iserch, sym (1), val, clstk, vlc) ^= 0) then go to label_400; 109 label_225: 110 prntu = 1; /* TRUE */; 111 expevl_answer = 0; /* FALSE */; 112 go to label_400; 113 114 /* number, convert to binary. */ 115 label_230: 116 unspec (val) = unspec (brk (2)) & "000000000000000000000000000000001111"b; /* val = utils_$and( brk(2), 15) */ 117 vlc = 0; 118 label_240: 119 call inputs_$next; 120 if (brk (1) ^= inum) then go to label_400; 121 val = radix * val + fixed (unspec (brk (2)) & "000000000000000000000000000000001111"b, 17, 0) ; 122 go to label_240; 123 124 /* unary operator, check which and process. */ 125 label_300: 126 brk_temp = brk (1); /* set brk_temp which is not abnormal so pl1 can optimize */ 127 if (brk_temp = iplus) then go to label_310; 128 if (brk_temp = iminus) then go to label_320; 129 if (brk_temp = istar) then go to label_330; 130 if (brk_temp = islash) then go to label_340; 131 if (brk_temp = icflx) then go to label_340; 132 if (brk_temp = ilpar) then go to label_350; 133 go to label_360; 134 135 /* ignore unary plus. */ 136 label_310: 137 go to label_200; 138 139 /* replace unary minus by _$neg_$, put instack, and . */ 140 label_320: 141 i = i+1; 142 stk (i) = eb_data_$ineg; 143 go to label_200; 144 145 /* unary star is symbol for this location. */ 146 label_330: 147 val = pc; 148 vlc = curlc; 149 call getid_$getid_; 150 if (sym (1) ^= 0) then go to label_800; 151 go to label_400; 152 153 /* unary slash for booleans means not. */ 154 label_340: 155 i = i+1; 156 stk (i) = eb_data_$inot; 157 go to label_200; 158 159 /* simply insert ( and scan. */ 160 label_350: 161 i = i+1; 162 stk (i) = ilpar; 163 go to label_200; 164 165 /* unknown break, val is zero and treat as binary end. */ 166 label_360: 167 val = 0; 168 vlc = 0; 169 go to label_400; 170 171 172 /* binary operator, insert operand, and check precedence of */ 173 /* operator. if current precedence greater than last operator, */ 174 /* insert new operator in stack, otherwise, begin evaluating */ 175 /* operators up the stack. parentheses and end of field are */ 176 /* treated in special ways. */ 177 178 label_400: 179 if (i > (nstk-4)) then go to label_800; 180 i = i+1; 181 stk (i) = val; 182 lstk (i) = vlc; 183 label_410: 184 unspec (rprec) = unspec (brk (1)) & "000000000000000000000000000000001111"b; /* rprec = utils_$and(brk(1), 15); */ 185 label_420: 186 op = stk (i-1); 187 if fixed (unspec (op) & "000000000000000000000000000000001111"b, 17, 0) >= rprec then goto label_460; 188 if (brk (1) = irpar) then go to label_450; 189 if (rprec <= 4) then go to label_440; 190 191 /* precedence greater, insert operator in stack. */ 192 label_430: 193 i = i+1; 194 stk (i) = brk (1); 195 go to label_200; 196 197 /* end terminator, check results and return answer. */ 198 label_440: 199 if (i ^= 2) then go to label_800; 200 go to label_900; 201 202 /* right parenthesis processed only after ops evaluated. */ 203 label_450: 204 if (op = eb_data_$ilend) then go to label_440; 205 if (op ^= ilpar) then go to label_800; 206 i = i-1; 207 stk (i) = stk (i+1); 208 lstk (i) = lstk (i+1); 209 call getid_$getid_; 210 if (sym (1) ^= 0) then go to label_800; 211 go to label_410; 212 213 /* work operators up stack until precedence is in order. */ 214 /* seperate evaluators for boolean and arithmetic operators. */ 215 label_460: 216 if (tbool ^= 0) then go to label_600; 217 218 /* arithmetic operator, branch on type. */ 219 label_500: 220 l1 = lstk (i-2); 221 l2 = lstk (i); 222 if (op = iplus) then go to label_510; 223 if (op = iminus) then go to label_520; 224 if (op = istar) then go to label_530; 225 if (op = islash) then go to label_540; 226 if (op = eb_data_$ineg) then go to label_550; 227 if (op = eb_data_$ilend) then go to label_900; 228 go to label_800; 229 230 /* evaluate binary +. */ 231 label_510: 232 stk (i-2) = stk (i-2)+stk (i); 233 if (l1 ^= 0 & l2 ^= 0) then tbad = 1; /* TRUE */; 234 if (l1+l2 = 0) then vlc = 0; 235 if (l1 ^= 0) then vlc = l1; 236 if (l2 ^= 0) then vlc = l2; 237 go to label_700; 238 239 /* evaluate binary -. */ 240 241 /* special patch has been added to permit */ 242 /* the evaluation of a difference when the */ 243 /* symbols are both relocatable and in the */ 244 /* same segment but are defined under different */ 245 /* location counters. in this case the result */ 246 /* is modified by adding the difference between */ 247 /* the origins of the two location counters. */ 248 label_520: 249 stk (i-2) = stk (i-2)-stk (i); 250 if (^(tpass2 ^= 0 & l1 ^= 0 & l2 ^= 0)) then go to label_525; 251 if (glpl_$crh (l1+4) ^= glpl_$crh (l2+4)) then tbad = 1; /* TRUE */; 252 stk (i-2) = stk (i-2) + (glpl_$clh (l1+3)-glpl_$clh (l2+3)); 253 vlc = 0; 254 go to label_700; 255 label_525: 256 257 258 if (l2 ^= 0 & l1 ^= l2) then tbad = 1; /* TRUE */; 259 if (l1+l2 = 0) then vlc = 0; 260 if (l1 ^= 0 & l2 = 0) then vlc = l1; 261 if (l1 ^= 0 & l2 ^= 0) then vlc = 0; 262 go to label_700; 263 264 /* evaluate binary *. */ 265 label_530: 266 stk (i-2) = stk (i-2)*stk (i); 267 if (l1+l2 ^= 0) then tbad = 1; /* TRUE */; 268 vlc = 0; 269 go to label_700; 270 271 /* evaluate binary /. */ 272 label_540: 273 if (stk (i) ^= 0) then stk (i-2) = divide (stk (i-2), stk (i), 17, 0); 274 if (l1+l2 ^= 0) then tbad = 1; /* TRUE */; 275 vlc = 0; 276 go to label_700; 277 278 /* evaluate unary -. */ 279 label_550: 280 stk (i-1) = -stk (i); 281 if (lstk (i) ^= 0) then tbad = 1; /* TRUE */; 282 vlc = 0; 283 go to label_710; 284 285 286 /* boolean operator, branch on type. */ 287 label_600: 288 if (op = iplus) then go to label_610; 289 if (op = iminus) then go to label_620; 290 if (op = istar) then go to label_630; 291 if (op = islash) then go to label_640; 292 if (op = icflx) then go to label_640; 293 if (op = eb_data_$inot) then go to label_650; 294 if (op = eb_data_$ilend) then go to label_900; 295 go to label_800; 296 297 /* evaluate boolean .or. function. */ 298 label_610: 299 unspec (stk (i-2)) = unspec (stk (i-2)) | unspec (stk (i)) ; 300 go to label_700; 301 302 /* evaluate boolean .xor. function. */ 303 label_620: 304 unspec (stk (i-2)) = bool (unspec (stk (i-2)), unspec (stk (i)), "0110"b) ; 305 go to label_700; 306 307 /* evaluate boolean .and. function. */ 308 label_630: 309 unspec (stk (i-2)) = unspec (stk (i-2)) & unspec (stk (i)) ; 310 go to label_700; 311 312 /* evaluate boolean .and not. function. */ 313 label_640: 314 unspec (stk (i-2)) = unspec (stk (i-2)) & ^unspec (stk (i)) ; 315 go to label_700; 316 317 /* evaluate boolean .not. function. */ 318 label_650: 319 stk (i-1) = -1 - stk (i) ; 320 go to label_710; 321 322 323 /* termination for binary operator evaluation, reduce stack */ 324 /* level, and go test new operator. */ 325 label_700: 326 lstk (i-2) = vlc; 327 i = i-2; 328 if (i >= 2) then go to label_420; 329 go to label_800; 330 331 /* termination for unary operations in stack. */ 332 label_710: 333 lstk (i-1) = vlc; 334 i = i-1; 335 if (i >= 2) then go to label_420; 336 go to label_800; 337 338 339 /* phase error return. */ 340 label_800: 341 prntf = 1; /* TRUE */ 342 expevl_answer = 0; /* FALSE */ 343 label_810: 344 inexp = 0; 345 lc = 0; 346 return ; 347 348 349 /* normal termination return, answer is stk(2). */ 350 label_900: 351 inexp = stk (2); 352 if (tbad ^= 0) then go to label_910; 353 lc = lstk (2); 354 return ; 355 356 /* invalid operator-operand modes somewhere in evaluation */ 357 label_910: 358 lc = 0; 359 if tpass1 = 0 then prntr = 1; 360 expevl_answer = 0; /* FALSE */; 361 return ; 362 363 364 end expevl_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/17/88 0938.8 expevl_.pl1 >spec>install>1170>expevl_.pl1 53 1 10/21/74 1242.9 varcom.incl.pl1 >ldd>include>varcom.incl.pl1 54 2 10/21/74 1243.0 concom.incl.pl1 >ldd>include>concom.incl.pl1 55 3 07/17/81 1911.5 erflgs.incl.pl1 >ldd>include>erflgs.incl.pl1 56 4 05/06/74 1741.0 codtab.incl.pl1 >ldd>include>codtab.incl.pl1 57 5 05/06/74 1741.5 curlc.incl.pl1 >ldd>include>curlc.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. brk 000010 external static fixed bin(26,0) array level 2 dcl 1-7 ref 100 115 120 121 125 183 188 194 brk_temp 000421 automatic fixed bin(17,0) dcl 81 set ref 125* 127 128 129 130 131 132 clint 11 000012 external static fixed bin(26,0) level 2 dcl 2-6 set ref 105* clmlc 16 000012 external static fixed bin(26,0) level 2 dcl 2-6 set ref 107* clstk 14 000012 external static fixed bin(26,0) level 2 dcl 2-6 set ref 108* curlc 000020 external static fixed bin(17,0) level 2 dcl 5-6 ref 148 eb_data_$codtab 000016 external static structure level 1 dcl 4-6 eb_data_$concom 000012 external static structure level 1 dcl 2-6 eb_data_$curlc 000020 external static structure level 1 dcl 5-6 eb_data_$erflgs_overlay 000014 external static structure level 1 dcl 3-9 eb_data_$ilend 000034 external static fixed bin(35,0) dcl 73 ref 94 203 227 294 eb_data_$ineg 000036 external static fixed bin(35,0) dcl 73 ref 142 226 eb_data_$inot 000040 external static fixed bin(35,0) dcl 73 ref 156 293 eb_data_$varcom 000010 external static structure level 1 dcl 1-7 expevl_answer parameter fixed bin(35,0) dcl 78 set ref 13 91* 111* 342* 360* getid_$getid_ 000022 constant entry external dcl 61 ref 98 149 209 glpl_$clh 000026 constant entry external dcl 66 ref 252 252 glpl_$crh 000030 constant entry external dcl 66 ref 251 251 i 000100 automatic fixed bin(17,0) dcl 81 set ref 93* 140* 140 142 154* 154 156 160* 160 162 178 180* 180 181 182 185 192* 192 194 198 206* 206 207 207 208 208 219 221 231 231 231 248 248 248 252 252 265 265 265 272 272 272 272 279 279 281 298 298 298 303 303 303 308 308 308 313 313 313 318 318 325 327* 327 328 332 334* 334 335 icflx 136 000016 external static fixed bin(17,0) level 2 dcl 4-6 ref 131 292 ilpar 50 000016 external static fixed bin(17,0) level 2 dcl 4-6 ref 132 162 205 iminus 55 000016 external static fixed bin(17,0) level 2 dcl 4-6 ref 128 223 289 inexp parameter fixed bin(17,0) dcl 81 set ref 13 343* 350* inputs_$next 000024 constant entry external dcl 61 ref 118 inum 60 000016 external static fixed bin(17,0) level 2 dcl 4-6 ref 100 120 iplus 53 000016 external static fixed bin(17,0) level 2 dcl 4-6 ref 127 222 287 irpar 51 000016 external static fixed bin(17,0) level 2 dcl 4-6 ref 188 iserch 76 000012 external static fixed bin(26,0) level 2 dcl 2-6 set ref 105* 107* 108* islash 57 000016 external static fixed bin(17,0) level 2 dcl 4-6 ref 130 225 291 istar 52 000016 external static fixed bin(17,0) level 2 dcl 4-6 ref 129 224 290 l1 000101 automatic fixed bin(17,0) dcl 81 set ref 219* 233 234 235 235 250 251 252 255 259 260 260 261 267 274 l2 000102 automatic fixed bin(17,0) dcl 81 set ref 221* 233 234 236 236 250 251 252 255 255 259 260 261 267 274 lc parameter fixed bin(17,0) dcl 81 set ref 13 345* 353* 357* lstk 000103 automatic fixed bin(17,0) array dcl 81 set ref 182* 208* 208 219 221 281 325* 332* 353 nstk constant fixed bin(17,0) initial dcl 84 ref 178 op 000247 automatic fixed bin(17,0) dcl 81 set ref 185* 187 203 205 222 223 224 225 226 227 287 289 290 291 292 293 294 pc 25 000010 external static fixed bin(26,0) level 2 dcl 1-7 ref 146 prntf 1 000014 external static fixed bin(17,0) level 2 dcl 3-9 set ref 340* prntr 6 000014 external static fixed bin(17,0) level 2 dcl 3-9 set ref 359* prntu 11 000014 external static fixed bin(17,0) level 2 dcl 3-9 set ref 109* radix 000420 automatic fixed bin(17,0) dcl 81 set ref 89* 121 rprec 000250 automatic fixed bin(17,0) dcl 81 set ref 183* 187 189 stk 000251 automatic fixed bin(17,0) array dcl 81 set ref 94* 142* 156* 162* 181* 185 194* 207* 207 231* 231 231 248* 248 248 252* 252 265* 265 265 272 272* 272 272 279* 279 298* 298 298 303* 303 303 308* 308 308 313* 313 313 318* 318 350 sym 4 000010 external static fixed bin(26,0) array level 2 dcl 1-7 set ref 102 105* 107* 108* 150 210 table_$table_ 000032 constant entry external dcl 66 ref 105 107 108 tbad 000415 automatic fixed bin(17,0) dcl 81 set ref 92* 233* 251* 255* 267* 274* 281* 352 tbool parameter fixed bin(17,0) dcl 81 ref 13 89 89 215 tpass1 61 000010 external static fixed bin(26,0) level 2 dcl 1-7 ref 359 tpass2 62 000010 external static fixed bin(26,0) level 2 dcl 1-7 ref 250 val 000416 automatic fixed bin(17,0) dcl 81 set ref 105* 107* 108* 115* 121* 121 146* 166* 181 vlc 000417 automatic fixed bin(17,0) dcl 81 set ref 105* 107* 108* 117* 148* 168* 182 234* 235* 236* 253* 259* 260* 261* 268* 275* 282* 325 332 NAME DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. eb_data_$erflgs external static structure level 1 dcl 3-5 NAMES DECLARED BY EXPLICIT CONTEXT. expevl_ 000010 constant entry external dcl 13 label_100 000015 constant label dcl 89 label_200 000032 constant label dcl 98 set ref 136 143 157 163 195 label_210 000037 constant label dcl 100 ref 95 label_220 000047 constant label dcl 105 label_225 000144 constant label dcl 109 label_230 000153 constant label dcl 115 ref 100 label_240 000160 constant label dcl 118 ref 122 label_300 000206 constant label dcl 125 ref 102 label_310 000225 constant label dcl 136 ref 127 label_320 000226 constant label dcl 140 ref 128 label_330 000233 constant label dcl 146 ref 129 label_340 000250 constant label dcl 154 ref 130 131 label_350 000255 constant label dcl 160 ref 132 label_360 000262 constant label dcl 166 ref 133 label_400 000265 constant label dcl 178 ref 105 107 108 112 120 151 169 label_410 000276 constant label dcl 183 ref 211 label_420 000302 constant label dcl 185 ref 328 335 label_430 000322 constant label dcl 192 label_440 000327 constant label dcl 198 ref 189 203 label_450 000333 constant label dcl 203 ref 188 label_460 000360 constant label dcl 215 ref 187 label_500 000363 constant label dcl 219 label_510 000407 constant label dcl 231 ref 222 label_520 000432 constant label dcl 248 ref 223 label_525 000542 constant label dcl 255 ref 250 label_530 000571 constant label dcl 265 ref 224 label_540 000603 constant label dcl 272 ref 225 label_550 000617 constant label dcl 279 ref 226 label_600 000627 constant label dcl 287 ref 215 label_610 000651 constant label dcl 298 ref 287 label_620 000655 constant label dcl 303 ref 289 label_630 000661 constant label dcl 308 ref 290 label_640 000665 constant label dcl 313 ref 291 292 label_650 000672 constant label dcl 318 ref 293 label_700 000676 constant label dcl 325 ref 237 254 262 269 276 300 305 310 315 label_710 000706 constant label dcl 332 ref 283 320 label_800 000716 constant label dcl 340 ref 150 178 198 205 210 228 295 329 336 label_810 000724 constant label dcl 343 label_900 000727 constant label dcl 350 ref 200 227 294 label_910 000737 constant label dcl 357 ref 352 NAMES DECLARED BY CONTEXT OR IMPLICATION. bool builtin function ref 303 divide builtin function ref 272 fixed builtin function ref 121 187 unspec builtin function set ref 115 115 121 183* 183 187 298* 298 298 303* 303 303 308* 308 308 313* 313 313 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1104 1146 751 1114 Length 1432 751 42 250 133 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME expevl_ 293 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME expevl_ 000100 i expevl_ 000101 l1 expevl_ 000102 l2 expevl_ 000103 lstk expevl_ 000247 op expevl_ 000250 rprec expevl_ 000251 stk expevl_ 000415 tbad expevl_ 000416 val expevl_ 000417 vlc expevl_ 000420 radix expevl_ 000421 brk_temp expevl_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_ne_as call_ext_out return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. getid_$getid_ glpl_$clh glpl_$crh inputs_$next table_$table_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. eb_data_$codtab eb_data_$concom eb_data_$curlc eb_data_$erflgs_overlay eb_data_$ilend eb_data_$ineg eb_data_$inot eb_data_$varcom LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 13 000003 89 000015 91 000022 92 000024 93 000025 94 000027 95 000031 98 000032 100 000037 102 000044 105 000047 107 000072 108 000117 109 000144 111 000150 112 000152 115 000153 117 000157 118 000160 120 000165 121 000172 122 000205 125 000206 127 000210 128 000212 129 000214 130 000216 131 000220 132 000222 133 000224 136 000225 140 000226 142 000227 143 000232 146 000233 148 000235 149 000237 150 000243 151 000247 154 000250 156 000251 157 000254 160 000255 162 000256 163 000261 166 000262 168 000263 169 000264 178 000265 180 000270 181 000271 182 000274 183 000276 185 000302 187 000305 188 000312 189 000317 192 000322 194 000323 195 000326 198 000327 200 000332 203 000333 205 000336 206 000340 207 000342 208 000345 209 000347 210 000353 211 000357 215 000360 219 000363 221 000365 222 000367 223 000374 224 000376 225 000400 226 000402 227 000404 228 000406 231 000407 233 000411 234 000417 235 000423 236 000426 237 000431 248 000432 250 000434 251 000450 252 000504 253 000540 254 000541 255 000542 259 000551 260 000555 261 000563 262 000570 265 000571 267 000574 268 000601 269 000602 272 000603 274 000610 275 000615 276 000616 279 000617 281 000621 282 000625 283 000626 287 000627 289 000634 290 000636 291 000640 292 000642 293 000644 294 000646 295 000650 298 000651 300 000654 303 000655 305 000660 308 000661 310 000664 313 000665 315 000671 318 000672 320 000675 325 000676 327 000700 328 000702 329 000705 332 000706 334 000710 335 000712 336 000715 340 000716 342 000722 343 000724 345 000725 346 000726 350 000727 352 000732 353 000734 354 000736 357 000737 359 000740 360 000747 361 000750 ----------------------------------------------------------- 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