COMPILATION LISTING OF SEGMENT decimal_op Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-18_1100.25_Tue_mdt Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* This procedure compiles decimal arithmetic expressions. 12* 13* Initial Version: 28 September 1973 by RAB 14* Modified: 9 March 1978 by RAB to fix 1714 (use compile_exp$save_exp instead of $save) 15* Modified: 25 April 1979 by PCK to implement 4-bit decimal */ 16 17 decimal_op: proc(node_pt,refs,atom); 18 19 dcl node_pt ptr, /* points at operator node */ 20 refs(3) ptr, /* ptrs to ref nodes of operands */ 21 atom(3) bit(1) aligned; /* ON if operand is atomic */ 22 23 dcl (op,p(128),s(128),q,r,imag(2)) ptr; 24 dcl op_code bit(9) aligned; 25 dcl (i,iop,j,max_scale,min_scale,ninst,scale(128),number,ltemp) fixed bin; 26 dcl (macro,mac) fixed bin(15); 27 dcl const char(2) aligned; 28 dcl (adjust,atomic,all_fixed) bit(1) aligned; 29 dcl mask bit(36) aligned; 30 31 dcl ( move_rounded init(439), 32 d3mac(0:5) init(438,440,446,450,456,451), 33 d2mac(4) init(442,448,454,458), 34 cplx_ops(3:4) init(465,466), 35 abs_decimal init(473), 36 abs_decimal_4bit init(737), 37 move_numeric init(438), 38 min_dec init(474), 39 max_dec init(475), 40 mod_dec init(546), 41 dvrcdec init(467)) fixed bin(15) int static; 42 43 /* Meaning of iop: 44* 0 move 45* 1 add 46* 2 sub 47* 3 mult 48* 4 div 49* 5 mult_rounded */ 50 51 dcl 1 exponent aligned, /* exponent of a float dec constant */ 52 2 pad bit(1) unal, 53 2 value fixed bin(7) unal; 54 55 dcl exponent_char char(1) based(addr(exponent)) aligned; 56 57 dcl 1 op_table(0:5) aligned int static, 58 2 macro fixed bin(15) init(541,542,0,543,544,545), 59 2 ltemp fixed bin init(1,1,0,0,80,1); 60 61 dcl (addr,bit,divide,fixed,length,max,min,mod,null,string) builtin; 62 63 dcl adjust_ref_count entry(ptr,fixed bin); 64 dcl assign_op$fix_dec_scaled entry(ptr); 65 dcl (base_man$update_base,base_man$load_var_and_lock) entry(fixed bin,ptr,fixed bin); 66 dcl c_a entry(fixed bin,fixed bin) returns(ptr); 67 dcl compare_expression entry(ptr,ptr) returns(bit(1) aligned) reducible; 68 dcl compile_exp$save_exp entry(ptr) returns(ptr); 69 dcl copy_temp entry(ptr) returns(ptr); 70 dcl declare_temporary entry(bit(36) aligned,fixed bin(31),fixed bin(15),ptr) returns(ptr); 71 dcl expmac entry(fixed bin(15),ptr); 72 dcl expmac$many_eis entry(fixed bin(15),ptr,fixed bin); 73 dcl expmac$two_eis entry(fixed bin(15),ptr,ptr); 74 dcl expmac$one_eis entry(fixed bin(15),ptr); 75 dcl generate_constant$relocatable entry(ptr,fixed bin,bit(1) aligned) returns(ptr); 76 dcl generate_constant$char_string entry(char(*) aligned,fixed bin) returns(ptr); 77 dcl get_imaginary entry(ptr) returns(ptr); 78 dcl make_n_addressable entry(ptr,fixed bin); 79 dcl prepare_operand entry(ptr,fixed bin,bit(1) aligned) returns(ptr); 80 dcl state_man$unlock entry; 81 1 1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */ 1 2 1 3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */ 1 4 /* Modified: 6 Jun 1979 by PG to add rank and byte */ 1 5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */ 1 6 /* Modified: 26 July 82 BIM wordno, segno */ 1 7 1 8 dcl ( add initial("000010001"b), /* opnd(1) <- opnd(2)+opnd(3) */ 1 9 sub initial("000010010"b), /* opnd(1) <- opnd(2)-opnd(3) */ 1 10 mult initial("000010011"b), /* opnd(1) <- opnd(2)*opnd(3) */ 1 11 div initial("000010100"b), /* opnd(1) <- opnd(2)/opnd(3) */ 1 12 negate initial("000010101"b), /* opnd(1) <- -opnd(2) */ 1 13 exp initial("000010110"b), /* opnd(1) <- opnd(2) ** opnd(3) */ 1 14 1 15 and_bits initial("000100001"b), /* opnd(1) <- opnd(2) & opnd(3) */ 1 16 or_bits initial("000100010"b), /* opnd(1) <- opnd(2)|opnd(3) */ 1 17 xor_bits initial("000100011"b), /* opnd(1) <- opnd(2) xor opnd(3) */ 1 18 not_bits initial("000100100"b), /* opnd(1) <- ^opnd(2) */ 1 19 cat_string initial("000100101"b), /* opnd(1) <- opnd(2)||opnd(3) */ 1 20 bool_fun initial("000100110"b), /* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */ 1 21 1 22 assign initial("000110001"b), /* opnd(1) <- opnd(2) */ 1 23 assign_size_ck initial("000110010"b), /* opnd(1) <- opnd(2) */ 1 24 assign_zero initial("000110011"b), /* opnd(1) <- 0 */ 1 25 copy_words initial("000110100"b), /* move opnd(2) to opnd(1) by opnd(3) words */ 1 26 copy_string initial("000110101"b), /* move opnd(2) to opnd(1) by opnd(3) units */ 1 27 make_desc initial("000110110"b), /* opnd(1) <- descriptor(opnd(2),opnd(3)) */ 1 28 assign_round initial("000110111"b), /* opnd(1) <- opnd(2) rounded */ 1 29 pack initial("000111000"b), /* opnd(1) <- encode to picture opnd(2) */ 1 30 unpack initial("000111001"b), /* opnd(1) <- decode from picture opnd(2) */ 1 31 1 32 less_than initial("001000100"b), /* opnd(1) <- opnd(2) < opnd(3) */ 1 33 greater_than initial("001000101"b), /* opnd(1) <- opnd(2) > opnd(3) */ 1 34 equal initial("001000110"b), /* opnd(1) <- opnd(2) = opnd(3) */ 1 35 not_equal initial("001000111"b), /* opnd(1) <- opnd(2) ^= opnd(3) */ 1 36 less_or_equal initial("001001000"b), /* opnd(1) <- opnd(2) <= opnd(3) */ 1 37 greater_or_equal initial("001001001"b), /* opnd(1) <- opnd(2) >= opnd(3) */ 1 38 1 39 jump initial("001010001"b), /* go to opnd(1) unconditionally */ 1 40 jump_true initial("001010010"b), /* go to opnd(1) if opnd(2) is not 0 */ 1 41 jump_false initial("001010011"b), /* go to opnd(1) if opnd(2) is all 0 */ 1 42 jump_if_lt initial("001010100"b), /* go to opnd(1) if opnd(2) < opnd(3) */ 1 43 jump_if_gt initial("001010101"b), /* go to opnd(1) if opnd(2) > opnd(3) */ 1 44 jump_if_eq initial("001010110"b), /* go to opnd(1) if opnd(2) = opnd(3) */ 1 45 jump_if_ne initial("001010111"b), /* go to opnd(1) if opnd(2) ^= opnd(3) */ 1 46 jump_if_le initial("001011000"b), /* go to opnd(1) if opnd(2) <= opnd(3) */ 1 47 jump_if_ge initial("001011001"b), /* go to opnd(1) if opnd(2) >= opnd(3) */ 1 48 1 49 std_arg_list initial("001100001"b), /* opnd(1) <- arglist(opnd(2) desclist(opnd(3))) */ 1 50 return_words initial("001100010"b), /* return aggregate opnd(1), opnd(2) is length in words */ 1 51 std_call initial("001100011"b), /* opnd(1) <- call opnd(2) with opnd(3) */ 1 52 return_bits initial("001100100"b), /* return aggregate opnd(1), opnd(2) is length in bits */ 1 53 std_entry initial("001100101"b), /* entry(opnd(1)... opnd(n)) */ 1 54 return_string initial("001100110"b), /* return string opnd(1) */ 1 55 ex_prologue initial("001100111"b), /* execute the prologue -no operands- */ 1 56 allot_auto initial("001101000"b), /* opnd(1) <- addrel(stack,opnd(2)) */ 1 57 param_ptr initial("001101001"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 1 58 param_desc_ptr initial("001101010"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 1 59 std_return initial("001101011"b), /* return -no arguments- */ 1 60 allot_ctl initial("001101100"b), /* allocate opnd(1) , length in words is opnd(2) */ 1 61 free_ctl initial("001101101"b), /* free opnd(1) */ 1 62 stop initial("001101110"b), /* stop - terminate run unit */ 1 63 1 64 mod_bit initial("001110000"b), /* opnd(1) <- mod(opnd(3),36), 1 65* opnd(2) <- opnd(3) / 36 */ 1 66 mod_byte initial("001110001"b), /* opnd(1) <- mod(opnd(3),4), 1 67* opnd(2) <- opnd(3) / 4 */ 1 68 mod_half initial("001110010"b), /* opnd(1) <- mod(opnd(3),2), 1 69* opnd(2) <- opnd(3) / 2 */ 1 70 mod_word initial("001110011"b), /* TO BE DEFINED BY BLW */ 1 71 1 72 bit_to_char initial("010000000"b), /* opnd(1) <- (opnd(2)+8)/9 */ 1 73 bit_to_word initial("010000001"b), /* opnd(1) <- (opnd(2)+35)/36 */ 1 74 char_to_word initial("010000010"b), /* opnd(1) <- (opnd(2)+3)/4 */ 1 75 half_to_word initial("010000011"b), /* opnd(1) <- (opnd(2)+1)/2 */ 1 76 word_to_mod2 initial("010000100"b), /* opnd(1) <- (opnd(2)+1)/2*2 */ 1 77 word_to_mod4 initial("010000101"b), /* opnd(1) <- (opnd(2)+3)/4*4 */ 1 78 word_to_mod8 initial("010000110"b), /* opnd(1) <- (opnd(2)+7)/8*8 */ 1 79 rel_fun initial("010000111"b), /* opnd(1) <- rel(opnd(2)) */ 1 80 baseno_fun initial("010001000"b), /* opnd(1) <- baseno(opnd(2)) */ 1 81 desc_size initial("010001001"b), /* opnd(1) <- substr(opnd(2),13,24) */ 1 82 bit_pointer initial("010001010"b), /* opnd(1) <- bit offset of opnd(2) */ 1 83 index_before_fun initial("010001011"b), /* opnd(1) <- length of before(opnd(2),opnd(3)) */ 1 84 index_after_fun initial("010001100"b), /* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */ 1 85 verify_ltrim_fun initial("010001101"b), /* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */ 1 86 verify_rtrim_fun initial("010001110"b), /* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */ 1 87 digit_to_bit initial("010001111"b), /* opnd(1) <- 9*opnd(2)/2 */ 1 88 1 89 ceil_fun initial("010010000"b), /* opnd(1) <- ceil(opnd(2)) */ 1 90 floor_fun initial("010010001"b), /* opnd(1) <- floor(opnd(2)) */ 1 91 round_fun initial("010010010"b), /* opnd(1) <- round(opnd(2)) */ 1 92 sign_fun initial("010010011"b), /* opnd(1) <- sign(opnd(2)) */ 1 93 abs_fun initial("010010100"b), /* opnd(1) <- abs(opnd(2)) */ 1 94 trunc_fun initial("010010101"b), /* opnd(1) <- trunc(opnd(2)) */ 1 95 byte_fun initial("010010110"b), /* opnd(1) <- byte(opnd(2)) */ 1 96 rank_fun initial("010010111"b), /* opnd(1) <- rank(opnd(2)) */ 1 97 index_rev_fun initial("010011000"b), /* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */ 1 98 search_rev_fun initial("010011001"b), /* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */ 1 99 verify_rev_fun initial("010011010"b), /* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */ 1 100 wordno_fun initial("010011011"b), /* opnd(1) <- wordno (opnd(2)) */ 1 101 segno_fun initial("010011100"b), /* opnd(1) <- segno (opnd(2)) */ 1 102 bitno_fun initial("010011101"b), /* opnd(1) <- bitno (opnd(2)) */ 1 103 charno_fun initial("010011110"b), /* opnd(1) <- charno (opnd(2)) */ 1 104 1 105 index_fun initial("010100000"b), /* opnd(1) <- index(opnd(2),opnd(3)) */ 1 106 off_fun initial("010100001"b), /* opnd(1) <- offset(opnd(2),opnd(3)) */ 1 107 complex_fun initial("010100010"b), /* opnd(1) <- complex(opnd(2),opnd(3)) */ 1 108 conjg_fun initial("010100011"b), /* opnd(1) <- conjg(opnd(2),opnd(3)) */ 1 109 mod_fun initial("010100100"b), /* opnd(1) <- mod(opnd(2),opnd(3)) */ 1 110 repeat_fun initial("010100101"b), /* opnd(1) <- repeat(opnd(2),opnd(3)) */ 1 111 verify_fun initial("010100110"b), /* opnd(1) <- verify(opnd(2),opnd(3)) */ 1 112 translate_fun initial("010100111"b), /* opnd(1) <- translate(opnd(2),opnd(3))*/ 1 113 real_fun initial("010101001"b), /* opnd(1) <- real(opnd(2)) */ 1 114 imag_fun initial("010101010"b), /* opnd(1) <- imag(opnd(2)) */ 1 115 length_fun initial("010101011"b), /* opnd(1) <- length(opnd(2)) */ 1 116 pl1_mod_fun initial("010101100"b), /* opnd(1) <- mod(opnd(2)) */ 1 117 search_fun initial("010101101"b), /* opnd(1) <- search(opnd(2),opnd(3)) */ 1 118 allocation_fun initial("010101110"b), /* opnd(1) <- allocation(opnd(2)) */ 1 119 reverse_fun initial("010101111"b), /* opnd(1) <- reverse(opnd(2)) */ 1 120 1 121 addr_fun initial("010110000"b), /* opnd(1) <- addr(opnd(2)) */ 1 122 addr_fun_bits initial("010110001"b), /* opnd(1) <- addr(opnd(2)) */ 1 123 ptr_fun initial("010110010"b), /* opnd(1) <- ptr(opnd(2),opnd(3)) */ 1 124 baseptr_fun initial("010110011"b), /* opnd(1) <- baseptr(opnd(2)) */ 1 125 addrel_fun initial("010110100"b), /* opnd(1) <- addrel(opnd(2),opnd(3)) */ 1 126 codeptr_fun initial("010110101"b), /* opnd(1) <- codeptr(opnd(2)) */ 1 127 environmentptr_fun initial("010110110"b), /* opnd(1) <- environmentptr(opnd(2)) */ 1 128 stackbaseptr_fun initial("010110111"b), /* opnd(1) is ptr to base of current stack */ 1 129 stackframeptr_fun initial("010111000"b), /* opnd(1) is ptr to current block's stack frame */ 1 130 setcharno_fun initial("010111001"b), /* opnd(1) <- opnd(2) with charno opnd(3) */ 1 131 addcharno_fun initial("010111010"b), /* opnd(1) <- opnd(2) with charno = charno + opnd(3) */ 1 132 setbitno_fun initial("010111011"b), /* setcharno for bitsno */ 1 133 addbitno_fun initial("010111100"b), /* addcharno for bitno */ 1 134 1 135 min_fun initial("011000000"b), /* opnd(1) <- min(opnd(1),opnd(2),...) */ 1 136 max_fun initial("011000001"b), /* opnd(1) <- max(opnd(1),opnd(2),...) */ 1 137 1 138 stack_ptr initial("011010001"b), /* opnd(1) <- stack frame ptr */ 1 139 empty_area initial("011010010"b), /* empty opnd(1), length in words is opnd(2) */ 1 140 enable_on initial("011010100"b), /* opnd(1) is the cond name 1 141* opnd(2) is the file name 1 142* opnd(3) is the block */ 1 143 revert_on initial("011010101"b), /* opnd(1) is the cond name, 1 144* opnd(2) is the file name */ 1 145 signal_on initial("011010110"b), /* opnd(1) is the cond name 1 146* opnd(2) is the file name */ 1 147 1 148 lock_fun initial("011010111"b), /* opnd(1) <- stac(opnd(2),opnd(3)) */ 1 149 stacq_fun initial("011011000"b), /* opnd(1) is result, opnd(2) is ptr to lock word, 1 150* opnd(3) is old value, (4) is new value. */ 1 151 clock_fun initial("011011001"b), /* opnd(1) is the clock time */ 1 152 vclock_fun initial("011011010"b), /* opnd(1) is the virtual clock time */ 1 153 1 154 bound_ck initial("011100000"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 1 155 range_ck initial("011100001"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 1 156 loop initial("011100010"b), /* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1, 1 157* opnd(5) is the list */ 1 158 join initial("011100011"b), /* do opnd(1), opnd(2) ... opnd(n) */ 1 159 allot_based initial("011100100"b), /* allocate opnd(2) words in opnd(3), set opnd(1) */ 1 160 free_based initial("011100101"b), /* free opnd(1) in opnd(3), length is opnd(2) words */ 1 161 1 162 r_parn initial("011110001"b), /* format op code */ 1 163 l_parn initial("011110010"b), 1 164 r_format initial("011110011"b), 1 165 c_format initial("011110100"b), 1 166 f_format initial("011110101"b), 1 167 e_format initial("011110110"b), 1 168 b_format initial("011110111"b), 1 169 a_format initial("011111000"b), 1 170 x_format initial("011111001"b), 1 171 skip_format initial("011111010"b), 1 172 column_format initial("011111011"b), 1 173 page_format initial("011111100"b), 1 174 line_format initial("011111101"b), 1 175 picture_format initial("011111110"b), 1 176 bn_format initial("011111111"b), /* bit format, length(opnd(2)), radix factor(opnd(3)) */ 1 177 1 178 get_list_trans initial("100000000"b), /* getlist(opnd(2) with desc(opnd(1))) */ 1 179 get_edit_trans initial("100000001"b), /* getedit(opnd(2) with desc(opnd(1))) */ 1 180 get_data_trans initial("100000010"b), /* getdata(opnd(1) to opnd(n)) */ 1 181 put_list_trans initial("100000011"b), /* putlist(opnd(2) with desc(opnd(1))) */ 1 182 put_edit_trans initial("100000100"b), /* putedit(opnd(2) with desc(opnd(1))) */ 1 183 put_data_trans initial("100000101"b), /* putdata(opnd(2)) with subscript-list opnd(1) */ 1 184 terminate_trans initial("100000110"b), /* terminate stream transmission */ 1 185 stream_prep initial("100000111"b), /* initiate stream transmission */ 1 186 record_io initial("100001000"b), /* perform record io operation */ 1 187 fortran_read initial("100001001"b), /* A complete read statement */ 1 188 fortran_write initial("100001010"b), /* A complete write statement */ 1 189 ftn_file_manip initial("100001011"b), /* endfile,backspace,rewind,etc. */ 1 190 ftn_trans_loop initial("100001100"b), /* An implied do in i/o list */ 1 191 put_control initial("100001101"b), /* put control opnd(1) opnd(2) times */ 1 192 put_field initial("100001110"b), /* putlist(opnd(2)) of length(opnd(1)) */ 1 193 put_field_chk initial("100001111"b), /* putlist(op(2)) of len(op(1)) check char index(op(3)) */ 1 194 1 195 /* These operators are produced by the parse but are not used as input to the code generator. */ 1 196 /* They are processed by the semantic translator. */ 1 197 1 198 return_value initial("100010010"b), /* return(opnd(1)) */ 1 199 allot_var initial("100010011"b), /* allot opnd(1) in opnd(2) */ 1 200 free_var initial("100010100"b), /* free opnd(1) out of opnd(2) */ 1 201 get_file initial("100010101"b), /* opnd(1) is filename,opnd(2) is copy */ 1 202 /* opnd(3) is skip, opnd(4) is list */ 1 203 get_string initial("100010110"b), /* opnd(1) is string,opnd(2) is list */ 1 204 put_file initial("100010111"b), /* opnd(1) is filename,opnd(2) is page */ 1 205 /* opnd(3) is skip,opnd(4) is line */ 1 206 put_string initial("100011000"b), /* opnd(1) is string,opnd(2) is list */ 1 207 open_file initial("100011001"b), 1 208 close_file initial("100011010"b), 1 209 read_file initial("100011011"b), 1 210 write_file initial("100011100"b), 1 211 locate_file initial("100011101"b), 1 212 do_fun initial("100011110"b), /* opnd(1) is join of a list */ 1 213 /* opnd(2) is control variable ref */ 1 214 /* opnd(3) is specification operator */ 1 215 do_spec initial("100011111"b), /* opnd(1) to opnd(2) by opnd(3) */ 1 216 /* repeat opnd(4) while opnd(5) */ 1 217 /* opnd(6) is next specification */ 1 218 1 219 rewrite_file initial("100100000"b), 1 220 delete_file initial("100100001"b), 1 221 unlock_file initial("100100010"b), 1 222 lock_file initial("100100011"b), 1 223 refer initial("100100101"b), /* opnd(1) refer(opnd(2)) */ 1 224 prefix_plus initial("100100110"b), /* opnd(1) <- +opnd(2) */ 1 225 nop initial("100100111"b), /* no-op */ 1 226 assign_by_name initial("100101000"b), /* opnd(1) <- opnd(2),by name */ 1 227 1 228 /* These operators are produced by the semantic translator in processing the math 1 229* builtin functions and are used as input to the code generator */ 1 230 1 231 sqrt_fun initial("100110000"b), /* opnd(1) <- sqrt(opnd(2)) */ 1 232 sin_fun initial("100110001"b), /* opnd(1) <- sin(opnd(2)) */ 1 233 sind_fun initial("100110010"b), /* opnd(1) <- sind(opnd(2)) */ 1 234 cos_fun initial("100110011"b), /* opnd(1) <- cos(opnd(2)) */ 1 235 cosd_fun initial("100110100"b), /* opnd(1) <- cosd(opnd(2)) */ 1 236 tan_fun initial("100110101"b), /* opnd(1) <- tan(opnd(2)) */ 1 237 tand_fun initial("100110110"b), /* opnd(1) <- tand(opnd(2)) */ 1 238 asin_fun initial("100110111"b), /* opnd(1) <- asin(opnd(2)) */ 1 239 asind_fun initial("100111000"b), /* opnd(1) <- asind(opnd(2)) */ 1 240 acos_fun initial("100111001"b), /* opnd(1) <- acos(opnd(2)) */ 1 241 acosd_fun initial("100111010"b), /* opnd(1) <- acosd(opnd(2)) */ 1 242 atan_fun initial("100111011"b), /* opnd(1) <- atan(opnd(2)[,opnd(3)]) */ 1 243 atand_fun initial("100111100"b), /* opnd(1) <- atand(opnd(2)[,opnd(3)]) */ 1 244 log2_fun initial("100111101"b), /* opnd(1) <- log2(opnd(2)) */ 1 245 log_fun initial("100111110"b), /* opnd(1) <- log(opnd(2)) */ 1 246 log10_fun initial("100111111"b), /* opnd(1) <- log10(opnd(2)) */ 1 247 1 248 exp_fun initial("101000000"b)) /* opnd(1) <- exp(opnd(2)) */ 1 249 1 250 bit(9) aligned internal static options(constant); 1 251 1 252 /* END INCLUDE FILE ... op_codes.incl.pl1 */ 82 2 1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */ 2 2 2 3 /* Modified: 2 Apr 1980 by PCK to add max_number_of_operands */ 2 4 2 5 /* format: style3 */ 2 6 dcl 1 operator based aligned, 2 7 2 node_type bit (9) unaligned, 2 8 2 op_code bit (9) unaligned, 2 9 2 shared bit (1) unaligned, 2 10 2 processed bit (1) unaligned, 2 11 2 optimized bit (1) unaligned, 2 12 2 number fixed (14) unaligned, 2 13 2 operand dimension (n refer (operator.number)) ptr unaligned; 2 14 2 15 dcl max_number_of_operands 2 16 fixed bin (15) int static options (constant) initial (32767); 2 17 2 18 /* END INCLUDE FILE ... operator.incl.pl1 */ 83 3 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 3 2 3 3 dcl 1 symbol based aligned, 3 4 2 node_type bit(9) unal, 3 5 2 source_id structure unal, 3 6 3 file_number bit(8), 3 7 3 line_number bit(14), 3 8 3 statement_number bit(5), 3 9 2 location fixed(18) unal unsigned, 3 10 2 allocated bit(1) unal, 3 11 2 dcl_type bit(3) unal, 3 12 2 reserved bit(6) unal, 3 13 2 pix unal, 3 14 3 pic_fixed bit(1) unal, 3 15 3 pic_float bit(1) unal, 3 16 3 pic_char bit(1) unal, 3 17 3 pic_scale fixed(7) unal, 3 18 3 pic_size fixed(7) unal, 3 19 2 level fixed(8) unal, 3 20 2 boundary fixed(3) unal, 3 21 2 size_units fixed(3) unal, 3 22 2 scale fixed(7) unal, 3 23 2 runtime bit(18) unal, 3 24 2 runtime_offset bit(18) unal, 3 25 2 block_node ptr unal, 3 26 2 token ptr unal, 3 27 2 next ptr unal, 3 28 2 multi_use ptr unal, 3 29 2 cross_references ptr unal, 3 30 2 initial ptr unal, 3 31 2 array ptr unal, 3 32 2 descriptor ptr unal, 3 33 2 equivalence ptr unal, 3 34 2 reference ptr unal, 3 35 2 general ptr unal, 3 36 2 father ptr unal, 3 37 2 brother ptr unal, 3 38 2 son ptr unal, 3 39 2 word_size ptr unal, 3 40 2 bit_size ptr unal, 3 41 2 dcl_size ptr unal, 3 42 2 symtab_size ptr unal, 3 43 2 c_word_size fixed(24), 3 44 2 c_bit_size fixed(24), 3 45 2 c_dcl_size fixed(24), 3 46 3 47 2 attributes structure aligned, 3 48 3 data_type structure unal, 3 49 4 structure bit(1) , 3 50 4 fixed bit(1), 3 51 4 float bit(1), 3 52 4 bit bit(1), 3 53 4 char bit(1), 3 54 4 ptr bit(1), 3 55 4 offset bit(1), 3 56 4 area bit(1), 3 57 4 label bit(1), 3 58 4 entry bit(1), 3 59 4 file bit(1), 3 60 4 arg_descriptor bit(1), 3 61 4 storage_block bit(1), 3 62 4 explicit_packed bit(1), /* options(packed) */ 3 63 4 condition bit(1), 3 64 4 format bit(1), 3 65 4 builtin bit(1), 3 66 4 generic bit(1), 3 67 4 picture bit(1), 3 68 3 69 3 misc_attributes structure unal, 3 70 4 dimensioned bit(1), 3 71 4 initialed bit(1), 3 72 4 aligned bit(1), 3 73 4 unaligned bit(1), 3 74 4 signed bit(1), 3 75 4 unsigned bit(1), 3 76 4 precision bit(1), 3 77 4 varying bit(1), 3 78 4 local bit(1), 3 79 4 decimal bit(1), 3 80 4 binary bit(1), 3 81 4 real bit(1), 3 82 4 complex bit(1), 3 83 4 variable bit(1), 3 84 4 reducible bit(1), 3 85 4 irreducible bit(1), 3 86 4 returns bit(1), 3 87 4 position bit(1), 3 88 4 internal bit(1), 3 89 4 external bit(1), 3 90 4 like bit(1), 3 91 4 member bit(1), 3 92 4 non_varying bit(1), 3 93 4 options bit(1), 3 94 4 variable_arg_list bit(1), /* options(variable) */ 3 95 4 alloc_in_text bit(1), /* options(constant) */ 3 96 3 97 3 storage_class structure unal, 3 98 4 auto bit(1), 3 99 4 based bit(1), 3 100 4 static bit(1), 3 101 4 controlled bit(1), 3 102 4 defined bit(1), 3 103 4 parameter bit(1), 3 104 4 param_desc bit(1), 3 105 4 constant bit(1), 3 106 4 temporary bit(1), 3 107 4 return_value bit(1), 3 108 3 109 3 file_attributes structure unal, 3 110 4 print bit(1), 3 111 4 input bit(1), 3 112 4 output bit(1), 3 113 4 update bit(1), 3 114 4 stream bit(1), 3 115 4 reserved_1 bit(1), 3 116 4 record bit(1), 3 117 4 sequential bit(1), 3 118 4 direct bit(1), 3 119 4 interactive bit(1), /* env(interactive) */ 3 120 4 reserved_2 bit(1), 3 121 4 reserved_3 bit(1), 3 122 4 stringvalue bit(1), /* env(stringvalue) */ 3 123 4 keyed bit(1), 3 124 4 reserved_4 bit(1), 3 125 4 environment bit(1), 3 126 3 127 3 compiler_developed structure unal, 3 128 4 aliasable bit(1), 3 129 4 packed bit(1), 3 130 4 passed_as_arg bit(1), 3 131 4 allocate bit(1), 3 132 4 set bit(1), 3 133 4 exp_extents bit(1), 3 134 4 refer_extents bit(1), 3 135 4 star_extents bit(1), 3 136 4 isub bit(1), 3 137 4 put_in_symtab bit(1), 3 138 4 contiguous bit(1), 3 139 4 put_data bit(1), 3 140 4 overlayed bit(1), 3 141 4 error bit(1), 3 142 4 symtab_processed bit(1), 3 143 4 overlayed_by_builtin bit(1), 3 144 4 defaulted bit(1), 3 145 4 connected bit(1); 3 146 3 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 84 4 1 /* BEGIN INCLUDE FILE ... cg_reference.incl.pl1 */ 4 2 4 3 dcl 1 reference based aligned, 4 4 2 node_type bit(9) unaligned, 4 5 2 array_ref bit(1) unaligned, 4 6 2 varying_ref bit(1) unaligned, 4 7 2 shared bit(1) unaligned, 4 8 2 put_data_sw bit(1) unaligned, 4 9 2 processed bit(1) unaligned, 4 10 2 units fixed(3) unaligned, 4 11 2 ref_count fixed(17) unaligned, 4 12 2 c_offset fixed(24), 4 13 2 c_length fixed(24), 4 14 2 symbol ptr unaligned, 4 15 2 qualifier ptr unaligned, 4 16 2 offset ptr unaligned, 4 17 2 length ptr unaligned, 4 18 /* these fields are used by the 645 code generator */ 4 19 2 c_f_offset fixed bin(6), 4 20 2 address structure unaligned, 4 21 3 base bit(3), 4 22 3 offset bit(15), 4 23 3 op bit(9), 4 24 3 no_address bit(1), 4 25 3 inhibit bit(1), 4 26 3 ext_base bit(1), 4 27 3 tag bit(6), 4 28 2 info structure unaligned, 4 29 3 address_in structure, 4 30 4 b dimension(0:7) bit(1), 4 31 4 storage bit(1), 4 32 3 value_in structure, 4 33 4 a bit(1), 4 34 4 q bit(1), 4 35 4 aq bit(1), 4 36 4 string_aq bit(1), 4 37 4 complex_aq bit(1), 4 38 4 decimal_aq bit(1), 4 39 4 b dimension(0:7) bit(1), 4 40 4 storage bit(1), 4 41 4 indicators bit(1), 4 42 4 x dimension(0:7) bit(1), 4 43 3 other structure, 4 44 4 big_offset bit(1), 4 45 4 big_length bit(1), 4 46 4 modword_in_offset bit(1), 4 47 2 data_type fixed(5) unaligned, 4 48 2 bits structure unaligned, 4 49 3 padded_ref bit(1), 4 50 3 aligned_ref bit(1), 4 51 3 long_ref bit(1), 4 52 3 forward_ref bit(1), 4 53 3 ic_ref bit(1), 4 54 3 temp_ref bit(1), 4 55 3 defined_ref bit(1), 4 56 3 evaluated bit(1), 4 57 3 allocate bit(1), 4 58 3 allocated bit(1), 4 59 3 aliasable bit(1), 4 60 3 even bit(1), 4 61 3 perm_address bit(1), 4 62 3 aggregate bit(1), 4 63 3 hit_zero bit(1), 4 64 3 dont_save bit(1), 4 65 3 fo_in_qual bit(1), 4 66 3 hard_to_load bit(1), 4 67 2 relocation bit(12) unaligned, 4 68 2 more_bits structure unaligned, 4 69 3 substr bit(1), 4 70 3 padded_for_store_ref bit(1), 4 71 3 aligned_for_store_ref bit(1), 4 72 3 mbz bit(15), 4 73 2 store_ins bit(18) unaligned; 4 74 4 75 /* END INCLUDE FILE ... cg_reference.incl.pl1 */ 85 5 1 dcl ( real_fix_bin_1 init(1), 5 2 real_fix_bin_2 init(2), 5 3 real_flt_bin_1 init(3), 5 4 real_flt_bin_2 init(4), 5 5 complex_fix_bin_1 init(5), 5 6 complex_fix_bin_2 init(6), 5 7 complex_flt_bin_1 init(7), 5 8 complex_flt_bin_2 init(8), 5 9 real_fix_dec init(9), 5 10 real_flt_dec init(10), 5 11 complex_fix_dec init(11), 5 12 complex_flt_dec init(12), 5 13 char_string init(13), 5 14 bit_string init(14), 5 15 label_constant init(15), 5 16 local_label_variable init(16), 5 17 label_variable init(17), 5 18 entry_variable init(18), 5 19 ext_entry_in init(19), 5 20 ext_entry_out init(20), 5 21 int_entry init(21), 5 22 int_entry_other init(22), 5 23 unpacked_ptr init(23), 5 24 packed_ptr init(24)) fixed bin(15) int static options(constant); 86 6 1 /* BEGIN INCLUDE FILE ... cgsystem.incl.pl1 */ 6 2 6 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 6 4 6 5 dcl ( bits_per_char init(9), 6 6 bits_per_half init(18), 6 7 bits_per_word init(36), 6 8 bits_per_two_words init(72), 6 9 bits_per_four_words init(144), 6 10 bits_per_words(2) init(36,72), 6 11 packed_digits_per_char init(2), 6 12 chars_per_word init(4), 6 13 packed_digits_per_word init(8), 6 14 6 15 break_even_bits init(216), 6 16 break_even_words init(6), 6 17 6 18 label_size init(4), 6 19 6 20 convert_size(13:14) init(9,1), 6 21 max_offset(13:14) init(27,35), 6 22 max_short_size(13:14) init(8,72), 6 23 6 24 units_per_word(0:5) init(1,36,8,4,2,1), 6 25 6 26 max_dec_scale init(32), 6 27 min_dec_scale init(-31), 6 28 max_p_xreg init(18), 6 29 max_p_fix_bin_1 init(35), 6 30 max_p_flt_bin_1 init(27), 6 31 max_p_fix_dec init(59), 6 32 max_length_p init(24), 6 33 default_fix_bin_p init(17)) fixed bin(8) int static options(constant); 6 34 6 35 dcl (convert_offset(0:5) init(36,1,4.5,9,18,36), 6 36 bits_per_packed_digit init(4.5)) fixed bin(8,1) int static options(constant); 6 37 6 38 dcl max_index_register_value init(262143) fixed bin(31) int static options(constant); 6 39 6 40 /* END INCLUDE FILE ... cgsystem.incl.pl1 */ 6 41 87 7 1 /* BEGIN INCLUDE FILE ... mask.incl.pl1 */ 7 2 7 3 dcl ( structure_mask init("100000000000000000000000000000000000"b), 7 4 fixed_mask init("010000000000000000000000000000000000"b), 7 5 float_mask init("001000000000000000000000000000000000"b), 7 6 bit_mask init("000100000000000000000000000000000000"b), 7 7 char_mask init("000010000000000000000000000000000000"b), 7 8 ptr_mask init("000001000000000000000000000000000000"b), 7 9 offset_mask init("000000100000000000000000000000000000"b), 7 10 area_mask init("000000010000000000000000000000000000"b), 7 11 label_mask init("000000001000000000000000000000000000"b), 7 12 entry_mask init("000000000100000000000000000000000000"b), 7 13 file_mask init("000000000010000000000000000000000000"b), 7 14 arg_descriptor_mask init("000000000001000000000000000000000000"b), 7 15 storage_block_mask init("000000000000100000000000000000000000"b), 7 16 lock_mask init("000000000000010000000000000000000000"b), 7 17 condition_mask init("000000000000001000000000000000000000"b), 7 18 format_mask init("000000000000000100000000000000000000"b), 7 19 builtin_mask init("000000000000000010000000000000000000"b), 7 20 generic_mask init("000000000000000001000000000000000000"b), 7 21 picture_mask init("000000000000000000100000000000000000"b), 7 22 dimensioned_mask init("000000000000000000010000000000000000"b), 7 23 initialed_mask init("000000000000000000001000000000000000"b), 7 24 aligned_mask init("000000000000000000000100000000000000"b), 7 25 unaligned_mask init("000000000000000000000010000000000000"b), 7 26 signed_mask init("000000000000000000000001000000000000"b), 7 27 unsigned_mask init("000000000000000000000000100000000000"b), 7 28 precision_mask init("000000000000000000000000010000000000"b), 7 29 varying_mask init("000000000000000000000000001000000000"b), 7 30 local_mask init("000000000000000000000000000100000000"b), 7 31 decimal_mask init("000000000000000000000000000010000000"b), 7 32 binary_mask init("000000000000000000000000000001000000"b), 7 33 real_mask init("000000000000000000000000000000100000"b), 7 34 complex_mask init("000000000000000000000000000000010000"b), 7 35 variable_mask init("000000000000000000000000000000001000"b), 7 36 reducible_mask init("000000000000000000000000000000000100"b), 7 37 irreducible_mask init("000000000000000000000000000000000010"b), 7 38 returns_mask init("000000000000000000000000000000000001"b)) bit(36) aligned int static 7 39 options(constant); 7 40 7 41 dcl ( arithmetic_mask init("011000000000000000000000000011110000"b), 7 42 computational_mask init("011110000000000000100000000011110000"b), 7 43 fixed_binary_real_mask init("010000000000000000000000000001100000"b), 7 44 fixed_decimal_real_mask init("010000000000000000000000000010100000"b), 7 45 float_decimal_real_mask init("001000000000000000000000000010100000"b), 7 46 fixed_decimal_complex_mask init("010000000000000000000000000010010000"b), 7 47 float_decimal_complex_mask init("001000000000000000000000000010010000"b), 7 48 string_mask init("000110000000000000000000000000000000"b), 7 49 undesirable_mask init("111111111111111111100111110111110111"b), 7 50 convert_mask init("011111111111111111100111110111111110"b), 7 51 declare_constant_mask init("111111111111111111100000000011110000"b) 7 52 ) bit(36) aligned int static 7 53 options(constant); 7 54 7 55 /* END INCLUDE FILE ... mask.incl.pl1 */ 88 8 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 8 2 8 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 8 4 8 5 dcl ( block_node initial("000000001"b), 8 6 statement_node initial("000000010"b), 8 7 operator_node initial("000000011"b), 8 8 reference_node initial("000000100"b), 8 9 token_node initial("000000101"b), 8 10 symbol_node initial("000000110"b), 8 11 context_node initial("000000111"b), 8 12 array_node initial("000001000"b), 8 13 bound_node initial("000001001"b), 8 14 format_value_node initial("000001010"b), 8 15 list_node initial("000001011"b), 8 16 default_node initial("000001100"b), 8 17 machine_state_node initial("000001101"b), 8 18 source_node initial("000001110"b), 8 19 label_node initial("000001111"b), 8 20 cross_reference_node initial("000010000"b), 8 21 sf_par_node initial("000010001"b), 8 22 temporary_node initial("000010010"b), 8 23 label_array_element_node initial("000010011"b), 8 24 by_name_agg_node initial("000010100"b)) 8 25 bit(9) internal static aligned options(constant); 8 26 8 27 dcl 1 node based aligned, 8 28 2 type unal bit(9), 8 29 2 source_id unal structure, 8 30 3 file_number bit(8), 8 31 3 line_number bit(14), 8 32 3 statement_number bit(5); 8 33 8 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 89 9 1 /* BEGIN INCLUDE FILE ... machine_state.incl.pl1 */ 9 2 9 3 dcl cg_static_$m_s_p ptr ext static, 9 4 m_s_p ptr init(cg_static_$m_s_p); 9 5 9 6 dcl 1 machine_state aligned based(m_s_p), 9 7 2 node_type bit(9), 9 8 2 indicators fixed bin, 9 9 2 next ptr unal, 9 10 2 a_reg, 9 11 3 variable(10) ptr unal, 9 12 3 number fixed bin(17), 9 13 3 size fixed bin(8), 9 14 3 length fixed bin(8), 9 15 3 offset fixed bin(8), 9 16 3 constant fixed bin(24), 9 17 3 changed fixed bin(18), 9 18 3 instruction bit(36), 9 19 3 locked bit(1) aligned, 9 20 3 number_h_o fixed bin, 9 21 3 has_offset(3) ptr unal, 9 22 2 q_reg, 9 23 3 variable(10) ptr unal, 9 24 3 number fixed bin(17), 9 25 3 size fixed bin(8), 9 26 3 length fixed bin(8), 9 27 3 offset fixed bin(8), 9 28 3 constant fixed bin(24), 9 29 3 changed fixed bin(18), 9 30 3 instruction bit(36), 9 31 3 locked bit(1) aligned, 9 32 3 number_h_o fixed bin, 9 33 3 has_offset(3) ptr unal, 9 34 2 string_reg, 9 35 3 variable ptr unal, 9 36 3 size fixed bin(8), 9 37 3 offset fixed bin(8), 9 38 2 complex_reg, 9 39 3 variable ptr unal, 9 40 3 size fixed bin(8), 9 41 3 scale fixed bin(8), 9 42 2 decimal_reg, 9 43 3 variable ptr unal, 9 44 3 size fixed bin(8), 9 45 3 scale fixed bin(8), 9 46 2 index_regs(0:7), 9 47 3 variable ptr unal, 9 48 3 constant fixed bin, 9 49 3 type fixed bin(8), 9 50 3 used fixed bin(18), 9 51 3 changed fixed bin(18), 9 52 3 instruction bit(36), 9 53 3 filler fixed bin, 9 54 2 base_regs(0:7), 9 55 3 variable ptr unal, 9 56 3 constant fixed bin, 9 57 3 type fixed bin(8), 9 58 3 pad (12) fixed bin, /* future...room to make 5 element array for variable, constant, type */ 9 59 3 number fixed bin (17), /* future...number of valid elements in array */ 9 60 3 used fixed bin(18), 9 61 3 changed fixed bin(18), 9 62 3 instruction bit(36), 9 63 3 locked fixed bin(2), 9 64 2 indicators_ref(2:3) ptr unal; 9 65 9 66 /* Permissible values for machine_state.indicators. */ 9 67 9 68 dcl ( ind_known_refs init (-2), /* set by comparison of known, nonzero, references */ 9 69 ind_invalid init (-1), 9 70 ind_string_aq init (0), /* logical value in storage */ 9 71 ind_logical init (1), /* logical value in A or AQ */ 9 72 ind_arithmetic init (2), /* arith value in Q, AQ, or EAQ */ 9 73 ind_x (0:7) init (6, 7, 8, 9, 10, 11, 12, 13), 9 74 ind_decimal_reg init (14) 9 75 ) fixed bin internal static options (constant); 9 76 9 77 /* END INCLUDE FILE ... machine_state.incl.pl1 */ 90 91 92 /* Initialize and compile any non-atomic operands */ 93 94 ninst = 1; 95 op = node_pt; 96 op_code = op -> operator.op_code; 97 all_fixed = "1"b; 98 number = op -> operator.number; 99 100 do i = 1 to number; 101 if ^ atom(i) 102 then p(i) = compile_exp$save_exp((op -> operand(i))); 103 else p(i) = refs(i); 104 s(i) = p(i) -> reference.symbol; 105 scale(i) = s(i) -> symbol.scale; 106 all_fixed = all_fixed & s(i) -> symbol.fixed; 107 end; 108 109 adjust = ^ (p(1) -> reference.temp_ref | p(1) -> reference.shared); 110 111 /* Handle negate case */ 112 113 if op_code = negate 114 then do; 115 if s(1) -> symbol.complex 116 then do; 117 ninst = 2; 118 119 /* We will multiply by -1 */ 120 121 use_mult: iop = 3; 122 const = "-1"; 123 end; 124 else do; 125 if ^ p(1) -> reference.temp_ref 126 then if compare_expression(p(1),p(2)) 127 then go to use_mult; 128 129 /* we will subtract from zero */ 130 131 iop = 2; 132 const = "+0"; 133 end; 134 135 p(3) = p(2); 136 s(3) = s(2); 137 p(2) = generate_constant$char_string(const,2); 138 p(2) -> reference.data_type = real_fix_dec; 139 s(2) = p(2) -> reference.symbol; 140 141 call issue; 142 return; 143 end; 144 145 146 /* Split off the builtins */ 147 148 if op_code > div then go to builtin; 149 150 /* Now, we handle the other arithmetic cases. Most code in the external procedure 151* past here deals with ensuring that the scales of the operands fall within the 152* limits of the 6180's EIS descriptors. */ 153 154 if s(1) -> symbol.complex then ninst = 2; 155 156 iop = fixed(op_code,9) - 16; /* encode operation */ 157 158 if iop <= 2 159 then do; 160 161 max_scale = max(scale(1),scale(2),scale(3)); 162 min_scale = min(scale(1),scale(2),scale(3)); 163 164 if max_scale <= max_dec_scale & min_scale >= min_dec_scale 165 then call issue; 166 167 else if max_scale - min_scale <= max_dec_scale - min_dec_scale & all_fixed 168 then do; 169 do i = 1 to 3 while(scale(i) ^= max_scale); 170 end; 171 172 do j = 1 to 3; 173 s(j) -> symbol.scale = max_dec_scale - scale(i) + scale(j); 174 end; 175 176 call issue; 177 178 do j = 1 to 3; 179 s(j) -> symbol.scale = scale(j); 180 end; 181 end; 182 183 else do; 184 call fix_scales; 185 call issue; 186 end; 187 188 return; 189 end; 190 191 call fix_scales; 192 193 if s(1) -> symbol.complex 194 then if s(2) -> symbol.complex | iop = 4 195 then if s(3) -> symbol.complex 196 then do; 197 ltemp = 48; 198 macro = cplx_ops(iop); 199 if ^ s(2) -> symbol.complex 200 then macro = dvrcdec; 201 call gen_call; 202 return; 203 end; 204 205 if iop = 4 206 then if s(1) -> symbol.float 207 then do; 208 209 /* Due to a hardware deficiency, floating point division must be done into 210* a temporary whose precision is 2 greater than that of the target's, and 211* the result is then moved into the target */ 212 213 q = p(1); 214 p(1) = decimal_op$get_float_temp(s(1) -> symbol.c_dcl_size + 2,(s(1) -> symbol.complex)); 215 216 call issue; 217 218 p(2) = p(1); 219 p(1) = q; 220 s(2) = p(2) -> reference.symbol; 221 iop = 0; 222 223 call issue; 224 return; 225 end; 226 227 call issue; 228 return; 229 230 231 232 /* Section to do decimal builtins */ 233 234 builtin: 235 if op_code = abs_fun 236 then if s(2) -> symbol.real 237 then do; 238 iop = 0; 239 if adjust 240 then p(1) -> reference.ref_count = p(1) -> reference.ref_count + 1; 241 242 call issue; 243 244 if s(1) -> symbol.unaligned 245 then mac = abs_decimal_4bit; 246 else mac = abs_decimal; 247 248 call expmac$one_eis(mac,p(1)); 249 250 machine_state.indicators = min(machine_state.indicators,-1); 251 return; 252 end; 253 254 255 if op_code = round_fun 256 then do; 257 258 /* NOTE: the following code assumes that the target has the proper pre- 259* cision and scale */ 260 261 scale(3) = 0; 262 call fix_scales; 263 264 if s(1) -> symbol.complex then ninst = 2; 265 266 if s(1) -> symbol.float 267 then iop = 0; 268 else do; 269 270 /* generate a multiply rounded by 10**K */ 271 272 iop = 5; 273 s(1) -> symbol.scale = 0; 274 s(2) -> symbol.scale = 0; 275 p(3) = p(2); 276 s(3) = s(2); 277 exponent.pad = "0"b; 278 exponent.value = scale(1) - scale(2); 279 p(2) = generate_constant$char_string("+1" || exponent_char,3); 280 s(2) = p(2) -> reference.symbol; 281 end; 282 283 call issue; 284 285 if s(1) -> symbol.fixed 286 then do; 287 s(1) -> symbol.scale = scale(1); 288 s(3) -> symbol.scale = scale(2); 289 end; 290 return; 291 end; 292 293 if op_code = min_fun | op_code = max_fun 294 then do; 295 call fix_scales; 296 if op_code = min_fun 297 then macro = min_dec; 298 else macro = max_dec; 299 mac = move_numeric + fixed(s(1) -> symbol.float,1); 300 301 if adjust 302 then p(1) -> reference.ref_count = p(1) -> reference.ref_count + 1; 303 304 call expmac$two_eis(mac,p(1),p(2)); 305 306 do i = 3 to number; 307 if ^ p(i) -> reference.shared 308 then p(i) -> reference.ref_count = p(i) -> reference.ref_count + 1; 309 if adjust 310 then p(1) -> reference.ref_count = p(1) -> reference.ref_count + 2; 311 call expmac$two_eis(macro,p(1),p(i)); 312 call expmac$two_eis(mac,p(1),p(i)); 313 end; 314 315 if adjust 316 then call adjust_ref_count(p(1),-1); 317 refs(2) = p(2); 318 return; 319 end; 320 321 if op_code = trunc_fun 322 then do; 323 call fix_scales; 324 if s(1) -> symbol.fixed 325 then do; 326 call expmac$two_eis((move_numeric),p(1),p(2)); 327 return; 328 end; 329 end; 330 331 if op_code = complex_fun 332 then do; 333 imag(1) = get_imaginary(p(1)); 334 macro = move_numeric + fixed(s(1) -> symbol.float,1); 335 call expmac$two_eis(macro,p(1),p(2)); 336 call expmac$two_eis(macro,imag(1),p(3)); 337 return; 338 end; 339 340 if op_code = real_fun | op_code = imag_fun 341 then do; 342 if op_code = real_fun 343 then q = p(2); 344 else do; 345 q = get_imaginary(p(2)); 346 if ^ p(2) -> reference.shared 347 then call adjust_ref_count(p(2),-1); 348 end; 349 350 call expmac$two_eis(move_numeric + fixed(s(1) -> symbol.float,1),p(1),q); 351 352 return; 353 end; 354 355 if op_code = conjg_fun 356 then do; 357 imag(1) = get_imaginary(p(1)); 358 imag(2) = get_imaginary(p(2)); 359 360 iop = 0; 361 call issue; 362 363 p(1) = imag(1); 364 p(2) = imag(2); 365 go to use_mult; 366 end; 367 368 /* Anything that reaches here results in calls to pl1_operators_ */ 369 370 if op_code ^= sign_fun 371 then if op_code ^= abs_fun 372 then call fix_scales; 373 else; 374 else do; 375 number = 1; 376 p(1) = p(2); 377 s(1) = s(2); 378 scale(1) = scale(2); 379 end; 380 381 if op_code = pl1_mod_fun 382 then do; 383 384 /* dec_ops_ will get stack extension */ 385 386 ltemp = 0; 387 macro = mod_dec; 388 end; 389 else do; 390 iop = fixed(op_code,9) - 144; 391 macro = op_table(iop).macro; 392 ltemp = op_table(iop).ltemp; 393 if ltemp = 1 394 then ltemp = divide(p(2) -> reference.c_length + 3,chars_per_word,17,0); 395 end; 396 397 call gen_call; 398 return; 399 400 401 402 403 404 /* decimal_op$get_float_temp returns a floating decimal temporary of precision prec which is 405* complex is complex is ON */ 406 407 decimal_op$get_float_temp: entry(prec,complex) returns(ptr); 408 409 dcl prec fixed bin(24); 410 dcl complex bit(1) aligned; 411 412 if complex 413 then mask = complex_mask; 414 else mask = real_mask; 415 416 r = declare_temporary(mask | float_mask | decimal_mask | aligned_mask,(prec), 417 0,null); 418 r = copy_temp(r); 419 r = prepare_operand(r,1,atomic); 420 return(r); 421 422 423 424 /* decimal_op$change_target is called when the target of a decimal arithmetic 425* operation has a scale outside of hardware limits to determine if the target 426* should be converted to floating point */ 427 428 decimal_op$change_target: entry(node_pt) returns(bit(1) aligned); 429 430 op = node_pt; 431 op_code = op -> operator.op_code; 432 433 if op_code = add | op_code = sub 434 then do; 435 scale(1) = op -> operand(1) -> reference.symbol -> symbol.scale; 436 do i = 2 to 3; 437 if op -> operand(i) -> node.type = reference_node 438 then p(i) = op -> operand(i); 439 else p(i) = prepare_operand((op -> operand(i)),1,atomic); 440 if p(i) -> reference.symbol -> symbol.float 441 then return("1"b); 442 scale(i) = p(i) -> reference.symbol -> symbol.scale; 443 end; 444 445 if max(scale(1),scale(2),scale(3)) - min(scale(1),scale(2),scale(3)) 446 <= max_dec_scale - min_dec_scale 447 then return("0"b); 448 end; 449 450 return("1"b); 451 452 453 454 issue: proc; 455 456 dcl arg(2,3) ptr; 457 dcl (i,nrands) fixed bin; 458 dcl macro fixed bin(15); 459 dcl (use_move,switch_rands) bit(1) aligned; 460 461 /* This routine does most of the work of issuing a decimal macro. It must handle the cases 462* concerning complex operands and cases in which the target variable is the same as one 463* of the sources */ 464 465 use_move = "0"b; 466 467 if iop ^= 0 468 then nrands = 3; 469 else nrands = 2; 470 macro = d3mac(iop); 471 472 if ^ p(1) -> reference.temp_ref 473 then do i = 2 to mod(iop,2) + 2; 474 475 /* If the target is not a temporary, it may be one of the sources as well */ 476 477 if compare_expression(p(1),p(i)) 478 then do; 479 if ^ p(i) -> reference.shared 480 then call adjust_ref_count(p(i),-1); 481 if nrands = 2 482 then do; 483 if adjust 484 then call adjust_ref_count(p(1),-1); 485 return; 486 end; 487 nrands = 2; 488 macro = d2mac(iop); 489 if i = 2 490 then do; 491 p(2) = p(3); 492 s(2) = s(3); 493 scale(2) = scale(3); 494 end; 495 if iop <= 2 496 then if ^ s(2) -> symbol.complex 497 then ninst = 1; 498 go to adjust_mac; 499 end; 500 end; 501 502 adjust_mac: 503 macro = macro + fixed(s(1) -> symbol.float,1); 504 505 /* fill in the argument lists */ 506 507 do i = 1 to nrands; 508 arg(1,i) = p(i); 509 if ninst > 1 510 then if s(i) -> symbol.complex 511 then arg(2,i) = get_imaginary(p(i)); 512 else if iop = 1 513 then do; 514 use_move = "1"b; 515 switch_rands = i = 2; 516 end; 517 else if iop = 2 518 then if i = 3 519 then do; 520 use_move = "1"b; 521 switch_rands = "0"b; 522 end; 523 else do; 524 arg(2,i) = generate_constant$char_string("+0",2); 525 arg(2,i) -> reference.data_type = real_fix_dec; 526 end; 527 else do; 528 if ^ p(i) -> reference.shared 529 then p(i) -> reference.ref_count = p(i) -> reference.ref_count + 1; 530 arg(2,i) = p(i); 531 end; 532 end; 533 534 /* Now, issue the macro . */ 535 536 do i = 1 to ninst; 537 if use_move 538 then if i = ninst 539 then do; 540 macro = d3mac(0); 541 nrands = 2; 542 if switch_rands 543 then arg(2,2) = arg(2,3); 544 end; 545 call expmac$many_eis(macro,addr(arg(i,1)),nrands); 546 end; 547 548 end; 549 550 551 fix_scales: proc; 552 553 /* replaces fixed scaled inputs whose scales are outside hardware limits with their 554* floating point equivalents */ 555 556 do i = 2 to number; 557 if scale(i) > max_dec_scale | scale(i) < min_dec_scale 558 then do; 559 call assign_op$fix_dec_scaled(p(i)); 560 s(i) = p(i) -> reference.symbol; 561 scale(i) = 0; 562 end; 563 end; 564 end; 565 566 gen_call: proc; 567 568 /* generates a call to pl1_operators_ to do decimal operation */ 569 570 dcl (desc,work) ptr; 571 dcl clength fixed bin(6); 572 dcl one_rand bit(1) aligned; 573 574 dcl 1 descriptor(3) aligned, 575 2 address bit(18) unal, 576 2 fract bit(2) unal, 577 2 type bit(4) unal, 578 2 dscale fixed bin(5) unal, 579 2 dlength bit(6) unal; 580 581 dcl 1 four_bit_descriptor(3) aligned based(addr(descriptor)), /* EIS 4-bit operand descriptor */ 582 2 address bit(18) unal, 583 2 fract bit(3) unal, 584 2 type bit(3) unal, 585 2 dscale fixed bin(5) unal, 586 2 dlength bit(6) unal; 587 588 /* get a pointer to a work area into the ab */ 589 590 if ltemp > 0 591 then do; 592 work = c_a(ltemp,12); 593 work -> reference.ref_count = 2; 594 call base_man$load_var_and_lock(2,work,3); 595 end; 596 597 /* make sure bp is uninvolved in addressing code for the decimal operands */ 598 599 call base_man$update_base(0,null,1); 600 601 /* make all decimal operands addressable without any tags */ 602 603 call make_n_addressable(addr(p),- number); 604 605 /* now build a string of descriptors for use by the operator */ 606 607 do i = 1 to number; 608 descriptor(i).address = string(p(i) -> reference.address); 609 if s(i) -> symbol.unaligned 610 then do; 611 four_bit_descriptor(i).fract = bit(fixed(p(i) -> reference.c_f_offset,3),3); 612 four_bit_descriptor(i).type = "10"b || s(i) -> symbol.fixed; 613 end; 614 else do; 615 descriptor(i).fract = bit(fixed(p(i) -> reference.c_f_offset,2),2); 616 descriptor(i).type = "000"b || s(i) -> symbol.fixed; 617 end; 618 descriptor(i).dscale = - scale(i); 619 clength = p(i) -> reference.c_length; 620 if s(i) -> symbol.complex 621 then clength = divide(clength,2,6,0); 622 descriptor(i).dlength = bit(clength,6); 623 end; 624 625 desc = generate_constant$relocatable(addr(descriptor),number,"0"b); 626 627 /* generate the operator call */ 628 629 call expmac(macro,desc); 630 631 /* unlock the registers and decrement the operands' reference counts */ 632 633 call state_man$unlock; 634 635 if ltemp > 0 636 then call adjust_ref_count(work,-1); 637 638 one_rand = number = 1; 639 640 do i = 1 to number; 641 if ^ p(i) -> reference.shared 642 then if ^ p(i) -> reference.temp_ref | i > 1 | one_rand 643 then call adjust_ref_count(p(i),-1); 644 end; 645 646 end; 647 648 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/18/00 1100.2 decimal_op.pl1 >udd>sm>ds>w>ml>decimal_op.pl1 82 1 04/07/83 1735.0 op_codes.incl.pl1 >ldd>incl>op_codes.incl.pl1 83 2 07/21/80 1646.3 operator.incl.pl1 >ldd>incl>operator.incl.pl1 84 3 12/07/83 1801.7 symbol.incl.pl1 >ldd>incl>symbol.incl.pl1 85 4 07/21/80 1646.3 cg_reference.incl.pl1 >ldd>incl>cg_reference.incl.pl1 86 5 05/03/76 1420.4 data_types.incl.pl1 >ldd>incl>data_types.incl.pl1 87 6 10/25/79 1745.8 cgsystem.incl.pl1 >ldd>incl>cgsystem.incl.pl1 88 7 11/30/78 1327.5 mask.incl.pl1 >ldd>incl>mask.incl.pl1 89 8 07/21/80 1646.3 nodes.incl.pl1 >ldd>incl>nodes.incl.pl1 90 9 11/13/79 1115.8 machine_state.incl.pl1 >ldd>incl>machine_state.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. abs_decimal constant fixed bin(15,0) initial dcl 31 ref 246 abs_decimal_4bit constant fixed bin(15,0) initial dcl 31 ref 244 abs_fun constant bit(9) initial dcl 1-8 ref 234 370 add constant bit(9) initial dcl 1-8 ref 433 addr builtin function dcl 61 ref 279 545 545 603 603 611 612 625 625 address 10 based structure level 2 in structure "reference" packed packed unaligned dcl 4-3 in procedure "decimal_op" ref 608 address 001420 automatic bit(18) array level 2 in structure "descriptor" packed packed unaligned dcl 574 in procedure "gen_call" set ref 608* adjust 001326 automatic bit(1) dcl 28 set ref 109* 239 301 309 315 483 adjust_ref_count 000010 constant entry external dcl 63 ref 315 346 479 483 635 641 aligned_mask constant bit(36) initial dcl 7-3 ref 416 all_fixed 001330 automatic bit(1) dcl 28 set ref 97* 106* 106 167 arg 001350 automatic pointer array dcl 456 set ref 508* 509* 524* 525 530* 542* 542 545 545 assign_op$fix_dec_scaled 000012 constant entry external dcl 64 ref 559 atom parameter bit(1) array dcl 19 ref 17 101 atomic 001327 automatic bit(1) dcl 28 set ref 419* 439* attributes 31 based structure level 2 dcl 3-3 base_man$load_var_and_lock 000016 constant entry external dcl 65 ref 594 base_man$update_base 000014 constant entry external dcl 65 ref 599 bit builtin function dcl 61 ref 611 615 622 bits 12(06) based structure level 2 packed packed unaligned dcl 4-3 c_a 000020 constant entry external dcl 66 ref 592 c_dcl_size 30 based fixed bin(24,0) level 2 dcl 3-3 ref 214 c_f_offset 7 based fixed bin(6,0) level 2 dcl 4-3 ref 611 615 c_length 2 based fixed bin(24,0) level 2 dcl 4-3 ref 393 619 cg_static_$m_s_p 000056 external static pointer dcl 9-3 ref 9-3 chars_per_word constant fixed bin(8,0) initial dcl 6-5 ref 393 clength 001416 automatic fixed bin(6,0) dcl 571 set ref 619* 620* 620 622 compare_expression 000022 constant entry external dcl 67 ref 125 477 compile_exp$save_exp 000024 constant entry external dcl 68 ref 101 complex parameter bit(1) dcl 410 in procedure "decimal_op" ref 407 412 complex 31(31) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 3-3 in procedure "decimal_op" ref 115 154 193 193 193 199 214 264 495 509 620 complex_fun constant bit(9) initial dcl 1-8 ref 331 complex_mask constant bit(36) initial dcl 7-3 ref 412 conjg_fun constant bit(9) initial dcl 1-8 ref 355 const 001325 automatic char(2) dcl 27 set ref 122* 132* 137* copy_temp 000026 constant entry external dcl 69 ref 418 cplx_ops 000014 constant fixed bin(15,0) initial array dcl 31 ref 198 d2mac 000016 constant fixed bin(15,0) initial array dcl 31 ref 488 d3mac 000022 constant fixed bin(15,0) initial array dcl 31 ref 470 540 data_type 31 based structure level 3 in structure "symbol" packed packed unaligned dcl 3-3 in procedure "decimal_op" data_type 12 based fixed bin(5,0) level 2 in structure "reference" packed packed unaligned dcl 4-3 in procedure "decimal_op" set ref 138* 525* decimal_mask constant bit(36) initial dcl 7-3 ref 416 declare_temporary 000030 constant entry external dcl 70 ref 416 desc 001412 automatic pointer dcl 570 set ref 625* 629* descriptor 001420 automatic structure array level 1 dcl 574 set ref 611 612 625 625 div constant bit(9) initial dcl 1-8 ref 148 divide builtin function dcl 61 ref 393 620 dlength 0(30) 001420 automatic bit(6) array level 2 packed packed unaligned dcl 574 set ref 622* dscale 0(24) 001420 automatic fixed bin(5,0) array level 2 packed packed unaligned dcl 574 set ref 618* dvrcdec constant fixed bin(15,0) initial dcl 31 ref 199 expmac 000032 constant entry external dcl 71 ref 629 expmac$many_eis 000034 constant entry external dcl 72 ref 545 expmac$one_eis 000040 constant entry external dcl 74 ref 248 expmac$two_eis 000036 constant entry external dcl 73 ref 304 311 312 326 335 336 350 exponent 001332 automatic structure level 1 dcl 51 set ref 279 exponent_char based char(1) dcl 55 ref 279 fixed 31(01) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 3-3 in procedure "decimal_op" ref 106 285 324 612 616 fixed builtin function dcl 61 in procedure "decimal_op" ref 156 299 334 350 390 502 611 615 float 31(02) based bit(1) level 4 packed packed unaligned dcl 3-3 ref 205 266 299 334 350 440 502 float_mask constant bit(36) initial dcl 7-3 ref 416 four_bit_descriptor based structure array level 1 dcl 581 fract 0(18) based bit(3) array level 2 in structure "four_bit_descriptor" packed packed unaligned dcl 581 in procedure "gen_call" set ref 611* fract 0(18) 001420 automatic bit(2) array level 2 in structure "descriptor" packed packed unaligned dcl 574 in procedure "gen_call" set ref 615* generate_constant$char_string 000044 constant entry external dcl 76 ref 137 279 524 generate_constant$relocatable 000042 constant entry external dcl 75 ref 625 get_imaginary 000046 constant entry external dcl 77 ref 333 345 357 358 509 i 001364 automatic fixed bin(17,0) dcl 457 in procedure "issue" set ref 472* 477 479 479 489* 507* 508 508 509 509 509 515 517 524 525 528 528 528 530 530* 536* 537 545 545* i 001113 automatic fixed bin(17,0) dcl 25 in procedure "decimal_op" set ref 100* 101 101 101 103 103 104 104 105 105 106* 169* 169* 173 306* 307 307 307 311 312* 436* 437 437 437 439 439 440 442 442* 556* 557 557 559 560 560 561* 607* 608 608 609 611 611 612 612 615 615 616 616 618 618 619 620 622* 640* 641 641 641 641* imag 001106 automatic pointer array dcl 23 set ref 333* 336* 357* 358* 363 364 imag_fun constant bit(9) initial dcl 1-8 ref 340 indicators 1 based fixed bin(17,0) level 2 dcl 9-6 set ref 250* 250 iop 001114 automatic fixed bin(17,0) dcl 25 set ref 121* 131* 156* 158 193 198 205 221* 238* 266* 272* 360* 390* 391 392 467 470 472 488 495 512 517 j 001115 automatic fixed bin(17,0) dcl 25 set ref 172* 173 173* 178* 179 179* ltemp 1 000000 constant fixed bin(17,0) initial array level 2 in structure "op_table" dcl 57 in procedure "decimal_op" ref 392 ltemp 001322 automatic fixed bin(17,0) dcl 25 in procedure "decimal_op" set ref 197* 386* 392* 393 393* 590 592* 635 m_s_p 001334 automatic pointer initial dcl 9-3 set ref 250 250 9-3* mac 001324 automatic fixed bin(15,0) dcl 26 set ref 244* 246* 248* 299* 304* 312* machine_state based structure level 1 dcl 9-6 macro 000000 constant fixed bin(15,0) initial array level 2 in structure "op_table" dcl 57 in procedure "decimal_op" ref 391 macro 001366 automatic fixed bin(15,0) dcl 458 in procedure "issue" set ref 470* 488* 502* 502 540* 545* macro 001323 automatic fixed bin(15,0) dcl 26 in procedure "decimal_op" set ref 198* 199* 296* 298* 311* 334* 335* 336* 387* 391* 629* make_n_addressable 000050 constant entry external dcl 78 ref 603 mask 001331 automatic bit(36) dcl 29 set ref 412* 414* 416 max builtin function dcl 61 ref 161 445 max_dec constant fixed bin(15,0) initial dcl 31 ref 298 max_dec_scale constant fixed bin(8,0) initial dcl 6-5 ref 164 167 173 445 557 max_fun constant bit(9) initial dcl 1-8 ref 293 max_scale 001116 automatic fixed bin(17,0) dcl 25 set ref 161* 164 167 169 min builtin function dcl 61 ref 162 250 445 min_dec constant fixed bin(15,0) initial dcl 31 ref 296 min_dec_scale 003055 constant fixed bin(8,0) initial dcl 6-5 ref 164 167 445 557 min_fun constant bit(9) initial dcl 1-8 ref 293 296 min_scale 001117 automatic fixed bin(17,0) dcl 25 set ref 162* 164 167 misc_attributes 31(19) based structure level 3 packed packed unaligned dcl 3-3 mod builtin function dcl 61 ref 472 mod_dec constant fixed bin(15,0) initial dcl 31 ref 387 move_numeric constant fixed bin(15,0) initial dcl 31 ref 299 326 334 350 negate constant bit(9) initial dcl 1-8 ref 113 ninst 001120 automatic fixed bin(17,0) dcl 25 set ref 94* 117* 154* 264* 495* 509 536 537 node based structure level 1 dcl 8-27 node_pt parameter pointer dcl 19 ref 17 95 428 430 nrands 001365 automatic fixed bin(17,0) dcl 457 set ref 467* 469* 481 487* 507 541* 545* null builtin function dcl 61 ref 416 416 599 599 number 0(21) based fixed bin(14,0) level 2 in structure "operator" packed packed unaligned dcl 2-6 in procedure "decimal_op" ref 98 number 001321 automatic fixed bin(17,0) dcl 25 in procedure "decimal_op" set ref 98* 100 306 375* 556 603 607 625* 638 640 one_rand 001417 automatic bit(1) dcl 572 set ref 638* 641 op 000100 automatic pointer dcl 23 set ref 95* 96 98 101 430* 431 435 437 437 439 op_code 0(09) based bit(9) level 2 in structure "operator" packed packed unaligned dcl 2-6 in procedure "decimal_op" ref 96 431 op_code 001112 automatic bit(9) dcl 24 in procedure "decimal_op" set ref 96* 113 148 156 234 255 293 293 296 321 331 340 340 342 355 370 370 381 390 431* 433 433 op_table 000000 constant structure array level 1 dcl 57 operand 1 based pointer array level 2 packed packed unaligned dcl 2-6 ref 101 435 437 437 439 operator based structure level 1 dcl 2-6 p 000102 automatic pointer array dcl 23 set ref 101* 103* 104 109 109 125 125* 125* 135* 135 137* 138 139 213 214* 218* 218 219* 220 239 239 248* 275* 275 279* 280 301 301 304* 304* 307 307 307 309 309 311* 311* 312* 312* 315* 317 326* 326* 333* 335* 335* 336* 342 345* 346 346* 350* 357* 358* 363* 364* 376* 376 393 437* 439* 440 442 472 477* 477* 479 479* 483* 491* 491 508 509* 528 528 528 530 559* 560 603 603 608 611 615 619 641 641 641* pad 001332 automatic bit(1) level 2 packed packed unaligned dcl 51 set ref 277* pl1_mod_fun constant bit(9) initial dcl 1-8 ref 381 prec parameter fixed bin(24,0) dcl 409 ref 407 416 prepare_operand 000052 constant entry external dcl 79 ref 419 439 q 001102 automatic pointer dcl 23 set ref 213* 219 342* 345* 350* r 001104 automatic pointer dcl 23 set ref 416* 418* 418* 419* 419* 420 real 31(30) based bit(1) level 4 packed packed unaligned dcl 3-3 ref 234 real_fix_dec constant fixed bin(15,0) initial dcl 5-1 ref 138 525 real_fun constant bit(9) initial dcl 1-8 ref 340 342 real_mask constant bit(36) initial dcl 7-3 ref 414 ref_count 0(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 4-3 set ref 239* 239 301* 301 307* 307 309* 309 528* 528 593* reference based structure level 1 dcl 4-3 reference_node constant bit(9) initial dcl 8-5 ref 437 refs parameter pointer array dcl 19 set ref 17 103 317* round_fun constant bit(9) initial dcl 1-8 ref 255 s 000502 automatic pointer array dcl 23 set ref 104* 105 106 115 136* 136 139* 154 173 179 193 193 193 199 205 214 214 220* 234 244 264 266 273 274 276* 276 280* 285 287 288 299 324 334 350 377* 377 492* 492 495 502 509 560* 609 612 616 620 scale 2(28) based fixed bin(7,0) level 2 in structure "symbol" packed packed unaligned dcl 3-3 in procedure "decimal_op" set ref 105 173* 179* 273* 274* 287* 288* 435 442 scale 001121 automatic fixed bin(17,0) array dcl 25 in procedure "decimal_op" set ref 105* 161 161 161 162 162 162 169 173 173 179 261* 278 278 287 288 378* 378 435* 442* 445 445 445 445 445 445 493* 493 557 557 561* 618 shared 0(11) based bit(1) level 2 packed packed unaligned dcl 4-3 ref 109 307 346 479 528 641 sign_fun constant bit(9) initial dcl 1-8 ref 370 state_man$unlock 000054 constant entry external dcl 80 ref 633 string builtin function dcl 61 ref 608 sub constant bit(9) initial dcl 1-8 ref 433 switch_rands 001370 automatic bit(1) dcl 459 set ref 515* 521* 542 symbol 3 based pointer level 2 in structure "reference" packed packed unaligned dcl 4-3 in procedure "decimal_op" ref 104 139 220 280 435 440 442 560 symbol based structure level 1 dcl 3-3 in procedure "decimal_op" temp_ref 12(11) based bit(1) level 3 packed packed unaligned dcl 4-3 ref 109 125 472 641 trunc_fun constant bit(9) initial dcl 1-8 ref 321 type based bit(9) level 2 in structure "node" packed packed unaligned dcl 8-27 in procedure "decimal_op" ref 437 type 0(20) 001420 automatic bit(4) array level 2 in structure "descriptor" packed packed unaligned dcl 574 in procedure "gen_call" set ref 616* type 0(21) based bit(3) array level 2 in structure "four_bit_descriptor" packed packed unaligned dcl 581 in procedure "gen_call" set ref 612* unaligned 31(22) based bit(1) level 4 packed packed unaligned dcl 3-3 ref 244 609 use_move 001367 automatic bit(1) dcl 459 set ref 465* 514* 520* 537 value 0(01) 001332 automatic fixed bin(7,0) level 2 packed packed unaligned dcl 51 set ref 278* work 001414 automatic pointer dcl 570 set ref 592* 593 594* 635* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. a_format internal static bit(9) initial dcl 1-8 acos_fun internal static bit(9) initial dcl 1-8 acosd_fun internal static bit(9) initial dcl 1-8 addbitno_fun internal static bit(9) initial dcl 1-8 addcharno_fun internal static bit(9) initial dcl 1-8 addr_fun internal static bit(9) initial dcl 1-8 addr_fun_bits internal static bit(9) initial dcl 1-8 addrel_fun internal static bit(9) initial dcl 1-8 allocation_fun internal static bit(9) initial dcl 1-8 allot_auto internal static bit(9) initial dcl 1-8 allot_based internal static bit(9) initial dcl 1-8 allot_ctl internal static bit(9) initial dcl 1-8 allot_var internal static bit(9) initial dcl 1-8 and_bits internal static bit(9) initial dcl 1-8 area_mask internal static bit(36) initial dcl 7-3 arg_descriptor_mask internal static bit(36) initial dcl 7-3 arithmetic_mask internal static bit(36) initial dcl 7-41 array_node internal static bit(9) initial dcl 8-5 asin_fun internal static bit(9) initial dcl 1-8 asind_fun internal static bit(9) initial dcl 1-8 assign internal static bit(9) initial dcl 1-8 assign_by_name internal static bit(9) initial dcl 1-8 assign_round internal static bit(9) initial dcl 1-8 assign_size_ck internal static bit(9) initial dcl 1-8 assign_zero internal static bit(9) initial dcl 1-8 atan_fun internal static bit(9) initial dcl 1-8 atand_fun internal static bit(9) initial dcl 1-8 b_format internal static bit(9) initial dcl 1-8 baseno_fun internal static bit(9) initial dcl 1-8 baseptr_fun internal static bit(9) initial dcl 1-8 binary_mask internal static bit(36) initial dcl 7-3 bit_mask internal static bit(36) initial dcl 7-3 bit_pointer internal static bit(9) initial dcl 1-8 bit_string internal static fixed bin(15,0) initial dcl 5-1 bit_to_char internal static bit(9) initial dcl 1-8 bit_to_word internal static bit(9) initial dcl 1-8 bitno_fun internal static bit(9) initial dcl 1-8 bits_per_char internal static fixed bin(8,0) initial dcl 6-5 bits_per_four_words internal static fixed bin(8,0) initial dcl 6-5 bits_per_half internal static fixed bin(8,0) initial dcl 6-5 bits_per_packed_digit internal static fixed bin(8,1) initial dcl 6-35 bits_per_two_words internal static fixed bin(8,0) initial dcl 6-5 bits_per_word internal static fixed bin(8,0) initial dcl 6-5 bits_per_words internal static fixed bin(8,0) initial array dcl 6-5 block_node internal static bit(9) initial dcl 8-5 bn_format internal static bit(9) initial dcl 1-8 bool_fun internal static bit(9) initial dcl 1-8 bound_ck internal static bit(9) initial dcl 1-8 bound_node internal static bit(9) initial dcl 8-5 break_even_bits internal static fixed bin(8,0) initial dcl 6-5 break_even_words internal static fixed bin(8,0) initial dcl 6-5 builtin_mask internal static bit(36) initial dcl 7-3 by_name_agg_node internal static bit(9) initial dcl 8-5 byte_fun internal static bit(9) initial dcl 1-8 c_format internal static bit(9) initial dcl 1-8 cat_string internal static bit(9) initial dcl 1-8 ceil_fun internal static bit(9) initial dcl 1-8 char_mask internal static bit(36) initial dcl 7-3 char_string internal static fixed bin(15,0) initial dcl 5-1 char_to_word internal static bit(9) initial dcl 1-8 charno_fun internal static bit(9) initial dcl 1-8 clock_fun internal static bit(9) initial dcl 1-8 close_file internal static bit(9) initial dcl 1-8 codeptr_fun internal static bit(9) initial dcl 1-8 column_format internal static bit(9) initial dcl 1-8 complex_fix_bin_1 internal static fixed bin(15,0) initial dcl 5-1 complex_fix_bin_2 internal static fixed bin(15,0) initial dcl 5-1 complex_fix_dec internal static fixed bin(15,0) initial dcl 5-1 complex_flt_bin_1 internal static fixed bin(15,0) initial dcl 5-1 complex_flt_bin_2 internal static fixed bin(15,0) initial dcl 5-1 complex_flt_dec internal static fixed bin(15,0) initial dcl 5-1 computational_mask internal static bit(36) initial dcl 7-41 condition_mask internal static bit(36) initial dcl 7-3 context_node internal static bit(9) initial dcl 8-5 convert_mask internal static bit(36) initial dcl 7-41 convert_offset internal static fixed bin(8,1) initial array dcl 6-35 convert_size internal static fixed bin(8,0) initial array dcl 6-5 copy_string internal static bit(9) initial dcl 1-8 copy_words internal static bit(9) initial dcl 1-8 cos_fun internal static bit(9) initial dcl 1-8 cosd_fun internal static bit(9) initial dcl 1-8 cross_reference_node internal static bit(9) initial dcl 8-5 declare_constant_mask internal static bit(36) initial dcl 7-41 default_fix_bin_p internal static fixed bin(8,0) initial dcl 6-5 default_node internal static bit(9) initial dcl 8-5 delete_file internal static bit(9) initial dcl 1-8 desc_size internal static bit(9) initial dcl 1-8 digit_to_bit internal static bit(9) initial dcl 1-8 dimensioned_mask internal static bit(36) initial dcl 7-3 do_fun internal static bit(9) initial dcl 1-8 do_spec internal static bit(9) initial dcl 1-8 e_format internal static bit(9) initial dcl 1-8 empty_area internal static bit(9) initial dcl 1-8 enable_on internal static bit(9) initial dcl 1-8 entry_mask internal static bit(36) initial dcl 7-3 entry_variable internal static fixed bin(15,0) initial dcl 5-1 environmentptr_fun internal static bit(9) initial dcl 1-8 equal internal static bit(9) initial dcl 1-8 ex_prologue internal static bit(9) initial dcl 1-8 exp internal static bit(9) initial dcl 1-8 exp_fun internal static bit(9) initial dcl 1-8 ext_entry_in internal static fixed bin(15,0) initial dcl 5-1 ext_entry_out internal static fixed bin(15,0) initial dcl 5-1 f_format internal static bit(9) initial dcl 1-8 file_mask internal static bit(36) initial dcl 7-3 fixed_binary_real_mask internal static bit(36) initial dcl 7-41 fixed_decimal_complex_mask internal static bit(36) initial dcl 7-41 fixed_decimal_real_mask internal static bit(36) initial dcl 7-41 fixed_mask internal static bit(36) initial dcl 7-3 float_decimal_complex_mask internal static bit(36) initial dcl 7-41 float_decimal_real_mask internal static bit(36) initial dcl 7-41 floor_fun internal static bit(9) initial dcl 1-8 format_mask internal static bit(36) initial dcl 7-3 format_value_node internal static bit(9) initial dcl 8-5 fortran_read internal static bit(9) initial dcl 1-8 fortran_write internal static bit(9) initial dcl 1-8 free_based internal static bit(9) initial dcl 1-8 free_ctl internal static bit(9) initial dcl 1-8 free_var internal static bit(9) initial dcl 1-8 ftn_file_manip internal static bit(9) initial dcl 1-8 ftn_trans_loop internal static bit(9) initial dcl 1-8 generic_mask internal static bit(36) initial dcl 7-3 get_data_trans internal static bit(9) initial dcl 1-8 get_edit_trans internal static bit(9) initial dcl 1-8 get_file internal static bit(9) initial dcl 1-8 get_list_trans internal static bit(9) initial dcl 1-8 get_string internal static bit(9) initial dcl 1-8 greater_or_equal internal static bit(9) initial dcl 1-8 greater_than internal static bit(9) initial dcl 1-8 half_to_word internal static bit(9) initial dcl 1-8 ind_arithmetic internal static fixed bin(17,0) initial dcl 9-68 ind_decimal_reg internal static fixed bin(17,0) initial dcl 9-68 ind_invalid internal static fixed bin(17,0) initial dcl 9-68 ind_known_refs internal static fixed bin(17,0) initial dcl 9-68 ind_logical internal static fixed bin(17,0) initial dcl 9-68 ind_string_aq internal static fixed bin(17,0) initial dcl 9-68 ind_x internal static fixed bin(17,0) initial array dcl 9-68 index_after_fun internal static bit(9) initial dcl 1-8 index_before_fun internal static bit(9) initial dcl 1-8 index_fun internal static bit(9) initial dcl 1-8 index_rev_fun internal static bit(9) initial dcl 1-8 initialed_mask internal static bit(36) initial dcl 7-3 int_entry internal static fixed bin(15,0) initial dcl 5-1 int_entry_other internal static fixed bin(15,0) initial dcl 5-1 irreducible_mask internal static bit(36) initial dcl 7-3 join internal static bit(9) initial dcl 1-8 jump internal static bit(9) initial dcl 1-8 jump_false internal static bit(9) initial dcl 1-8 jump_if_eq internal static bit(9) initial dcl 1-8 jump_if_ge internal static bit(9) initial dcl 1-8 jump_if_gt internal static bit(9) initial dcl 1-8 jump_if_le internal static bit(9) initial dcl 1-8 jump_if_lt internal static bit(9) initial dcl 1-8 jump_if_ne internal static bit(9) initial dcl 1-8 jump_true internal static bit(9) initial dcl 1-8 l_parn internal static bit(9) initial dcl 1-8 label_array_element_node internal static bit(9) initial dcl 8-5 label_constant internal static fixed bin(15,0) initial dcl 5-1 label_mask internal static bit(36) initial dcl 7-3 label_node internal static bit(9) initial dcl 8-5 label_size internal static fixed bin(8,0) initial dcl 6-5 label_variable internal static fixed bin(15,0) initial dcl 5-1 length builtin function dcl 61 length_fun internal static bit(9) initial dcl 1-8 less_or_equal internal static bit(9) initial dcl 1-8 less_than internal static bit(9) initial dcl 1-8 line_format internal static bit(9) initial dcl 1-8 list_node internal static bit(9) initial dcl 8-5 local_label_variable internal static fixed bin(15,0) initial dcl 5-1 local_mask internal static bit(36) initial dcl 7-3 locate_file internal static bit(9) initial dcl 1-8 lock_file internal static bit(9) initial dcl 1-8 lock_fun internal static bit(9) initial dcl 1-8 lock_mask internal static bit(36) initial dcl 7-3 log10_fun internal static bit(9) initial dcl 1-8 log2_fun internal static bit(9) initial dcl 1-8 log_fun internal static bit(9) initial dcl 1-8 loop internal static bit(9) initial dcl 1-8 machine_state_node internal static bit(9) initial dcl 8-5 make_desc internal static bit(9) initial dcl 1-8 max_index_register_value internal static fixed bin(31,0) initial dcl 6-38 max_length_p internal static fixed bin(8,0) initial dcl 6-5 max_number_of_operands internal static fixed bin(15,0) initial dcl 2-15 max_offset internal static fixed bin(8,0) initial array dcl 6-5 max_p_fix_bin_1 internal static fixed bin(8,0) initial dcl 6-5 max_p_fix_dec internal static fixed bin(8,0) initial dcl 6-5 max_p_flt_bin_1 internal static fixed bin(8,0) initial dcl 6-5 max_p_xreg internal static fixed bin(8,0) initial dcl 6-5 max_short_size internal static fixed bin(8,0) initial array dcl 6-5 mod_bit internal static bit(9) initial dcl 1-8 mod_byte internal static bit(9) initial dcl 1-8 mod_fun internal static bit(9) initial dcl 1-8 mod_half internal static bit(9) initial dcl 1-8 mod_word internal static bit(9) initial dcl 1-8 move_rounded internal static fixed bin(15,0) initial dcl 31 mult internal static bit(9) initial dcl 1-8 nop internal static bit(9) initial dcl 1-8 not_bits internal static bit(9) initial dcl 1-8 not_equal internal static bit(9) initial dcl 1-8 off_fun internal static bit(9) initial dcl 1-8 offset_mask internal static bit(36) initial dcl 7-3 open_file internal static bit(9) initial dcl 1-8 operator_node internal static bit(9) initial dcl 8-5 or_bits internal static bit(9) initial dcl 1-8 pack internal static bit(9) initial dcl 1-8 packed_digits_per_char internal static fixed bin(8,0) initial dcl 6-5 packed_digits_per_word internal static fixed bin(8,0) initial dcl 6-5 packed_ptr internal static fixed bin(15,0) initial dcl 5-1 page_format internal static bit(9) initial dcl 1-8 param_desc_ptr internal static bit(9) initial dcl 1-8 param_ptr internal static bit(9) initial dcl 1-8 picture_format internal static bit(9) initial dcl 1-8 picture_mask internal static bit(36) initial dcl 7-3 precision_mask internal static bit(36) initial dcl 7-3 prefix_plus internal static bit(9) initial dcl 1-8 ptr_fun internal static bit(9) initial dcl 1-8 ptr_mask internal static bit(36) initial dcl 7-3 put_control internal static bit(9) initial dcl 1-8 put_data_trans internal static bit(9) initial dcl 1-8 put_edit_trans internal static bit(9) initial dcl 1-8 put_field internal static bit(9) initial dcl 1-8 put_field_chk internal static bit(9) initial dcl 1-8 put_file internal static bit(9) initial dcl 1-8 put_list_trans internal static bit(9) initial dcl 1-8 put_string internal static bit(9) initial dcl 1-8 r_format internal static bit(9) initial dcl 1-8 r_parn internal static bit(9) initial dcl 1-8 range_ck internal static bit(9) initial dcl 1-8 rank_fun internal static bit(9) initial dcl 1-8 read_file internal static bit(9) initial dcl 1-8 real_fix_bin_1 internal static fixed bin(15,0) initial dcl 5-1 real_fix_bin_2 internal static fixed bin(15,0) initial dcl 5-1 real_flt_bin_1 internal static fixed bin(15,0) initial dcl 5-1 real_flt_bin_2 internal static fixed bin(15,0) initial dcl 5-1 real_flt_dec internal static fixed bin(15,0) initial dcl 5-1 record_io internal static bit(9) initial dcl 1-8 reducible_mask internal static bit(36) initial dcl 7-3 refer internal static bit(9) initial dcl 1-8 rel_fun internal static bit(9) initial dcl 1-8 repeat_fun internal static bit(9) initial dcl 1-8 return_bits internal static bit(9) initial dcl 1-8 return_string internal static bit(9) initial dcl 1-8 return_value internal static bit(9) initial dcl 1-8 return_words internal static bit(9) initial dcl 1-8 returns_mask internal static bit(36) initial dcl 7-3 reverse_fun internal static bit(9) initial dcl 1-8 revert_on internal static bit(9) initial dcl 1-8 rewrite_file internal static bit(9) initial dcl 1-8 search_fun internal static bit(9) initial dcl 1-8 search_rev_fun internal static bit(9) initial dcl 1-8 segno_fun internal static bit(9) initial dcl 1-8 setbitno_fun internal static bit(9) initial dcl 1-8 setcharno_fun internal static bit(9) initial dcl 1-8 sf_par_node internal static bit(9) initial dcl 8-5 signal_on internal static bit(9) initial dcl 1-8 signed_mask internal static bit(36) initial dcl 7-3 sin_fun internal static bit(9) initial dcl 1-8 sind_fun internal static bit(9) initial dcl 1-8 skip_format internal static bit(9) initial dcl 1-8 source_node internal static bit(9) initial dcl 8-5 sqrt_fun internal static bit(9) initial dcl 1-8 stack_ptr internal static bit(9) initial dcl 1-8 stackbaseptr_fun internal static bit(9) initial dcl 1-8 stackframeptr_fun internal static bit(9) initial dcl 1-8 stacq_fun internal static bit(9) initial dcl 1-8 statement_node internal static bit(9) initial dcl 8-5 std_arg_list internal static bit(9) initial dcl 1-8 std_call internal static bit(9) initial dcl 1-8 std_entry internal static bit(9) initial dcl 1-8 std_return internal static bit(9) initial dcl 1-8 stop internal static bit(9) initial dcl 1-8 storage_block_mask internal static bit(36) initial dcl 7-3 stream_prep internal static bit(9) initial dcl 1-8 string_mask internal static bit(36) initial dcl 7-41 structure_mask internal static bit(36) initial dcl 7-3 symbol_node internal static bit(9) initial dcl 8-5 tan_fun internal static bit(9) initial dcl 1-8 tand_fun internal static bit(9) initial dcl 1-8 temporary_node internal static bit(9) initial dcl 8-5 terminate_trans internal static bit(9) initial dcl 1-8 token_node internal static bit(9) initial dcl 8-5 translate_fun internal static bit(9) initial dcl 1-8 unaligned_mask internal static bit(36) initial dcl 7-3 undesirable_mask internal static bit(36) initial dcl 7-41 units_per_word internal static fixed bin(8,0) initial array dcl 6-5 unlock_file internal static bit(9) initial dcl 1-8 unpack internal static bit(9) initial dcl 1-8 unpacked_ptr internal static fixed bin(15,0) initial dcl 5-1 unsigned_mask internal static bit(36) initial dcl 7-3 variable_mask internal static bit(36) initial dcl 7-3 varying_mask internal static bit(36) initial dcl 7-3 vclock_fun internal static bit(9) initial dcl 1-8 verify_fun internal static bit(9) initial dcl 1-8 verify_ltrim_fun internal static bit(9) initial dcl 1-8 verify_rev_fun internal static bit(9) initial dcl 1-8 verify_rtrim_fun internal static bit(9) initial dcl 1-8 word_to_mod2 internal static bit(9) initial dcl 1-8 word_to_mod4 internal static bit(9) initial dcl 1-8 word_to_mod8 internal static bit(9) initial dcl 1-8 wordno_fun internal static bit(9) initial dcl 1-8 write_file internal static bit(9) initial dcl 1-8 x_format internal static bit(9) initial dcl 1-8 xor_bits internal static bit(9) initial dcl 1-8 NAMES DECLARED BY EXPLICIT CONTEXT. adjust_mac 002261 constant label dcl 502 ref 498 builtin 000632 constant label dcl 234 ref 148 decimal_op 000071 constant entry external dcl 17 decimal_op$change_target 001705 constant entry external dcl 428 decimal_op$get_float_temp 001564 constant entry external dcl 407 ref 214 fix_scales 002463 constant entry internal dcl 551 ref 184 191 262 295 323 370 gen_call 002523 constant entry internal dcl 566 ref 201 397 issue 002115 constant entry internal dcl 454 ref 141 164 176 185 216 223 227 242 283 361 use_mult 000223 constant label dcl 121 ref 125 365 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3370 3450 3060 3400 Length 4036 3060 60 352 310 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME decimal_op 878 external procedure is an external procedure. issue internal procedure shares stack frame of external procedure decimal_op. fix_scales internal procedure shares stack frame of external procedure decimal_op. gen_call internal procedure shares stack frame of external procedure decimal_op. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME decimal_op 000100 op decimal_op 000102 p decimal_op 000502 s decimal_op 001102 q decimal_op 001104 r decimal_op 001106 imag decimal_op 001112 op_code decimal_op 001113 i decimal_op 001114 iop decimal_op 001115 j decimal_op 001116 max_scale decimal_op 001117 min_scale decimal_op 001120 ninst decimal_op 001121 scale decimal_op 001321 number decimal_op 001322 ltemp decimal_op 001323 macro decimal_op 001324 mac decimal_op 001325 const decimal_op 001326 adjust decimal_op 001327 atomic decimal_op 001330 all_fixed decimal_op 001331 mask decimal_op 001332 exponent decimal_op 001334 m_s_p decimal_op 001350 arg issue 001364 i issue 001365 nrands issue 001366 macro issue 001367 use_move issue 001370 switch_rands issue 001412 desc gen_call 001414 work gen_call 001416 clength gen_call 001417 one_rand gen_call 001420 descriptor gen_call THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_in call_ext_out_desc call_ext_out return_mac mdfx1 signal_op ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. adjust_ref_count assign_op$fix_dec_scaled base_man$load_var_and_lock base_man$update_base c_a compare_expression compile_exp$save_exp copy_temp declare_temporary expmac expmac$many_eis expmac$one_eis expmac$two_eis generate_constant$char_string generate_constant$relocatable get_imaginary make_n_addressable prepare_operand state_man$unlock THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cg_static_$m_s_p LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 9 3 000057 17 000065 94 000101 95 000103 96 000107 97 000113 98 000115 100 000121 101 000127 103 000151 104 000155 105 000162 106 000170 107 000174 109 000176 113 000212 115 000215 117 000221 121 000223 122 000225 123 000227 125 000230 131 000250 132 000252 135 000254 136 000256 137 000260 138 000303 139 000306 141 000310 142 000311 148 000323 154 000326 156 000334 158 000340 161 000342 162 000352 164 000362 167 000372 169 000402 170 000412 172 000414 173 000421 174 000434 176 000436 178 000437 179 000445 180 000455 181 000457 184 000460 185 000461 188 000462 191 000474 193 000475 197 000520 198 000522 199 000525 201 000531 202 000532 205 000544 213 000552 214 000554 216 000573 218 000574 219 000576 220 000600 221 000603 223 000604 224 000605 227 000617 228 000620 234 000632 238 000640 239 000641 242 000650 244 000651 246 000660 248 000662 250 000673 251 000701 255 000713 261 000716 262 000717 264 000720 266 000726 272 000733 273 000735 274 000741 275 000746 276 000750 277 000751 278 000753 279 000761 280 001010 283 001013 285 001014 287 001020 288 001024 290 001031 293 001043 295 001047 296 001050 298 001056 299 001060 301 001066 304 001076 306 001111 307 001121 309 001135 311 001145 312 001161 313 001175 315 001177 317 001214 318 001220 321 001232 323 001234 324 001235 326 001241 327 001256 331 001270 333 001273 334 001304 335 001312 336 001325 337 001340 340 001352 342 001356 345 001363 346 001374 350 001412 352 001433 355 001445 357 001447 358 001460 360 001471 361 001472 363 001473 364 001475 365 001477 370 001500 373 001505 375 001506 376 001510 377 001512 378 001514 381 001516 386 001521 387 001522 388 001524 390 001525 391 001530 392 001534 393 001536 397 001545 398 001546 407 001560 412 001574 414 001603 416 001605 418 001635 419 001645 420 001664 428 001700 430 001714 431 001720 433 001724 435 001730 436 001736 437 001743 439 001757 440 002003 442 002026 443 002037 445 002041 450 002100 648 002114 454 002115 465 002116 467 002117 469 002124 470 002126 472 002131 477 002147 479 002167 481 002206 483 002211 485 002226 487 002227 488 002231 489 002234 491 002237 492 002241 493 002243 495 002245 498 002256 500 002257 502 002261 507 002266 508 002275 509 002300 512 002323 514 002326 515 002330 516 002334 517 002335 520 002342 521 002344 522 002345 524 002346 525 002373 526 002377 528 002400 530 002411 532 002413 536 002415 537 002425 540 002431 541 002433 542 002435 545 002441 546 002460 548 002462 551 002463 556 002464 557 002473 559 002500 560 002512 561 002516 563 002520 564 002522 566 002523 590 002524 592 002526 593 002543 594 002546 599 002565 603 002605 607 002622 608 002631 609 002637 611 002644 612 002654 613 002665 615 002666 616 002676 618 002706 619 002712 620 002714 622 002721 623 002727 625 002731 629 002752 633 002763 635 002770 638 003005 640 003011 641 003017 644 003051 646 003053 ----------------------------------------------------------- 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