COMPILATION LISTING OF SEGMENT apl_dim_canonicalize_ Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 11/29/83 1600.6 mst Tue 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 /* Input canonicalization program for APL Device Interface Module. 11* Paul Green, July 1973 */ 12 /* Modified 741018 by PG for variable tab width. */ 13 /* Modified 780505 by William York to allow erasing of illegal characters. */ 14 15 /* format: style3 */ 16 apl_dim_canonicalize_: 17 procedure (sdb_ptr, charp, lowi, n); 18 19 dcl (col, ncol, sos, lowi, i, j, k, save, tempn) 20 fixed bin (18); 21 dcl pair_index fixed bin, 22 compressing bit (1) aligned, 23 pair char (2) aligned, 24 move fixed bin (3), 25 tchar bit (9), 26 (charp, tempp) ptr; 27 28 dcl 1 temp (n) aligned, /* temp array of chars and their columns */ 29 2 col unal fixed bin (17), /* column where char starts */ 30 2 erase bit (1) unaligned, /* if erase char */ 31 2 kill bit (1) unaligned, /* kill char switch */ 32 2 stop bit (1) unaligned, /* end-of-line switch */ 33 2 error bit (1) unaligned, /* character error here */ 34 2 pad bit (5) unaligned, 35 2 char bit (9) unaligned; 36 37 dcl ccol fixed bin (17); 38 39 dcl tempa (1) fixed bin based (tempp) aligned; 40 /* overlay for temp, used in sort */ 41 42 dcl 1 char based aligned, /* to reference input string */ 43 2 a (0:1) bit (9) unaligned; 44 45 /* builtins */ 46 47 dcl (addr, binary, divide, index, mod, null, substr, unspec) 48 builtin; 49 50 /* include files */ 51 1 1 /* ====== BEGIN INCLUDE SEGMENT apl_dim_sdb.incl.pl1 ====================================== */ 1 2 1 3 /* format: style3,initlm0,idind30 */ 1 4 dcl sdb_ptr ptr; 1 5 1 6 dcl 1 stream_data_block aligned based (sdb_ptr), 1 7 2 outer_module_name char (32) init (my_name), 1 8 /* standard I/O System SDB header */ 1 9 2 device_name_list_ptr ptr init (addr (stream_data_block.device_name)), 1 10 2 device_name aligned, 1 11 3 next_ptr ptr init (null ()), 1 12 3 name_size fixed bin init (length (att_stream)), 1 13 3 name char (32) init (att_stream), 1 14 2 device_iocb_ptr ptr, /* ptr to IOCB for sdb.name */ 1 15 2 iocb_ptr ptr, /* ptr to IOCB for this attachment */ 1 16 /* info about conversion tables */ 1 17 2 sequence_table_ptr ptr, /* points to escape sequences in use */ 1 18 2 device_info_ptr ptr init (null ()), /* pointer to dev-info table */ 1 19 2 conv_tab_ptr ptr init (null ()), /* pointer to conversion tables */ 1 20 2 compression_in_ptr ptr initial (null ()), 1 21 /* pointer to compression input table */ 1 22 2 compression_out_ptr ptr initial (null ()), 1 23 /* pointer to compression output table */ 1 24 /* parameters of the device */ 1 25 2 keying_time fixed bin (71) init (0), 1 26 /* keying time of device */ 1 27 2 max_col fixed bin init (-1),/* number of columns per line */ 1 28 2 max_line fixed bin init (-1),/* number of lines per frame */ 1 29 2 actcol fixed bin init (0), /* present column */ 1 30 2 actline fixed bin init (0), /* present line */ 1 31 2 actshift unal bit (2) init ("11"b), 1 32 /* present shift */ 1 33 /* modes of the device */ 1 34 2 tabm unal bit (1) init ("1"b), 1 35 /* tabs may be used */ 1 36 2 conm unal bit (1) init ("1"b), 1 37 /* canonicalization should be performed */ 1 38 2 graphic unal bit (1) init ("0"b), 1 39 /* graphic mode */ 1 40 2 escm unal bit (1) init ("1"b), 1 41 /* processing escapes on input */ 1 42 2 erklm unal bit (1) init ("1"b), 1 43 /* erase/kill on */ 1 44 2 rawim unal bit (1) init ("0"b), 1 45 /* raw input mode */ 1 46 2 red_mode unal bit (1) init ("1"b), 1 47 /* red/black shifts may be transmitted */ 1 48 2 escape_out_seen unal bit (1) init ("0"b), 1 49 /* user typed overstruck O-U-T */ 1 50 2 tabsin_mode unal bit (1) init ("0"b), 1 51 /* ON means let tabs thru, OFF means change to spaces */ 1 52 2 hndlquit_mode unal bit (1) init ("1"b), 1 53 /* ON means dim does reset(read write), OFF it doesn't */ 1 54 2 padding unal bit (24), 1 55 2 read_back fixed bin init (0), /* input processing mode */ 1 56 /* info about read/write buffers */ 1 57 2 canonicalization_index fixed bin init (1), /* offset in canonicalization_buffer of next "free" char */ 1 58 2 read_offset fixed bin init (-1),/* offset in canonicalization_buffer of first character */ 1 59 2 character_error_index fixed bin init (-1),/* index of last good character */ 1 60 2 error_mark_column fixed bin init (0), /* column error marker goes in */ 1 61 2 inimax fixed bin init (0), /* index of last char (0-origin) + 1 */ 1 62 2 tab_width fixed bin init (10),/* how wide a tab stop is. */ 1 63 2 baud_rate fixed bin init (0), /* see apl_dim_table.incl.pl1 */ 1 64 2 internal_type unal dim (0:255) bit (9), 1 65 /* copied from device_info.code_move */ 1 66 2 canonicalization_buffer char (512), 1 67 2 normal_read_buffer char (512), 1 68 2 quit_read_buffer char (512); 1 69 1 70 dcl 1 type unal dim (0:255) defined (stream_data_block.internal_type (0)), 1 71 /* indexed by internal code */ 1 72 2 white bit (1), /* on if white space char */ 1 73 2 red bit (1), /* on if red/black shift char */ 1 74 2 action bit (4), /* 0 none, 1 esc, 2 erase, 3 kill, 4 delim, 5 break */ 1 75 2 move bit (3); /* 0=+1, 1=0, 2=-1, 3=tab, 4=cr, 5=nl, 6=np, 7=vt */ 1 76 1 77 /* constants for stream_data_block.read_back field. */ 1 78 1 79 declare read_back_names char (16) dimension (0:2) internal static options (constant) 1 80 initial ("read_back_spaces", "read_back_input", "read_back_output"); 1 81 1 82 dcl ( 1 83 read_back_spaces init (0), /* just keep track of column input starts in */ 1 84 read_back_input init (1), /* just read what user typed */ 1 85 read_back_output init (2) /* remember output & recanonicalize entire line */ 1 86 ) fixed bin internal static options (constant); 1 87 1 88 dcl status bit (72); 1 89 1 90 dcl 1 status_bits based (addr (status)), 1 91 2 status_code fixed bin (35), 1 92 ( 1 93 2 logical_initiation bit (1), 1 94 2 logical_completion bit (1), 1 95 2 physical_initiation bit (1), 1 96 2 physical_completion bit (1), 1 97 2 transaction_terminated bit (1), 1 98 2 unused_42_45 bit (4), 1 99 2 end_of_logical_data bit (1), 1 100 2 end_of_physical_data bit (1), 1 101 2 unused_48_51 bit (4), 1 102 2 stream_detached bit (1), 1 103 2 unused_53 bit (1), 1 104 2 transaction_aborted bit (1), 1 105 2 transaction_index bit (18) 1 106 ) unaligned; 1 107 1 108 /* ------ END INCLUDE SEGMENT apl_dim_sdb.incl.pl1 -------------------------------------- */ 52 2 1 /* ====== BEGIN INCLUDE SEGMENT apl_dim_table.incl.pl1 ==================================== */ 2 2 2 3 dcl (conversion_ptr, device_ptr, sequence_ptr) ptr, 2 4 n fixed bin; 2 5 2 6 dcl ( baud_rate_110 init (0), 2 7 baud_rate_150_or_134 init (1), 2 8 baud_rate_300 init (2), 2 9 baud_rate_1200 init (3) 2 10 ) fixed bin internal static options (constant); 2 11 2 12 2 13 dcl 1 device_info based (device_ptr) aligned, 2 14 2 conversion_offset unal bit (18), 2 15 2 sequence_offset unal bit (18), 2 16 2 compression_in_offset unal bit (18), 2 17 2 compression_out_offset unal bit (18), 2 18 2 device_name unal char (32), 2 19 2 graphic_terminal unal bit (1), 2 20 2 shift_needed unal bit (1), 2 21 2 quit_editing_allowed unal bit (1), 2 22 2 unused_bits_1 unal bit (15), 2 23 2 linefeed_character_device unal bit (9), 2 24 2 escape_character_code unal bit (9), /* internal 8-bit code */ 2 25 2 delay_character unal bit (9), 2 26 2 upper_case unal bit (9), 2 27 2 lower_case unal bit (9), 2 28 2 escape_character_device unal bit (9), /* external 7-bit device */ 2 29 2 default_page_length unal fixed bin (17), 2 30 2 default_line_length unal fixed bin (17), 2 31 2 pad_info dim (0:3) aligned, /* 110, 150, 300, 1200 */ 2 32 3 nl_addend unal fixed bin (17), 2 33 3 nl_multiplier unal fixed bin (17), 2 34 3 tab_addend unal fixed bin (17), 2 35 3 tab_multiplier unal fixed bin (17), 2 36 3 bs_n_pads unal fixed bin (17), /* number of pads after bs. */ 2 37 3 np_n_pads unal fixed bin (17), /* number of pads after new page. */ 2 38 2 editing_prompt varying char (8); 2 39 2 40 dcl 1 conversions based (conversion_ptr) aligned, 2 41 2 out unal dim (0:255) bit (9), /* internal 8-bit code to external 7-bit device */ 2 42 2 in unal dim (0:127) bit (9), /* external 7-bit device to internal 8-bit code */ 2 43 2 code_move unal dim (0:255) bit (9), /* internal movement of code */ 2 44 2 device_move unal dim (0:127) bit (6), /* external movement of device */ 2 45 2 unused_1 unal bit (24), 2 46 2 size fixed bin, 2 47 2 escape dim (0:n refer (conversions.size)), 2 48 3 prefix unal bit (1), 2 49 3 conceal unal bit (1), 2 50 3 unused_2 unal bit (7), 2 51 3 inchar unal bit (9), 2 52 3 outchar unal bit (9), 2 53 3 unused_3 unal bit (9); 2 54 2 55 dcl 1 sequence based (sequence_ptr) aligned, 2 56 2 size unal fixed bin (8), 2 57 2 characters unal dim (sequence.size) bit (9); 2 58 2 59 dcl 1 compression_in based (compression_in_ptr) aligned, 2 60 2 size fixed bin, 2 61 2 compression_string char (compression_in.size); 2 62 2 63 dcl 1 compression_out based (compression_out_ptr) aligned, 2 64 2 size fixed bin, 2 65 2 output_character dim (compression_out.size) unal bit (9); 2 66 2 67 /* ------ END INCLUDE SEGMENT apl_dim_table.incl.pl1 ------------------------------------ */ 53 54 55 /* program */ 56 57 compressing = compression_in_ptr ^= null; 58 tempp = addr (temp); 59 col = 1; /* first copy chars into stack array */ 60 j = 1; /* computing column position */ 61 do i = lowi to lowi + n - 1; 62 tempa (j) = 0; 63 tchar = charp -> char.a (i); /* copy char */ 64 if tchar = "100011000"b /* if special erase */ 65 then do; 66 temp (j).char = "000100011"b; /* erase char */ 67 temp (j).erase = "1"b; /* erase flag on */ 68 end; 69 else if tchar = "100011001"b /* if kill */ 70 then do; 71 temp (j).char = "001000000"b; /* store real kill char */ 72 temp (j).kill = "1"b; /* set switch */ 73 end; 74 else if tchar = "100011010"b /* if character error */ 75 then do; 76 temp (j).char = "011000010"b; /* universal ignored, spacing char */ 77 temp (j).error = "1"b; 78 end; 79 else do; 80 temp (j).char = tchar; 81 end; 82 temp (j).col = col; /* store column where char starts */ 83 move = binary (type (binary (temp (j).char, 9)).move, 3); 84 /* get movement code */ 85 if move = 0 /* +1 (normal) */ 86 then do; 87 col = col + 1; 88 end; 89 else if move = 3 /* tab */ 90 then do; 91 col = col + stream_data_block.tab_width - mod (col, stream_data_block.tab_width); 92 end; 93 else if move = 2 /* bs */ 94 then do; 95 j = j - 1; /* erase from temp array */ 96 if col > 1 /* and backup col */ 97 then col = col - 1; 98 end; 99 else if move = 4 /* cr */ 100 then do; 101 j = j - 1; /* don't keep it */ 102 col = 1; 103 end; 104 else if move = 5 /* nl */ 105 then if tchar = "011000000"b /* QLineFeed */ 106 then temp (j).stop = "1"b; /* force end-of-line at this column */ 107 else do; 108 temp (j).col = col + 250; /* nl is like a big barrier */ 109 col = col + 500; 110 end; 111 j = j + 1; 112 end; 113 114 tempn = j - 1; /* length of temp array */ 115 do i = tempn by -1 to 2; /* sort */ 116 if tempa (i) < tempa (i - 1) /* if inversion */ 117 then do; 118 save = tempa (i - 1); /* save char out of place */ 119 do j = i to tempn while (tempa (j) < save); 120 /* search for correct place */ 121 tempa (j - 1) = tempa (j); /* sliding other chars */ 122 end; 123 tempa (j - 1) = save; /* place found, insert */ 124 end; 125 end; 126 127 sos = 1; /* first character is significant */ 128 tempa (tempn + 1) = 0; 129 130 do i = 1 by 1 while (i <= tempn); /* process erase kill chars */ 131 shortlp: 132 if temp (i).char = "000100000"b /* if blank */ 133 then if temp (i + 1).col = temp (i).col /* and at same col with next char */ 134 then do; 135 do k = i + 1 to tempn; /* delete blank */ 136 tempa (k - 1) = tempa (k); 137 end; 138 tempn = tempn - 1; 139 go to shortlp; 140 end; 141 if temp (i).erase /* only recognize this erase char */ 142 then do; 143 do k = i - 1 by -1 to sos while (temp (k).erase); 144 /* find last existing graphic */ 145 end; 146 if k >= sos /* if something to erase */ 147 then do; 148 if type (binary (temp (k).char, 9)).white 149 /* if erasing white space */ 150 then do j = k by -1 to 1 while (type (binary (temp (j).char, 9)).white); 151 tempa (j) = -1;/* turn the erase flag on */ 152 end; 153 else do; 154 ccol = temp (k).col; 155 do j = k by -1 to 1 while (temp (j).col = ccol); 156 /* else erase all in col */ 157 tempa (j) = -1; 158 /* set the erase bit on */ 159 end; 160 end; 161 end; 162 else sos = i + 1; /* only suceding columns are significant */ 163 end; 164 165 else if temp (i).kill /* if kill char */ 166 then do; 167 if temp (i + 1).erase /* if next char is erase */ 168 then if temp (i + 1).col = temp (i).col 169 /* and at same col */ 170 then go to loop; /* do not kill */ 171 sos = i + 1; /* kill, first significant column is the 172* next column */ 173 end; 174 else if temp (i).stop 175 then do; 176 tempn = i - 1; /* delete LineFeed and rest of line */ 177 do k = i - 1 by -1 while (temp (k).col = temp (i).col); 178 /* and everything in same col */ 179 tempn = tempn - 1; 180 end; 181 end; 182 loop: 183 end; 184 185 j = lowi; /* copy back into string, inserting bs */ 186 col = 1; /* no initial bs */ 187 do i = sos to tempn; 188 if temp (i).erase 189 then go to skip; 190 ncol = temp (i).col; 191 192 if ncol < col /* if backed up */ 193 then do; 194 195 if temp (i).char = temp (i - 1).char 196 then go to skip; /* eliminate duplicate chars in same column */ 197 198 if compressing 199 then do; 200 201 unspec (substr (pair, 1, 1)) = temp (i - 1).char; 202 unspec (substr (pair, 2, 1)) = temp (i).char; 203 pair_index = index (compression_string, pair); 204 205 if 2 * divide (pair_index, 2, 17, 0) = pair_index 206 /* if not found or bad match (even index) */ 207 then if stream_data_block.character_error_index < 0 208 then do; 209 if pair = "ot" & temp (i + 1).char = "001110101"b /* "u" */ 210 & temp (i).col = temp (i + 1).col 211 then stream_data_block.escape_out_seen = "1"b; 212 else stream_data_block.character_error_index = j - 1 - lowi; 213 /* j-1-lowi chars are good */ 214 pair_index = 0; 215 end; 216 else pair_index = 0; 217 else pair_index = divide (pair_index, 2, 17, 0) + 1; 218 219 if pair_index ^= 0 220 then do; 221 temp (i).char = output_character (pair_index); 222 j = j - 1; /* wipe out previous char */ 223 end; 224 225 end; 226 else do; 227 charp -> char.a (j) = "000001000"b; 228 /* insert backspace */ 229 j = j + 1; 230 end; 231 end; 232 233 if temp (i).error /* character error */ 234 then if stream_data_block.character_error_index < 0 235 then stream_data_block.character_error_index = j - lowi; 236 237 charp -> char.a (j) = temp (i).char; /* move char */ 238 j = j + 1; 239 col = ncol; /* remember col */ 240 if type (binary (temp (i).char, 9)).move = "0"b 241 /* if normal +1 char */ 242 then col = col + 1; /* then move ahead 1 */ 243 skip: 244 end; 245 n = j - lowi; /* return new n (might be less) */ 246 return; 247 248 end /* apl_dim_canonicalize_ */; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/29/83 1346.2 apl_dim_canonicalize_.pl1 >special_ldd>on>apl.1129>apl_dim_canonicalize_.pl1 52 1 03/27/82 0429.8 apl_dim_sdb.incl.pl1 >ldd>include>apl_dim_sdb.incl.pl1 53 2 03/27/82 0438.6 apl_dim_table.incl.pl1 >ldd>include>apl_dim_table.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. a based bit(9) array level 2 packed unaligned dcl 42 set ref 63 227* 237* addr builtin function dcl 47 ref 58 binary builtin function dcl 47 ref 83 83 148 148 240 ccol 000120 automatic fixed bin(17,0) dcl 37 set ref 154* 155 char based structure level 1 dcl 42 in procedure "apl_dim_canonicalize_" char 0(27) 000120 automatic bit(9) array level 2 in structure "temp" packed unaligned dcl 28 in procedure "apl_dim_canonicalize_" set ref 66* 71* 76* 80* 83 131 148 148 195 195 201 202 209 221* 237 240 character_error_index 56 based fixed bin(17,0) initial level 2 dcl 1-6 set ref 205 212* 233 233* charp parameter pointer dcl 21 ref 16 63 227 237 col 000100 automatic fixed bin(18,0) dcl 19 in procedure "apl_dim_canonicalize_" set ref 59* 82 87* 87 91* 91 91 96 96* 96 102* 108 109* 109 186* 192 239* 240* 240 col 000120 automatic fixed bin(17,0) array level 2 in structure "temp" packed unaligned dcl 28 in procedure "apl_dim_canonicalize_" set ref 82* 108* 131 131 154 155 167 167 177 177 190 209 209 compressing 000111 automatic bit(1) dcl 21 set ref 57* 198 compression_in based structure level 1 dcl 2-59 compression_in_ptr 40 based pointer initial level 2 dcl 1-6 ref 57 203 203 compression_out based structure level 1 dcl 2-63 compression_out_ptr 42 based pointer initial level 2 dcl 1-6 ref 221 compression_string 1 based char level 2 dcl 2-59 ref 203 divide builtin function dcl 47 ref 205 217 erase 0(18) 000120 automatic bit(1) array level 2 packed unaligned dcl 28 set ref 67* 141 143 167 188 error 0(21) 000120 automatic bit(1) array level 2 packed unaligned dcl 28 set ref 77* 233 escape_out_seen 52(09) based bit(1) initial level 2 packed unaligned dcl 1-6 set ref 209* i 000103 automatic fixed bin(18,0) dcl 19 set ref 61* 63* 115* 116 116 118 119* 130* 130* 131 131 131 135 141 143 162 165 167 167 167 171 174 176 177 177* 187* 188 190 195 195 201 202 209 209 209 221 233 237 240* index builtin function dcl 47 ref 203 internal_type 63 based bit(9) array level 2 packed unaligned dcl 1-6 ref 83 83 148 148 148 148 240 240 j 000104 automatic fixed bin(18,0) dcl 19 set ref 60* 62 66 67 71 72 76 77 80 82 83 95* 95 101* 101 104 108 111* 111 114 119* 119* 121 121* 123 148* 148* 151* 155* 155* 157* 185* 212 222* 222 227 229* 229 233 237 238* 238 245 k 000105 automatic fixed bin(18,0) dcl 19 set ref 135* 136 136* 143* 143* 146 148 148 154 155 177* 177* kill 0(19) 000120 automatic bit(1) array level 2 packed unaligned dcl 28 set ref 72* 165 lowi parameter fixed bin(18,0) dcl 19 ref 16 61 61 185 212 233 245 mod builtin function dcl 47 ref 91 move 000113 automatic fixed bin(3,0) dcl 21 in procedure "apl_dim_canonicalize_" set ref 83* 85 89 93 99 104 move 0(06) defined bit(3) array level 2 in structure "type" packed unaligned dcl 1-70 in procedure "apl_dim_canonicalize_" ref 83 240 n parameter fixed bin(17,0) dcl 2-3 set ref 16 28 61 245* ncol 000101 automatic fixed bin(18,0) dcl 19 set ref 190* 192 239 null builtin function dcl 47 ref 57 output_character 1 based bit(9) array level 2 packed unaligned dcl 2-63 ref 221 pair 000112 automatic char(2) dcl 21 set ref 201* 202* 203 209 pair_index 000110 automatic fixed bin(17,0) dcl 21 set ref 203* 205 205 214* 216* 217* 217 219 221 save 000106 automatic fixed bin(18,0) dcl 19 set ref 118* 119 123 sdb_ptr parameter pointer dcl 1-4 ref 16 57 83 91 91 148 148 203 203 205 209 212 221 233 233 240 size based fixed bin(17,0) level 2 dcl 2-59 ref 203 sos 000102 automatic fixed bin(18,0) dcl 19 set ref 127* 143 146 162* 171* 187 stop 0(20) 000120 automatic bit(1) array level 2 packed unaligned dcl 28 set ref 104* 174 stream_data_block based structure level 1 dcl 1-6 substr builtin function dcl 47 ref 201 202 tab_width 61 based fixed bin(17,0) initial level 2 dcl 1-6 ref 91 91 tchar 000114 automatic bit(9) unaligned dcl 21 set ref 63* 64 69 74 80 104 temp 000120 automatic structure array level 1 dcl 28 set ref 58 tempa based fixed bin(17,0) array dcl 39 set ref 62* 116 116 118 119 121* 121 123* 128* 136* 136 151* 157* tempn 000107 automatic fixed bin(18,0) dcl 19 set ref 114* 115 119 128 130 135 138* 138 176* 179* 179 187 tempp 000116 automatic pointer dcl 21 set ref 58* 62 116 116 118 119 121 121 123 128 136 136 151 157 type defined structure array level 1 packed unaligned dcl 1-70 unspec builtin function dcl 47 set ref 201* 202* white defined bit(1) array level 2 packed unaligned dcl 1-70 ref 148 148 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. baud_rate_110 internal static fixed bin(17,0) initial dcl 2-6 baud_rate_1200 internal static fixed bin(17,0) initial dcl 2-6 baud_rate_150_or_134 internal static fixed bin(17,0) initial dcl 2-6 baud_rate_300 internal static fixed bin(17,0) initial dcl 2-6 conversion_ptr automatic pointer dcl 2-3 conversions based structure level 1 dcl 2-40 device_info based structure level 1 dcl 2-13 device_ptr automatic pointer dcl 2-3 read_back_input internal static fixed bin(17,0) initial dcl 1-82 read_back_names internal static char(16) initial array unaligned dcl 1-79 read_back_output internal static fixed bin(17,0) initial dcl 1-82 read_back_spaces internal static fixed bin(17,0) initial dcl 1-82 sequence based structure level 1 dcl 2-55 sequence_ptr automatic pointer dcl 2-3 status automatic bit(72) unaligned dcl 1-88 status_bits based structure level 1 unaligned dcl 1-90 NAMES DECLARED BY EXPLICIT CONTEXT. apl_dim_canonicalize_ 000013 constant entry external dcl 16 loop 000543 constant label dcl 182 ref 167 shortlp 000305 constant label dcl 131 ref 139 skip 000772 constant label dcl 243 ref 188 195 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1032 1042 1002 1042 Length 1242 1002 10 164 27 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME apl_dim_canonicalize_ 93 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME apl_dim_canonicalize_ 000100 col apl_dim_canonicalize_ 000101 ncol apl_dim_canonicalize_ 000102 sos apl_dim_canonicalize_ 000103 i apl_dim_canonicalize_ 000104 j apl_dim_canonicalize_ 000105 k apl_dim_canonicalize_ 000106 save apl_dim_canonicalize_ 000107 tempn apl_dim_canonicalize_ 000110 pair_index apl_dim_canonicalize_ 000111 compressing apl_dim_canonicalize_ 000112 pair apl_dim_canonicalize_ 000113 move apl_dim_canonicalize_ 000114 tchar apl_dim_canonicalize_ 000116 tempp apl_dim_canonicalize_ 000120 temp apl_dim_canonicalize_ 000120 ccol apl_dim_canonicalize_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_ne_as return alloc_auto_adj mod_fx1 ext_entry NO EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 16 000006 28 000020 57 000025 58 000034 59 000036 60 000040 61 000041 62 000053 63 000056 64 000066 66 000071 67 000075 68 000077 69 000100 71 000102 72 000106 73 000110 74 000111 76 000113 77 000117 78 000121 80 000122 82 000126 83 000132 85 000146 87 000150 88 000151 89 000152 91 000154 92 000164 93 000165 95 000167 96 000171 98 000176 99 000177 101 000201 102 000203 103 000205 104 000206 108 000216 109 000223 111 000225 112 000226 114 000230 115 000233 116 000237 118 000244 119 000246 121 000261 122 000263 123 000265 125 000271 127 000274 128 000276 130 000300 131 000305 135 000322 136 000333 137 000337 138 000341 139 000343 141 000344 143 000347 145 000363 146 000366 148 000370 151 000425 152 000431 154 000435 155 000441 157 000454 159 000460 161 000463 162 000464 163 000467 165 000470 167 000473 171 000507 173 000512 174 000513 176 000516 177 000521 179 000536 180 000540 182 000543 185 000545 186 000550 187 000552 188 000561 190 000565 192 000570 195 000573 198 000605 201 000610 202 000612 203 000615 205 000633 209 000642 212 000663 214 000667 215 000670 216 000671 217 000673 219 000676 221 000700 222 000710 225 000712 227 000713 229 000723 233 000724 237 000741 238 000754 239 000755 240 000757 243 000772 245 000774 246 001000 ----------------------------------------------------------- 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