THIS FILE IS DAMAGED COMPILATION LISTING OF SEGMENT decimal_op_ Compiled by: Multics PL/I Compiler, Release 28d, of September 14, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 10/03/83 1435.4 mst Mon Options: optimize map 1 /* ****************************************************** 2* * * 3* * * 4* * Copyright (c) 1972 by Massachusetts Institute of * 5* * Technology and Honeywell Information Systems, Inc. * 6* * * 7* * * 8* ****************************************************** */ 9 10 /* Decimal arithmetic runtime routines for Version II PL/1 11* These routines operate on floating decimal or fixed scaled decimal numbers 12* with a maximum precision of 63 digits. The length of the number as determined 13* by the input descriptor does not include the leading sign or the trailing 14* exponent character in the case of floating point numbers. 15* 16* Initial Version: 16 July 1971 by PG 17* Modified: 19 October 1972 by RAB */ 18 19 decimal_op_: proc(poperation,pop3,pdesc3,pop1,pdesc1,pop2,pdesc2); 20 21 dcl poperation fixed bin, /* operation to perform 22* 0 = comparsion of op1 and op2 23* 1 is op3 = op1 + op2 24* 2 is op3 = op1 - op2 25* 3 is op3 = op1 * op2 26* 4 is op3 = op1 / op2 27* 5 is op3 = - op1 28* 6 is op3 = ceil(op1) 29* 7 is op3 = floor(op1) 30* 8 is op3 = round(op1,desc2) 31* 9 is op3 = sign(op1) 32* 10 is op3 = abs(op1) 33* 11 is op3 = trunc(op1) 34* 12 is op3 = mod(op1,op2) 35* 13 is op3 = min(op1,op2) 36* 14 is op3 = max(op1,op2) */ 37 pop3 char(1) unal, /* result if operation is not comparsion */ 38 pdesc3 bit(36) aligned, /* descriptor of op3, result if comparison */ 39 pop1 char(1) unal, /* left operand */ 40 pdesc1 bit(36) aligned, /* descriptor */ 41 pop2 char(1) unal, /* right operand */ 42 pdesc2 bit(36) aligned; /* descriptor of op2, 2nd arg of round bif */ 43 44 dcl ( ans,op1,op2,product(9),remainder) char(64) aligned; 45 dcl ( desc1,desc2,desc3) bit(36) aligned; 46 dcl max_desc bit(36) aligned int static init("100101000000000000000000000000111111"b); 47 dcl decimal_op_ entry(fixed bin,char(1) unal,bit(36) aligned,char(1) unal,bit(36) aligned,char(1) unal,bit(36) aligned); 48 dcl c char(1) unal based(p); 49 dcl p ptr; 50 dcl ( sch,ch,ci,sign,sign1,sign2) char(1) aligned; 51 dcl ( big,carry,col1,col2,exp,i,j,k,l0,l1,l2,l3,lg3,len1,len2,n,p1,p2, 52 s1,s2,scale1,scale2,scale3,sc3,st(9),sum) fixed bin; 53 dcl ( addr,binary,bit,divide,fixed,length,max,min,null,substr,unspec) builtin; 54 dcl info bit(36) initial("111011011100010010110010000101001001"b) internal static; 55 dcl ( zero_op1 init(13),zero_op2 init(22)) fixed bin int static; 56 dcl bit3 bit(3) aligned; 57 dcl ( add,float,negate,no_round,product_calculated(9),signal_ufl) bit(1) aligned; 58 dcl operation fixed bin; 59 dcl based_fb based fixed bin; 60 dcl negabs bit(1) aligned init("0"b); 61 62 dcl ( comparison init(0), 63 addition init(1), 64 subtraction init(2), 65 multiplication init(3), 66 division init(4), 67 negation init(5), 68 ceil_fun init(6), 69 floor_fun init(7), 70 round_fun init(8), 71 sign_fun init(9), 72 abs_fun init(10), 73 trunc_fun init(11), 74 mod_fun init(12), 75 min_fun init(13), 76 max_fun init(14)) fixed bin int static; 77 78 79 dcl plio2_signal_$s_ entry(ptr,char(*) aligned,char(*) aligned,fixed bin); 80 dcl condition(5) char(13) aligned internal static 81 initial("SIZE","OVERFLOW","UNDERFLOW","ZERODIVIDE","FIXEDOVERFLOW"); 82 dcl error_number(5) fixed bin internal static initial(158,159,160,120,121); 83 84 begin: 85 desc3 = pdesc3; 86 desc1 = pdesc1; 87 negate, 88 signal_ufl = "0"b; 89 operation = poperation; 90 if operation = min_fun then operation = comparison; 91 if operation = max_fun then operation = comparison; 92 if operation = negation | operation = abs_fun 93 then do; 94 95 /* we use the fact that op3 will have the same attributes as op1 */ 96 97 l1 = fixed(substr(desc1,25,12),12); 98 sch = substr(pop1,1,1); 99 if operation = negation 100 then if sch = "-" 101 then sch = "+"; 102 else sch = "-"; 103 else sch = "+"; 104 if substr(desc1,13,12) = substr(desc3,13,12) then /* check for equal scales */ 105 do; 106 if substr(desc1,7,1) = "0"b then l1 = l1 + 1; /* floating pt */ 107 substr(pop3,1,1) = sch; 108 substr(pop3,2,l1) = substr(pop1,2,l1); 109 return; 110 end; 111 else negabs = "1"b; 112 end; 113 114 desc2 = pdesc2; 115 float = ^ substr(desc3,7,1); 116 117 l0 = fixed(substr(desc3,25,12),12); 118 if l0 = 0 then call setdesc; 119 lg3 = l0 + 1; 120 121 122 if float then lg3 = lg3 + 1; 123 else do; 124 sc3 = fixed(substr(desc3,13,12),12); 125 if sc3 > 2047 then sc3 = sc3 - 4096; 126 end; 127 128 l1 = fixed(substr(desc1,25,12),12) + 1; 129 130 if substr(desc1,7,1) 131 then do; 132 133 /* fixed decimal */ 134 135 scale1 = fixed(substr(desc1,13,12),12); 136 if scale1 > 2047 then scale1 = scale1 - 4096; 137 end; 138 else do; 139 140 /* float decimal */ 141 142 ch = substr(pop1,l1+1,1); 143 exp = fixed(unspec(ch),9); 144 if exp >= 128 then exp = exp - 256; 145 scale1 = -exp; 146 end; 147 148 if operation >= negation & operation < mod_fun 149 then go to skip_opnd_two; 150 151 l2 = fixed(substr(desc2,25,12),12) + 1; 152 153 if substr(desc2,7,1) 154 then do; 155 156 /* fixed decimal */ 157 158 scale2 = fixed(substr(desc2,13,12),12); 159 if scale2 > 2047 then scale2 = scale2 - 4096; 160 end; 161 else do; 162 163 /* float decimal */ 164 165 ch = substr(pop2,l2+1,1); 166 exp = fixed(unspec(ch),9); 167 if exp >= 128 then exp = exp - 256; 168 scale2 = -exp; 169 end; 170 171 op2 = (64)"0"; 172 sign2 = substr(pop2,1,1); 173 s2 = 66-l2; 174 substr(op2,s2,l2-1) = substr(pop2,2,l2-1); 175 176 do j = s2 to 64 while( substr(op2,j,1) = "0"); 177 end; 178 s2 = j-1; /* s2 = verify(op2,"0") - 1; */ 179 p2 = 65-j; /* # digits */ 180 181 skip_opnd_two: 182 ans, op1 = (64)"0"; 183 sum, carry = 0; 184 sign1 = substr(pop1,1,1); 185 s1 = 66-l1; 186 substr(op1,s1,l1-1) = substr(pop1,2,l1-1); 187 188 do j = s1 to 64 while( substr(op1,j,1) = "0" ); /* find true number of digits */ 189 end; 190 s1 = j-1; /* s1 = position to left of first non-zero digit */ 191 p1 = 65 - j; 192 193 if negabs then 194 do; 195 sign1 = sch; 196 go to assign_op1; 197 end; 198 199 if operation = division then go to divide_op; 200 /0*@:00h*@:00l*@:0l*:0~/&::RK0(0(la0 `853493.sts ::!6$0vGlaVG0Nl*@::0F0VP*@::0N0^*@::0V0f*@::0^0nh*@::0f0vl*@::0nl*::00 &:9RK00la0~{853493.ec :9bp̠.$0GlaG0l*@:900P*@:900*@:900*@:900h*@:900l*@:90l*:90:0~&;RK00lm0hD853493_1.dll ;bY+$02GlmG0 l*@;00P*@;0 0*@;00"*@;00*h*@;0"02l*;0*l*;00&;RK0B0Blm0:A.P853493_1.dll ;bp'$0Glm^"G0hl*@;0`0pP*@;0h0x*@;0p0*@;0x0h*@;00l*;0l*;00:&;RK00lm0;R853493_1.dll ;!6$0Glm{dG0l*@;00P*@;00*@;00*@;00h*@;00l*;0l*;40&;RK00lm0M853493_1.map ;!63$1LGlm?G1$l*@;11,P*@;1$14*@;1,1<*@;141Dh*@;1<1Ll*;1Dl*;1D0&`[R}z1\1\>la1T773720.value `[ k#$1G>lmh@11l*@`[11z*@`[1>l*@`[11*@`[G1P*@`[1z1*@`[11h*@`[G*`[R1v1&`[RR}11>la1773720.sts `[R!i g$11>laiG1P*@`[R11*@`[R11*@`[R11h*@`[R1>l*@`[RG1*@`[11Vh*@`[11T&`[R}m1 1 >la1]773720.sts.archive `[bY+$1V1N>la1FGP*@`[1N1>l*@`[1F*`[1>l*@`[1n1f*@`[1^1h*@`[H1^*@`[11&`[R}1~1~>la1v`773720.ec `[ . $11>la 1Hl*@`[1*`[1f>l*@`[11*@`\12h*@`\11*@`\H 1P*@`\221v&`\RT711>lm1D773720_1.dll `\bp'$21>lmBH * go to normalize; 324 end; 325 326 if operation = sign_fun 327 then do; 328 if sign1 = "-" 329 then i = -1; 330 else if p1 = 0 331 then if substr(desc1,7,1) /* fixed point zero */ 332 then i = 0; 333 else if scale1 = -127 /* floating point zero */ 334 then i = 0; 335 else i = 1; 336 else i = 1; 337 addr(pop3)->based_fb = i; 338 return; 339 end; 340 341 if operation = mod_fun 342 then do; 343 p = addr(ans); 344 call decimal_op_(division,c,max_desc,pop1,pdesc1,pop2,pdesc2); 345 call decimal_op_(floor_fun,c,max_desc,c,max_desc,pop2,pdesc2); 346 call decimal_op_(multiplication,c,max_desc,c,max_desc,pop2,pdesc2); 347 call decimal_op_(subtraction,pop3,pdesc3,pop1,pdesc1,c,max_desc); 348 return; 349 end; 350 351 i = scale1; 352 j = scale2; 353 354 if operation ^= comparison 355 then do; 356 if p1 = 0 357 then do; 358 if operation = multiplication then go to assign_zero2; 359 if p2 = 0 then go to assign_zero2; 360 go to assign_op2; 361 end; 362 if p2 = 0 363 then do; 364 if operation = multiplication then go to assign_zero2; 365 go to assign_op1; 366 end; 367 368 if operation = multiplication then go to multiply_op; 369 if operation = addition then add = "1"b; else add = "0"b; 370 end; 371 372 scale3 = max(scale1,scale2); /* pl1 language rules for scale of result */ 373 col1 = s1 - scale3 + scale1 + 1; /* re-align operands to account for scales */ 374 col2 = s2 - scale3 + scale2 + 1; 375 len1 = min(65-col1,p1); 376 len2 = min(65-col2,p2); 377 378 if float /* force number to start in at least column 2 */ 379 then do; 380 if col1 < 2 381 then do; 382 k = 2-col1; 383 again: col1 = col1 + k; 384 col2 = col2 + k; 385 scale1 = scale1 - k; 386 scale2 = scale2 - k; 387 scale3 = scale3 - k; 388 end; 389 if col2 < 2 390 then do; 391 k = 2-col2; 392 go to again; 393 end; 394 end; 395 else if operation ^= comparison 396 then do; 397 if col1 < 2 then go to signal_size; 398 if col2 < 2 then go to signal_size; 399 end; 400 401 if operation ^= comparison 402 then do; 403 if len1 < 1 /* operand one was zero */ 404 then do; 405 if len2 < 1 then go to assign_zero2; /* both are zero */ 406 assign_op2: 407 ans = (64)"0"; 408 substr(ans,s2+1,p2) = substr(pop2,l2-p2+1,p2); 409 if operation = subtraction then if sign2 = "+" then sign2 = "-"; 410 else sign2 = "+"; 411 sign = sign2; 412 l3 = s2; 413 scale3 = j; 414 go to normalize; 415 end; 416 if len2 < 1 /* operand two was zero */ 417 then do; 418 assign_op1: 419 ans = (64)"0"; 420 substr(ans,s1+1,p1) = substr(pop1,l1-p1+1,p1); 421 sign = sign1; 422 l3 = s1; 423 scale3 = i; 424 go to normalize; 425 end; 426 end; 427 else do; 428 if col1 ^= col2 then go to test; 429 if col1 < 2 430 then do; 431 n = l1 - p1 + 1; 432 k = l2 - p2 + 1; 433 compare_long_fixed_loop: 434 ch = substr(op1,n,1); 435 ci = substr(op2,k,1); 436 if ch > ci /* op1 > op2 */ 437 then do; 438 big = 1; 439 go to compare; 440 end; 441 if ch < ci /* op1 < op2 */ 442 then do; 443 big = -1; 444 go to compare; 445 end; 446 if n = 64 447 then do; /* op1 is shorter */ 448 do n = k+1 to 64 while(substr(op2,n,1) = "0"); 449 end; 450 if n = 65 451 then do; /* op1 = op2 */ 452 compare_equal: big = 0; 453 go to compare; 454 end; 455 big = -1; /* op1 < op2 */ 456 go to compare; 457 end; 458 if k = 64 459 then do; /* op2 shorter */ 460 do k = n+1 to 64 while(substr(op1,k,1) = "0"); 461 end; 462 if k = 65 then go to compare_equal; /* op1 = op2 */ 463 big = 1; /* op1 > op2 */ 464 go to compare; 465 end; 466 k = k + 1; 467 n = n + 1; 468 go to compare_long_fixed_loop; 469 end; 470 end; 471 op1,op2 = (64)"0"; 472 substr(op1,col1,len1) = substr(pop1,l1-p1+1,len1); /* final alignment prior to operation */ 473 substr(op2,col2,len2) = substr(pop2,l2-p2+1,len2); /* takes care of lengths and scale. */ 474 p1 = 65-col1; 475 p2 = 65-col2; 476 477 /* Now determine which operand has the larger magnitude, and make it operand one. */ 478 479 test: 480 if len1 > len2 481 then big = 1; 482 else if len2 > len1 483 then big = -1; 484 else do; 485 do n = col1 to 64 while(substr(op1,n,1) = substr(op2,n,1)); 486 end; 487 if n = 65 488 then big = 0; 489 else if substr(op2,n,1) < substr(op1,n,1) 490 then big = 1; 491 else big = -1; 492 end; 493 494 if operation = comparison 495 then do; 496 compare: 497 if big ^= 0 498 then if sign1 = "+" 499 then if sign2 = "-" 500 then big = 1; 501 else; 502 else if sign2 = "+" 503 then big = -1; 504 else big = -big; 505 506 if poperation = min_fun 507 then if big <= 0 508 then go to assign_op1; 509 else go to assign_op2; 510 if poperation = max_fun 511 then if big <= 0 512 then go to assign_op2; 513 else go to assign_op1; 514 515 addr(pdesc3)->based_fb = big; 516 return; 517 end; 518 519 /* Simulate a 3-dimensional array, and use "info" to determine whether the operands 520* must be switched, what the operation will be, and the sign of the result. */ 521 522 s1 = col1-1; 523 s2 = col2-1; 524 j = 1; 525 if ^add 526 then if sign2 = "-" 527 then sign2 = "+"; 528 else sign2 = "-"; 529 if sign1 = "-" then j = j + 18; 530 if sign2 = "-" then j = j + 9; 531 if big = 0 then j = j + 3; 532 else if big = 1 then j = j + 6; 533 if j = zero_op1 | j = zero_op2 then go to assign_zero2; 534 bit3 = substr(info,j,3); 535 add = substr(bit3,3,1); 536 if substr(bit3,1,1) /* switch bit */ 537 then do; 538 ans = op1; 539 op1 = op2; 540 op2 = ans; 541 ans = (64)"0"; 542 k = s1; 543 s1 = s2; 544 s2 = k; 545 end; 546 if substr(bit3,2,1) /* sign bit */ 547 then sign = "+"; 548 else sign = "-"; 549 l1,l2,l3 = 64; 550 551 /* Loop to perform addition or subtraction. op2 <= op1 */ 552 553 loop1: 554 ch = substr(op2,l2,1); 555 k = fixed(unspec(ch) & "000001111"b); /* convert ASCII to BINARY */ 556 557 loop2: 558 ch = substr(op1,l1,1); 559 i = fixed(unspec(ch) & "000001111"b,15,0); 560 561 if add 562 then do; 563 sum = i + k + carry; 564 carry = 0; 565 if sum >= 10 566 then do; 567 sum = sum - 10; 568 carry = 1; 569 end; 570 end; 571 else do; 572 sum = i - k - carry; 573`\1>l*`\22*@`\2 2Xh*@`\2"2 *@`\2*2P*@`\H2"l*@`\21&`\RT;2:2:>lm22P773720_1.dll `\!6 $2XH>lm۲2>l*`\2p2h*@`\2`Hh*@`\2x2`*@`\22pP*@`\22xl*@`\2*`\222&`\RT?22>lm2R773720_1.dll `\bp̠ $H2>lm{d52h*@`\y25*@`\y22P*@`\y22l*@`\y2*`\y2>l*`\y2H$*@`_|2L2&`\yRTO22>lm2CM773720_1.map `\y!i $22>lm422*@`_|2$2P*@`_|2,2l*@`_|2$*`_|H$>l*`_|H,2D*@`_C2<2h*@`_C22&`_|RT)2T2T>lm2LnD773720_2.dll `_|bp' $242,>lm 2zH,P*@`_C22rl*@`_C2z*`_C2D>l*`_C22*@`_~22h*@`_~H42*@`_~32L&`_CRT-22>lm2GP773720_2.dll `_Cbp' $22>lm 2H4l*@`_~2*`_~2>l*`_~22*@`_}236h*@`_}32*@`_}H<2P*@`_}52&`_~RT133>lm3AR773720_2.dll `_~bq |$22>lm*H<*`_}2>l*`_}3F3Nl*@`3>*`3>3VP*@`3NHD*@`HD3h*@`35&`_}R}zx3n3n>lm3fM773720_2.map `_}bp' $363.>lm(3^>l*`33l*@` 3*` 33P*@` 33*@` 3HLh*@` 33*@` 4<3"&`R}p3D>lmD3=M773720_3.map `bp̠ $33F>lm33l*@`3*`33P*@`33*@`33h*@`33 *@`3 >l*`33&` R}n3*D>lmD3"bG773720_3.dll ` !i $HL3>lm-HT3Pl*@`3H3XP*@`3P3`*@`3X3h*@`3`3ph*@`3h>l*`H\l*r3"3&`R}m3D>lmD31B773720_3.dll `bp̠ $33>lmH3l*@r3P*@r3*@r3*@r3h*@r3l*rHdl*r33f&`R}k3D>lmD3wA773720_3.dll `!i $3pHT>lm޾4 l*@r4P*@r4*@r4$*@r4,h*@r44l*rl*r3&` R}4D4D>lm4<G1U01200.crc.dll ` !i $44b>lm$H*` 4r4*@` H4jP*@` 44h*@` 4j4z*@` 3xl* p}4z>l*` 40&cRK44lm4G1G01000.crc.dll cbq $4Hllm$Hl4l*@c44P*@c44*@c44*@c44h*@c44l*c4l*c4^4&s{RK44>la4m883028.value s{ k#L$ 4VHt>lm.Ht4&P*@s{44.*@s{4&46*@s{4.4>l*@s{464F*@s{4>4Nh*@s{4F4V>l*@s{4Nl*s{44&suRK4f4f>la4^883028.sts.archive su .z$4H|>laIH|4l*@su44P*@su44*@su44*@su44h*@su44>l*@su4l*su54^&sRK44>la4u+883028.sts sbY+$5H>laDH4l*@s44P*@s44*@s45*@s45 h*@s55>l*@s5 l*s5x4&sRK5"5">la5883028.ec s k#$5pH>la2H5Hl*@s5@5PP*@s5H5X*@s5P5`*@s5X5hh*@s5`5p>l*@s5hl*s55&shRK55>lm5xD883028_2.dll shbq 9$5H>lmH5l*@sh55P*@sh55*@sh55*@sh55h*@sh55>l*sh5l*sh545x&sgRK55>lm5P883028_2.dll sg!i1$5,H>lm H5l*@sg55 P*@sg55*@sg5 5*@sg55$h*@sg55,>l*sg5$l*sg55&smRK5<5<>lm54R883028_2.dll sm!6L$5H>lm{dH5bl*@sm5Z5jP*@sm5b5r*@sm5j5z*@sm5r5h*@sm5z5>l*sm5l*sm3f3&`_ZRT955>lm5G1001700.crc.dll `_Z!i &$55>lm$I*`_ZI5P*@`_Z55*@`_Z55h*@`_Z55*@`_Z5>l*`_Z22*@`\y6N54&siRK55>lm5IM883028_2.map si!i$6FH>lm'H6l*@si66&P*@si66.*@si6&66*@si6.6>h*@si666F>l*si6>l*si65&ҼRK6V6V>la6N832155.value Ҽ .$ 6HlaWH6|P*@Ҽ6t6*@Ҽ6|6*@Ҽ66l*@Ҽ66*@Ҽ66h*@Ҽ66>l*@Ҽ6l*Ҽ66N&ҿRK66>la6W832155.sts.archive ҿ!6$6 H>laXH6l*@ҿ66P*@ҿ66*@ҿ66*@ҿ66h*@ҿ66 >l*@ҿ6l*ҿ6p6&:RK 66>la6832155.sts :bp'$6hH>laH6@l*@:686HP*@:6@6P*@:6H6X*@:6P6`h*@:6X6h>l*@:6`l*:66&RK!6x6x>la6pi832155.ec bp'c$6H>la `H6l*@66P*@66*@66*@66h*@66>l*@6l*7,6p&lm6{D832155_2.dll < .~$7$H>lmH6P*@<67*@<67 *@<77l*<7 7h*@<77$>l*<7l*<76&3RK$7474>lm7,QP832155_2.dll 3!6$7H>lmvH7ZP*@37R7b*@37Z7j*@37b7rl*37j7zh*@37r7>l*37zl*377,&RK&77>lm7KR832155_2.dll bq$7H>lm|H7P*@77*@77*@77l*77h*@77>l*7l*7F7&=RK'77>lm7 M832155_2.map = . $7>H>lm H7l*@=77P*@=77&*@=77.*@=7&76h*@=7.7>>l*=76l*=77&RK)7N7N>lm7FD832155_1.dll bY+)$7H>lmH7tP*@7l7|*@7t7*@7|7l*77h*@77>l*7l*87F&RK+77>lm7P832155_1.dll bq $7H>lmvH7P*@77*@77*@77l*77h*@77>l*7l* 953 substr(op1,col1,len1) = substr(ans,l3+1,len1); 954 ans = op1; 955 end; 956 else if sc3 > scale3 then 957 do; 958 col1 = l3 + 1 + scale3 - sc3; 959 len1 = 64 - l3 - 1; 960 if lg3 >= 64 - col1 then go to scale_fixed; 961 go to signal_size; 962 end; 963 964 assign: 965 substr(pop3,1,lg3) = substr(ans,65-lg3,lg3); 966 if float 967 then do; 968 unspec(ch) = substr(unspec(exp),28,9); 969 substr(pop3,lg3,1) = ch; 970 end; 971 substr(pop3,1,1) = sign; 972 if ^signal_ufl then return; 973 974 signal: 975 976 /* Signal the relevant condition. The default handler will print a message 977* indicating that the program is in error (except for underflow), and so 978* if he returns, we will, too. (although we could really do anything we 979* please!) */ 980 981 call plio2_signal_$s_(null,condition(i),"",error_number(i)); 982 983 return; 984 985 assign_zero: 986 ans = (64)"0"; 987 988 assign_zero2: 989 sign = "+"; 990 exp = 127; 991 go to assign; 992 993 994 /* BIG REL BITS SIGNS (definition of "info" bit string) 995* -1 < 111 ++ 996* 0 = 011 ++ 997* 1 > 011 ++ 998* -1 < 100 +- 999* 0 = 010 +- Zero_op1 1000* 1 > 010 +- 1001* -1 < 110 -+ 1002* 0 = 010 -+ Zero_op2 1003* 1 > 000 -+ 1004* -1 < 101 -- 1005* 0 = 001 -- 1006* 1 > 001 -- 1007* 1008*bit(1) = 1 if switch operands to make op1 > op2, 1009*bit(2) = 1 if result is +, 1010*bit(3) = 1 if operation is add. */ 1011 1012 1013 1014 /* setdesc follows PL/I rules to calculate the precision and scale of the result 1015* when this has not been provided by the calling program */ 1016 1017 setdesc: proc; 1018 if operation = comparison then return; 1019 if operation > division then return; 1020 p1 = fixed(substr(desc1,25,12),12); 1021 p2 = fixed(substr(desc2,25,12),12); 1022 if float then 1023 do; 1024 l0 = max(p1,p2); 1025 end; 1026 else 1027 do; 1028 scale1 = fixed(substr(desc1,13,12),12); 1029 if scale1 > 2047 then scale1 = scale1 - 4096; 1030 scale2 = fixed(substr(desc2,13,12),12); 1031 if scale2 > 2047 then scale2 = scale2 - 4096; 1032 go to case(operation); 1033 1034 /* addition|subtraction */ 1035 1036 case(1): case(2): scale3 = max(scale1,scale2); 1037 l0 = min(63,max(p1-scale1,p2-scale2)+scale3+1); 1038 go to set_scale; 1039 1040 /* multiplication */ 1041 1042 case(3): l0 = min(63,p1+p2+1); 1043 scale3 = scale1 + scale2; 1044 go to set_scale; 1045 1046 /* division */ 1047 1048 case(4): l0 = 63; 1049 scale3 = 63 - p1 + scale1 - scale2; 1050 1051 set_scale: if scale3 < 0 then scale3 = scale3 + 4096; 1052 substr(desc3,13,12) = bit(binary(scale3,12),12); 1053 end; 1054 1055 substr(desc3,25,12) = bit(binary(l0,12),12); 1056 pdesc3 = desc3; 1057 return; 1058 end; 1059 1060 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/03/83 1005.7 decimal_op_.pl1 >spec>on>pl128d>decimal_op_.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. abs_fun constant fixed bin(17,0) initial dcl 62 ref 92 add 000477 automatic bit(1) dcl 57 set ref 369* 369* 525 535* 561 addition 8`7&RK08 8 >lm8R832155_1.dll bq -$8XH>lm|H80P*@8(88*@808@*@888Hl*8@8Ph*@8H8X>l*8Pl*88&RK28h8h>lm8`G100130D.crc.dll !6$8H >lm$H 8l*@88P*@88*@88*@88h*@88>l*8l*8L8`&RK488>lm8PM832155_1.map bp'$8H>lm H8l*@88P*@88*@88*@88 h*@88>l*8 l*8$h*@8,8*@848$*@8<8,P*@8D84l*@8<*98&RK58T8Tla8L6V781741.value bY+$ 8H>lmn88zh*@8r8l*@88r*@88*@88*@H8P*@8zl*88l*@9n9&RK888la86781741.sts bq n$9H,>la88*@98P*@88*@88h*@89l*@8l*H,8l*@88L&#RK699la9W6781741.sts.archive # . $9^H$>la9>9F*@#9f96P*@#969N*@#9F9Vh*@#9N9^l*@#9Vl*#H$9>l*@#98&RK99v9vla9ni6x781741.ec bp̠ $9H4>la i99*@99P*@99*@99h*@99l*@9l*H49l*@9*9n& Z:RK;99>lm9#4D781741_1.dll Z:bq $9H<>lmȒ99*@ Z:9"9P*@ Z:99 *@ Z:99h*@ Z:9 9>l* Z:9l* Z:H<9l*@ Z:99& Zlm9*#P781741_1.dll Z<!i -$9xHD>lmcl9X9`*@ Z<99PP*@ Z<9P9h*@ Z<9`9ph*@ Z<9h9x>l* Z<9pl* Z<HD9Xl*@ Z<99*& Z$RK?99>lm9#R781741_1.dll Z$bq $9HL>lm 99*@ Z$99P*@ Z$99*@ Z$99h*@ Z$99>l* Z$9l* Z$HL9l*@ Z$:D9& Z?RKA99>lm9O%`M781741_1.dll Z? . 475 523 639* 643 729* 744 749* 749 750 839* 844 845* 845 comparison constant fixed bin(17,0) initial dcl 62 ref 90 91 354 395 401 494 1018 condition 000015 internal static char(13) initial array dcl 80 set ref 974* decimal_op_ 000046 constant entry external dcl 47 ref 344 345 346 347 desc1 000420 automatic bit(36) dcl 45 set ref 86* 97 104 106 128 130 135 330 1020 1028 desc2 000421 automatic bit(36) dcl 45 set ref 114* 151 153 158 1021 1030 desc3 000422 automatic bit(36) dcl 45 set ref 84* 104 115 117 124 1052* 1055* 1056 divide builtin function dcl 53 ref 771 division 000013 internal static fixed bin(17,0) initial dcl 62 set ref 199 344* 1019 error_number 000041 internal static fixed bin(17,0) initial array dcl 82 set ref 974* exp 000440 automatic fixed bin(17,0) dcl 51 set ref 143* 144 144* 144 145 166* 167 167* 167 168 912* 913* 917* 917 925 930 936 936* 936 968 990* fixed builtin function dcl 53 ref 97 117 124 128 135 143 151 158 166 215 310 555 559 653 657 661 760 762 766 770 784 843 846 1020 1021 1028 1030 float 000500 automatic bit(1) dcl 57 set ref 115* 122 378 595 605 704 720 872 904 966 1022 floor_fun 000014 internal static fixed bin(17,0) initial dcl 62 set ref 236 345* i 000441 automatic fixed bin(17,0) dcl 51 set ref 246* 265* 266 266* 269 274 286* 287 287* 289 328* 330* 333* 335* 336* 337 351* 423 559* 563 572 608* 657* 663 687* 688 688* 697* 713* 714* 730* 731 733 739 741 760* 762* 762 766* 771 811* 812 813 843* 847 864* 865 865 907* 908 927* 932* 941* 974 974 info 000004 constant bit(36) initial unaligned dcl 54 ref 534 j 000442 automatic fixed bin(17,0) dcl 51 set ref 176* 176* 178 179 188* 188* 190 191 301* 322 352* 413 524* 529* 529 530* 530 531* 531 532* 532 533 533 534 617* 621* 625* 637 639 640 641 644 661* 663 718* 771* 772 772* 777 781 785 795 802 805 806 811 817 817 822 827* 827 834 844 910* 910* 913 916 k 000443 automatic fixed bin(17,0) dcl 51 set ref 274* 274* 276 301* 307 309 315 316* 316 320 382* 383 384 385 386 387 391* 432* 435 448 458 460* 460* 462 466* 466 542* 544 555* 563 572 588* 616* 620* 624* 628 630 631 632 635 653* 663 770* 771 784* 785 846* 847 908* 910 916* 917 918 919 l0 000444 automatic fixed bin(17,0) dcl 51 set ref 117* 118 119 1024* 1037* 1042* 1048* 1055 l1 000445 automatic fixed bin(17,0) dcl 51 set ref 97* 106* 106 108 108 128* 142 185 186 186 420 431 472 549* 557 585* 585 589 634 655* 656 659* 704* 706* 734 736 755 868 l2 000446 automatic fixed bin(17,0) dcl 51 set ref 151* 165 173 174 174 213* 214 220 221* 221 224 408 432 473 549* 553 584* 584 587 643 651* 652 659* 782* 783 795* 802 803* 803 805 814* 815 817 821* 821 822 822 841* 842 856* 859* 859* 862 891 892 892 893* 893 895 l3 000447 automatic fixed bin(17,0) dcl 51 set ref 225 225* 225 272* 296* 412* 422* 549* 581 583* 583 593 594* 594 595 603* 605 659* 660 674 679* 679 683 691* 691 722* 725* 733* 733 734 736* 755 756* 756 837 865 865* 868 874 875 876 887* 894* 894 907 910 913 918 919 921 938 950 953 958 959 len1 000451 automatic fixed bin(17,0) dcl 51 set ref 213 269* 271 271 289* 290 291 294* 300 300 301 375* 403 472 472 479 482 631* 634 634 875* 880* 885 919* 921 921 951* 953 953 959* len2 000452 automatic fixed bin(17,0) dcl 51 set ref 376* 405 416 473 473 479 482 640* 643 643 719* 723 725 731 733 739* 741 757* 757 812 813 841 895* 895 896* 896 lg3 000450 automatic fixed bin(17,0) dcl 51 set ref 119* 122* 122 704 706 907 938 960 964 964 964 969 max builtin function dcl 53 ref 372 907 1024 1036 1037 max_desc 000010 internal static bit(36) initial dcl 46 set ref 344* 345* 345* 346* 346* 347* max_fun constant fixed bin(17,0) initial dcl 62 ref 91 510 min builtin function dcl 53 ref 265 286 375 376 880 1037 1042 min_fun constant fixed bin(17,0) initial dcl 62 ref 90 506 mod_fun constant fixed bin(17,0) initial dcl 62 ref 148 341 multiplication 000012 internal static fixed bin(17,0) initial dcl 62 set ref 346* 358 364 368 n 000453 automatic fixed bin(17,0) dcl 51 set ref 284* 289 431* 433 446 448* 448* 450 460 467* 467 485* 485 485* 487 489 489 negabs 000516 automatic bit(1) initial dcl 60 set ref 60* 111* 193 negate 000501 automatic bit(1) dcl 57 set ref 87* 206* 228 241* negation constant fixed bin(17,0) initial dcl 62 ref 92 99 148 no_round 000502 automatic bit(1) dcl 57 set ref 293* 303 null builtin function dcl 53 ref 974 974 op1 000120 automatic char(64) dcl 44 set ref 181* 186* 188 271 274 300 433 460 471* 472* 485 489 538 539* 557 633* 634* 656 710 870* 885* 886 920* 921* 922 952* 953* 954 op2 000140 automatic char(64) dcl 44 set ref 171* 174* 176 435 448 471* 473* 485 489 539 540* 553 642* 643* 652 711 744 769 783 operation 000515 automatic fixed bin(17,0) dcl 58 set ref 89* 90 90* 91 91* 92 92 99 148 148 199 201 236 251 282 326 341 354 358 364 368 369 395 401 409 494 1018 1019 1032 p 000424 automatic pointer dcl 49 set ref 343* 344 345 345 346 346 347 p1 000454 automatic fixed bin(17,0) dcl 51 set ref 191* 265 269 286 289 330 356 375 420 420 420 431 472 474* 1020* 1024 1037 1042 1049 p2 000455 automatic fixed bin(17,0) dcl 51 set ref 179* 359 362 376 408 408 408 432 473 475* 1021* 1024 1037 1042 pdesc1 parameter bit(36) dcl 21 set ref 19 86 344* 347* pdesc2 parameter bit(36) dcl 21 set ref 19 114 284 344* 345* 346* pdesc3 parameter bit(36) dcl 21 set ref 19 84 347* 515 1056* plio2_signal_$s_ 000050 constant entry external dcl 79 ref 974 pop1 parameter char(1) unaligned dcl 21 set ref 19 98 108 142 184 186 344* 347* 420 472 634 pop2 parameter char(1) unaligned dcl 21 set ref 19 165 172 174 344* 345* 346* 408 473 643 pop3 parameter char(1) unaligned dcl 21 set ref 19 107* 108* 337 347* 964* 969* 971* poperation parameter fixed bin(17,0) dcl 21 ref 19 89 506 510 product 000160 automatic char(64) array dcl 44 set ref 711* 716* 781* 795*$:4HT>lm%V::*@ Z?:<: P*@ Z?: :$*@ Z?::,h*@ Z?:$:4>l* Z?:,l* Z?HT:l*@ Z?:9& Z9RKD:L:L>lm:D?#NM781741_1.map Z9 . $:H\>lm:r:z*@ Z9::jP*@ Z9:j:*@ Z9:z:h*@ Z9::>l* Z9:l* Z9H\:rl*@ Z9;:& aBRKL::>lm:M781741_2.dll aBbq $:H|>lm%V::>l* aB:l* aB::h*@ aB::*@ aB::P*@ aB::*@ aBH|:l*@ aB::^& a?RKJ::>lm::R781741_2.dll a?!6 $:.Ht>lm:6:.>l* a?:&l* a?:>:&h*@ a?:N:6*@ a?:V:NP*@ a?:F:>*@ a?Ht:Fl*@ a?::& aARKH:f:f>lm:^@|P781741_2.dll aAbp̠ $:Hl>lmcl::>l* aA:l* aA::h*@ aA::*@ aA::P*@ aA::*@ aAHl:l*@ aA:^:D& aGRKF::>lm:jfD781741_2.dll aGbp̠ $:Hd>lm::>l* aG:l* aG::h*@ aG; :*@ aG;; P*@ aG;:*@ aGHd;l*@ aG;x:& a7RKN;";">lm;M781741_2.map a7!6 $;@H>lmr;Hl* a7;P;@>l* a7;X;Hh*@ a7;`;P*@ a7;h;X*@ a7;p;`P*@ a7H;hl*@ a7;;& cvRKP;;>lm;x,D781741_3.dll cvbp̠ :$;H>lm;;*@ cv;;P*@ cv;;*@ cv;;h*@ cv;;>l* cv;l* cvH;l*@ cv;4;x& cRKQ;;>lm;9P781741_3.dll cbp' &$;$H>lmcl;; *@ c;,;P*@ c;;*@ c; ;h*@ c;;$>l* c;l* cH;l*@ c;;& cRKS;<;<>lm;4R781741_3.dll cbp̠ ;$;H>lm;b;j*@ c;;ZP*@ c;Z;r*@ c;j;zh*@ c;r;>l* c;zl* cH;bl*@ c;;4& cRKU;;>lm;IM781741_3.dll c!i R$;H>lm%V;;*@ c;;P*@ c;;*@ c;;h*@ c;;>l* c;l* cH;l*@ clm;9M781741_3.map builtin function dcl 53 set ref 97 98 104 104 106 107* 108* 108 115 117 124 128 130 135 142 151 153 158 165 172 174* 174 176 184 186* 186 188 214 219 220* 223 224* 225 271* 271 274 300* 300 307 309 314 315* 319 320* 322* 330 408* 408 420* 420 433 435 448 460 472* 472 473* 473 485 485 489 489 534 535 536 546 553 557 580 581* 592 593* 634* 634 643* 643 652 656 660 673 674* 682 683* 688 688 710* 710 716* 742 744 758 761 765 769 783 794 795* 801 802* 815 817 836 837* 842 844 855 856* 859 885* 891 892* 910 921* 921 953* 953 964* 964 968 969* 971* 1020 1021 1028 1030 1052* 1055* subtraction 000011 internal static fixed bin(17,0) initial dcl 62 set ref 347* 409 sum 000475 automatic fixed bin(17,0) dcl 51 set ref 183* 215* 216* 216 217 218* 218 219 223 305* 310* 311* 311 312 313* 313 314 319 563* 565 567* 567 572* 574 576* 576 580 663* 665 668* 668 673 680* 682 780* 785* 787 790* 790 794 799* 801 834* 836 838* 847* 849 851* 851 855 trunc_fun constant fixed bin(17,0) initial dcl 62 ref 251 unspec builtin function dcl 53 set ref 143 166 215 219* 219 223* 223 310 314* 314 319* 319 555 559 580* 580 592* 592 653 657 661 673* 673 682* 682 688* 688 760 762 766 770 784 794* 794 801* 801 836* 836 843 846 855* 855 968* 968 zero_op1 constant fixed bin(17,0) initial dcl 55 ref 533 zero_op2 constant fixed bin(17,0) initial dcl 55 ref 533 NAME DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. length builtin function dcl 53 NAMES DECLARED BY EXPLICIT CONTEXT. again 001176 constant label dcl 383 ref 392 assign 003477 constant label dcl 964 ref 991 assign_op1 001301 constant label dcl 418 ref 196 365 506 513 assign_op2 001237 constant label dcl 406 ref 360 509 510 assign_zero 003557 constant label dcl 985 ref 934 assign_zero2 003562 constant label dcl 988 ref 290 358 359 364 405 533 700 882 begin 000032 constant label dcl 84 case 000000 constant label array(4) dcl 1036 ref 1032 ceil 000421 constant label dcl 203 ref 243 253 ceil_loop 000440 constant label dcl 214 ref 222 ceil_out 000472 constant label dcl 223 ref 217 compare 001546 constant label dcl 496 ref 439 444 453 456 464 compare_equal 001411 constant label dcl 452 ref 462 compare_long_fixed_loop 001342 constant label dcl 433 ref 468 decimal_op_ 000024 constant entry external dcl 19 divide_carry_loop 002716 constant label dcl 787 ref 792 divide_est2 002536 constant label dcl 742 ref 750 divide_est3 002574 constant label dcl 758 ref 741 divide_estimate 002510 constant label dcl 727 ref 897 divide_fail 003047 constant label dcl 827 ref 813 divide_finish 003203 constant label dcl 870 ref 737 755 866 divide_magnitude 003006 constant label dcl 815 ref 822 divide_op 002377 constant label dcl 694 ref 199 divide_product 002653 constant label dcl 777 ref 829 divide_subtract 003052 constant label dcl 834 ref 812 floor 000525 constant label dcl 238 ref 208 255 loop1 001733 constant label dcl 553 ref 587 loop2 001745 constant label dcl 557 ref 589 loop_carry 002307 constant label dcl 665 ref 670 multiply_op 002054 constant label dcl 599 ref 368 neg_ck 000510 constant label dcl 228 ref 247 normalize 003307 constant label dcl 904 ref 233 303 323 414 424 597 692 888 round_loop 000640 constant label dcl 309 ref 318 round_out 000675 constant label dcl 319 ref 312 scale_fixed 003443 constant label dcl 952 ref 960 set_scale 003761 constant label dcl 1051 ref 1038 1044 setdesc 003644 constant entry internal dcl 1017 ref 118 signal 003524 constant label dcl 974 ref 610 698 928 942 signal_fixedoverflow 002074 constant label dcl 608 ref 595 signal_size 003425 constant label dcl 941 ref 397 398 881 961 skip_opnd_two 000336 constant label dcl 181 ref 148 test 001502 constant label dcl 479 ref 428 test_fractional 003567 constant entry internal dcl 258 ref 211 246 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4100 4152 4040 4110 Length 4332 4040 52 144 37 36 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME decimal_op_ 391 external procedure is an external procedure. test_fractional internal procedure shares stack frame of external procedure decimal_op_. setdesc internal procedure shares stack frame of external procedure decimal_op_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 max_desc decimal_op_ 000011 subtraction decimal_op_ 000012 multiplication decimal_op_ 000013 division decimal_op_ 000014 floor_fun decimal_op_ 000015 condition decimal_op_ 000041 error_number decimal_op_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME decimal_op_ 000100 ans decimal_op_ 000120 op1 decimal_op_ 000140 op2 decimal_op_ 000160 product decimal_op_ 000400 remainder decimal_op_ 000420 desc1 decimal_op_ 000421 desc2 decimal_op_ 000422 desc3 decimal_op_ 000424 p decimal_op_ 000426 sch decimal_op_ 000427 ch decimal_op_ 000430 ci decimal_op_ 000431 sign decimal_op_ 000432 sign1 decimal_op_ 000433 sign2 decimal_op_ 000434 big decimal_op_ 000435 carry decimal_op_ 000436 col1 decimal_op_ 000437 col2 decimal_op_ 000440 exp decimal_op_ 000441 i decimal_op_ 000442 j decimal_op_ 000443 k decimal_op_ 000444 l0 decimal_op_ 000445 l1 decimal_op_ 000446 l2 decimal_op_ 000447 l3 decimal_op_ 000450 lg3 decimal_op_ 000451 len1 decimal_op_ 000452 len2 decimal_op_ 000453 n decimal_op_ 000454 p1 decimal_op_ 000455 p2 decimal_op_ 000456 s1 decimal_op_ 000457 s2 decimal_op_ 000460 scale1 decimal_op_ 000461 scale2 decimal_op_ 000462 scale3 decimal_op_ 000463 sc3 decimal_op_ 000464 st decimal_op_ 000475 sum decimal_op_ 000476 bit3 decimal_op_ 000477 add decimal_op_ 000500 float decimal_op_ 000501 negate decimal_op_ 000502 no_round decimal_op_ 000503 product_calculated decimal_op_ 000514 signal_ufl decimal_op_ 000515 operation decimal_op_ 000516 negabs decimal_op_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. decimal_op_ plio2_signal_$s_ NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 19 000016 60 000031 84 000032 86 000035 87 000037 89 000041 90 000043 91 000047 92 000053 97 000057 98 000062 99 000067 102 000100 103 000103 104 000105 106 000116 107 000122 108 000126 109 000132 111 000133 114 000135 115 000137 117 000144 118 000147 119 000152 122 000155 124 000161 125 000165 128 000171 130 000175 135 000200 136 000204 137 000210 142 000211 143 000217 144 000222 145 000226 148 000230 151 000235 153 000241 158 000244 159 000250 160 000254 165 000255 166 000263 167 000266 168 000272 171 000274 172 000277 173 000305 174 000310 176 000316 177 000327 178 000331 179 000333 181 000336 183 000344 184 000346 185 000354 186 000357 188 000365 189 000377 190 000401 191 000403 193 000406 195 000410 196 000412 199 000413 201 000417 203 000421 206 000424 207 000426 208 000430 211 000431 213 000435 214 000440 215 000445 216 000452 217 000453 218 000456 219 000460 220 000464 221 000467 222 000471 223 000472 224 000476 225 000501 228 000510 232 000520 233 000522 236 000523 238 000525 241 000530 242 000532 243 000534 246 000535 247 000537 251 000540 253 000542 255 000545 282 000546 284 000550 285 000553 286 000555 287 000562 289 000565 290 000572 291 000573 293 000577 294 000601 296 000604 297 000606 298 000610 299 000611 300 000614 301 000621 303 000626 304 000630 305 000632 307 000633 309 000640 310 000645 311 000652 312 000654 313 000657 314 000661 315 000665 316 000670 317 000672 318 000674 319 000675 320 000701 322 000704 323 000710 326 000711 328 000713 330 000721 333 000730 335 000735 336 000740 337 000742 338 000751 341 000752 343 000754 344 000756 345 001001 346 001025 347 001051 348 001075 351 001076 352 001100 354 001102 356 001104 358 001106 359 001111 360 001113 362 001114 364 001116 365 001121 368 001122 369 001125 369 001132 372 001133 373 001140 374 001145 375 001152 376 001160 378 001166 380 001170 382 001173 383 001176 384 001200 385 001201 386 001203 387 001205 389 001207 391 001212 392 001215 394 001216 395 001217 397 001221 398 001224 401 001227 403 001231 405 001234 406 001237 408 001242 409 001253 410 001265 411 001267 412 001271 413 001273 414 001275 416 001276 418 001301 420 001304 421 001315 422 001317 423 001321 424 001323 426 001324 428 001325 429 001330 431 001332 432 001336 433 001342 435 001347 436 001354 438 001361 439 001363 441h*@`BA*@`BBP*@`BB*@`IBl*@`AC&`RKB.B.>lmB&D832395_1.dll `bp̠ S$BLI>lmFBTl*`B\BL>l*`BdBTh*@`BlB\*@`BtBd*@`B|BlP*@`IBtl*@`B@&`RKwBB>lmBD832395_3.dll `bY+$BI\>lmwBB*@`BBP*@`BB*@`BBh*@`BB>l*`Bl*`I\Bl*@`B@B&`RKyBB>lmBP832395_3.dll ` . $B0Id>lm|BB*@`B8BP*@`BB *@`BB(h*@`B B0>l*`B(l*`IdBl*@`BB&`RK{BHBH>lmB@R832395_3.dll `bp̠ $BIl>lmBnBv*@`BBfP*@`BfB~*@`BvBh*@`B~B>l*`Bl*`IlBnl*@`BB@&`RK|BB>lmBHM832395_3.dll ` k#$BIt>lm%VBB*@`BBP*@`BB*@`BBh*@`BB>l*`Bl*`ItBl*@`CZB&`RK~CC>lmB8M832395_3.map `bp̠ $CJI|>lmWC*C2*@`CRC"P*@`C"C:*@`C2CBh*@`C:CJ>l*`CBl*`I|C*l*@`CB&`RPoCbCb>lmCZcD832395_4.dll `bp̠ >$CI>lm~CC*@`CCP*@`CC*@`CCh*@`CC>l*`Cl*`ICl*@`CCZ&`RKCC>lmC< P832395_4.dll ` k#"$CI>lm1:CC*@`CCP*@`CC*@`CCh*@`CC>l*`Cl*`ICl*@`CtC&`RKCC>lmC3R832395_4.dll `bq $CdI>lm|CDCL*@`ClC<P*@`Cl*`C\l*`ICDl*@`CC&`RKC|C|>lmCt*M832395_4.dll `bq $CI>lm%VCC*@`CCP*@`CC*@`CCh*@`CC>l*`Cl*`ICl*@`B&Ct&`RKCC>lmC?M832395_4.map `bp'9$D I>lmȻDD*@`003034 825 003043 827 003047 829 003051 834 003052 836 003054 837 003060 838 003064 839 003066 841 003070 842 003075 843 003101 844 003106 845 003120 846 003122 847 003127 848 003133 849 003134 851 003135 852 003137 855 003141 856 003145 857 003151 859 003154 860 003165 862 003167 864 003171 865 003174 866 003177 868 003200 870 003203 872 003206 874 003210 875 003213 876 003215 877 003221 879 003222 880 003226 881 003234 882 003237 883 003241 885 003243 886 003250 887 003253 888 003256 891 003257 892 003270 893 003300 894 003302 895 003303 896 003305 897 003306 904 003307 907 003311 908 003320 910 003323 911 003337 912 003342 913 003344 916 003352 917 003355 918 003356 919 003360 920 003364 921 003367 922 003374 925 003377 927 003402 928 003404 930 003405 932 003407 933 003411 934 003413 936 003414 937 003420 938 003421 941 003425 942 003427 948 003430 950 003433 951 003440 952 003443 953 003446 954 003454 955 003457 956 003460 958 003461 959 003466 960 003472 961 003476 964 003477 966 003507 968 003511 969 003514 971 003517 972 003522 974 003524 983 003556 985 003557 988 003562 990 003564 991 003566 258 003567 265 003571 266 003576 269 003601 270 003604 271 003607 272 003613 273 003615 274 003617 275 003631 276 003633 278 003640 1017 003644 1018 003645 1019 003650 1020 003654 1021 003657 1022 003662 1024 003664 1025 003670 1028 003671 1029 003675 1030 003701 1031 003705 1032 003711 1036 003713 1037 003720 1038 003736 1042 003737 1043 003746 1044 003751 1048 003752 1049 003754 1051 003761 1052 003765 1055 003773 1056 004000 1057 004003 ----------------------------------------------------------- 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