COMPILATION LISTING OF SEGMENT hasp_util_ Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 12/20/82 1052.8 mst Mon 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 /* format: off */ 12 13 /* Support functions for use by user-ring HASP I/O modules */ 14 15 /* Created: December 1979 by G. Palter */ 16 /* Modified: 13 January 1980 by G. Palter to have the character to be treated as a space for compression/expansion be a 17* parameter rather than fixed as the EBCDIC space character */ 18 /* Modified: 22 July 1981 by G. Palter to compress only spaces in order to increase the performance of HASP I/O switches */ 19 /* Modified: 15 December 1982 by G. Palter to return error_table_$short_record if the expand_text entry reaches the end of 20* the input buffer normally without finding an end-of-record indicator */ 21 22 /* format: on,style4,delnl,insnl,ifthenstmt,ifthen */ 23 24 25 hasp_util_: 26 procedure (); 27 28 return; /* not an entry */ 29 30 31 /* Error returns */ 32 33 OUTPUT_BUFFER_OVERFLOWS: 34 if expand_entry then /* reflect what part was processed */ 35 P_input_text_used = input_text_used - 1; 36 else P_input_text_used = input_text_used; 37 P_output_buffer_used = output_buffer_used; 38 P_code = error_table_$long_record; 39 return; 40 41 BAD_DATA_FORMAT: 42 P_input_text_used = input_text_used - 1; /* this much processed successfully */ 43 P_output_buffer_used = output_buffer_used; 44 P_code = error_table_$improper_data_format; 45 return; 46 47 48 /* Parameters */ 49 50 dcl P_input_text_ptr pointer parameter; /* -> text to be compressed or decompressed (I) */ 51 dcl P_input_text_lth fixed binary (21) parameter; /* length of above text (I) */ 52 dcl P_input_text_used fixed binary (21) parameter; /* amount of above text processed (I/O) */ 53 54 dcl P_output_buffer_ptr pointer parameter; /* -> buffer to hold resulting text (I) */ 55 dcl P_output_buffer_lth fixed binary (21) parameter; /* size of above buffer (I) */ 56 dcl P_output_buffer_used fixed binary (21) parameter; /* amount of above buffer used (I/O) */ 57 58 dcl P_space character (1) aligned parameter; /* treated as a space for compression/expansion (I) */ 59 60 dcl P_code fixed binary (35) parameter; /* status code (O) */ 61 62 63 /* Local copies of parameters */ 64 65 dcl input_text_ptr pointer; 66 dcl (input_text_lth, input_text_used) fixed binary (21); 67 68 dcl output_buffer_ptr pointer; 69 dcl (output_buffer_lth, output_buffer_used) fixed binary (21); 70 71 dcl space character (1); 72 73 74 /* Remaining declarations */ 75 76 dcl input_text character (input_text_lth) unaligned based (input_text_ptr); 77 dcl input_text_array (input_text_lth) character (1) unaligned based (input_text_ptr); 78 79 dcl output_buffer character (output_buffer_lth) unaligned based (output_buffer_ptr); 80 dcl output_buffer_array (output_buffer_lth) character (1) unaligned based (output_buffer_ptr); 81 82 dcl scb_char character (1) unaligned based (scb_char_ptr); 83 dcl 1 scb unaligned based (scb_char_ptr) like hasp_scb_byte; 84 dcl 1 not_compressed_scb unaligned based (scb_char_ptr) like hasp_not_compressed_scb_byte; 85 dcl 1 compressed_scb unaligned based (scb_char_ptr) like hasp_compressed_scb_byte; 86 dcl scb_char_ptr pointer; 87 88 dcl expand_entry bit (1) aligned; /* ON => expand_text entry; OFF => compress_text entry */ 89 90 dcl space_space character (2); 91 92 dcl the_character character (1) unaligned; 93 dcl is_space bit (1) aligned; 94 95 dcl (amount_to_scan, first_duplicate_idx, compression_count, count) fixed binary (21); 96 97 dcl found_eor bit (1) aligned; /* found end-of-record while expanding */ 98 99 /* format: off */ 100 dcl (error_table_$improper_data_format, error_table_$long_record, error_table_$short_record) 101 fixed binary (35) external; 102 /* format: on */ 103 104 dcl (addr, index, min, substr, verify) builtin; 105 106 /* Compress text: apply HASP compression algorithm on the supplied text, placing result into given output buffer */ 107 108 compress_text: 109 entry (P_input_text_ptr, P_input_text_lth, P_input_text_used, P_output_buffer_ptr, P_output_buffer_lth, 110 P_output_buffer_used, P_space, P_code); 111 112 expand_entry = "0"b; 113 114 input_text_ptr = P_input_text_ptr; 115 input_text_lth = P_input_text_lth; 116 input_text_used = P_input_text_used; 117 118 output_buffer_ptr = P_output_buffer_ptr; 119 output_buffer_lth = P_output_buffer_lth; 120 output_buffer_used = P_output_buffer_used; 121 122 space = P_space; 123 space_space = space || space; 124 125 126 call add_scb_char (); /* add an initial SCB for this piece of text */ 127 128 do while (input_text_used < input_text_lth); 129 130 amount_to_scan = 131 min ((input_text_lth - input_text_used), 132 (HASP_MAX_NOT_COMPRESSED_TEXT_LTH - not_compressed_scb.count)); 133 134 first_duplicate_idx = index (substr (input_text, (input_text_used + 1), amount_to_scan), space_space); 135 136 /* do first_duplicate_idx = 1 to (amount_to_scan - 1) */ 137 /* while (substr (input_text, (input_text_used+first_duplicate_idx), 1) */ 138 /* ^= substr (input_text, (input_text_used+first_duplicate_idx+1), 1)); */ 139 /* end; */ 140 /* search for first duplicated character */ 141 142 143 /* if first_duplicate_idx = amount_to_scan */ 144 if first_duplicate_idx = 0 then do; 145 146 /* No duplicates found: in this portion of the text, no duplicate characters were found so this portion will be copied 147* directly to the output buffer. The size of this substring was computed to not overflow the possibly partially-used SCB 148* already at the end of the output buffer */ 149 150 call copy_for_compression (amount_to_scan); 151 if input_text_used < input_text_lth then call add_scb_char (); 152 end; 153 154 155 else do; 156 157 /* Duplicate characters found: copy any portion of the string before these characters; if more than two of this character 158* appears in the string, use the compressed form of the SCB to save space in the output buffer */ 159 160 if first_duplicate_idx > 1 then /* some text appears before the duplicates */ 161 call copy_for_compression (first_duplicate_idx - 1); 162 163 the_character = substr (input_text, (input_text_used + 1), 1); 164 is_space = (the_character = space); 165 compression_count = verify (substr (input_text, (input_text_used + 1)), the_character) - 1; 166 if compression_count = -1 then /* rest of string is the same character */ 167 compression_count = input_text_lth - input_text_used; 168 169 if compression_count > 2 then do; /* compression is possible */ 170 if not_compressed_scb.count = 0 then output_buffer_used = output_buffer_used - 1; 171 count = compression_count; 172 do while (count > 0); 173 call add_scb_char (); 174 scb.not_compressed = "0"b; 175 compressed_scb.not_blank = ^is_space; 176 compressed_scb.count = min (count, HASP_MAX_COMPRESSED_TEXT_LTH); 177 if ^is_space then do; 178 if output_buffer_used = output_buffer_lth then do; 179 output_buffer_used = output_buffer_used - 1; 180 go to OUTPUT_BUFFER_OVERFLOWS; 181 end; /* be sure to flush the SCB before returning */ 182 output_buffer_used = output_buffer_used + 1; 183 substr (output_buffer, output_buffer_used, 1) = the_character; 184 end; 185 count = count - compressed_scb.count; 186 input_text_used = input_text_used + compressed_scb.count; 187 end; 188 if input_text_used < input_text_lth then call add_scb_char (); 189 end; 190 191 else do; /* duplicate is too short to benifit from compression */ 192 call copy_for_compression (compression_count); 193 if (not_compressed_scb.count = HASP_MAX_NOT_COMPRESSED_TEXT_LTH) 194 & (input_text_used < input_text_lth) then 195 call add_scb_char (); 196 end; 197 end; 198 end; 199 200 201 P_input_text_used = input_text_used; /* reflect what was done to caller */ 202 P_output_buffer_used = output_buffer_used; 203 P_code = 0; 204 205 return; 206 207 /* Expand text: apply the inverse of the HASP compression algorithm on the supplied text, placing the result into the 208* given output buffer. If the entire input text is successfully processed but an end-of-record string control byte (SCB) 209* is not found, error_table_$short_record will be returned */ 210 211 expand_text: 212 entry (P_input_text_ptr, P_input_text_lth, P_input_text_used, P_output_buffer_ptr, P_output_buffer_lth, 213 P_output_buffer_used, P_space, P_code); 214 215 expand_entry = "1"b; /* for output overflow error handling */ 216 217 input_text_ptr = P_input_text_ptr; 218 input_text_lth = P_input_text_lth; 219 input_text_used = P_input_text_used; 220 221 output_buffer_ptr = P_output_buffer_ptr; 222 output_buffer_lth = P_output_buffer_lth; 223 output_buffer_used = P_output_buffer_used; 224 225 space = P_space; 226 227 found_eor = "0"b; /* haven't seen EOR yet */ 228 229 230 do while (input_text_used < input_text_lth); 231 232 input_text_used = input_text_used + 1; /* have picked up an SCB */ 233 scb_char_ptr = addr (input_text_array (input_text_used)); 234 235 if scb_char = HASP_EOR_SCB then do; /* found the end of a record */ 236 found_eor = "1"b; 237 go to RETURN_FROM_EXPAND_TEXT; 238 end; 239 240 241 else if scb.not_compressed then do; 242 243 /* A piece of not compressed text: simply copy it to the output buffer */ 244 245 count = not_compressed_scb.count; 246 247 if (input_text_used + count) > input_text_lth then go to BAD_DATA_FORMAT; 248 /* not enough text in input stream */ 249 if (output_buffer_used + count) > output_buffer_lth then go to OUTPUT_BUFFER_OVERFLOWS; 250 251 substr (output_buffer, (output_buffer_used + 1), count) = 252 substr (input_text, (input_text_used + 1), count); 253 254 input_text_used = input_text_used + count; 255 output_buffer_used = output_buffer_used + count; 256 end; 257 258 259 else do; 260 261 /* A piece of compressed text: duplicate the requested character in the output buffer */ 262 263 count = compressed_scb.count; 264 265 if compressed_scb.not_blank then do; /* not space: get the character */ 266 if (input_text_used + 1) > input_text_lth then go to BAD_DATA_FORMAT; 267 input_text_used = input_text_used + 1; 268 the_character = substr (input_text, input_text_used, 1); 269 end; 270 271 else the_character = space; /* compressed character is a space */ 272 273 if (output_buffer_used + count) > output_buffer_lth then go to OUTPUT_BUFFER_OVERFLOWS; 274 275 substr (output_buffer, (output_buffer_used + 1), count) = copy (the_character, count); 276 277 output_buffer_used = output_buffer_used + count; 278 end; 279 end; 280 281 282 RETURN_FROM_EXPAND_TEXT: 283 P_input_text_used = input_text_used; 284 P_output_buffer_used = output_buffer_used; 285 286 if found_eor then /* processing terminated at end-of-record */ 287 P_code = 0; 288 else P_code = error_table_$short_record; /* processing terminated at end of input text */ 289 290 return; 291 292 /* Add an SCB character to the output buffer */ 293 294 add_scb_char: 295 procedure (); 296 297 if output_buffer_used = output_buffer_lth then go to OUTPUT_BUFFER_OVERFLOWS; 298 299 output_buffer_used = output_buffer_used + 1; 300 301 scb_char_ptr = addr (output_buffer_array (output_buffer_used)); 302 303 scb.not_eor = "1"b; 304 scb.not_compressed = "1"b; 305 not_compressed_scb.count = 0; 306 307 return; 308 309 end add_scb_char; 310 311 312 313 /* Copy a piece of text from the input string to the output buffer and update the SCB character count */ 314 315 copy_for_compression: 316 procedure (P_n_characters); 317 318 dcl P_n_characters fixed binary (21) parameter; 319 dcl n_characters fixed binary (21); 320 321 n_characters = P_n_characters; 322 323 if (output_buffer_used + n_characters) > output_buffer_lth then go to OUTPUT_BUFFER_OVERFLOWS; 324 325 substr (output_buffer, (output_buffer_used + 1), n_characters) = 326 substr (input_text, (input_text_used + 1), n_characters); 327 output_buffer_used = output_buffer_used + n_characters; 328 329 not_compressed_scb.count = not_compressed_scb.count + n_characters; 330 331 input_text_used = input_text_used + n_characters; /* advance "pointer" past text already compressed */ 332 333 return; 334 335 end copy_for_compression; 336 1 1 /* BEGIN INCLUDE FILE ... hasp_srcb_scb_bytes.incl.pl1 */ 1 2 /* Created: October 1979 by G. Palter */ 1 3 1 4 /* HASP End-Of-File record */ 1 5 1 6 dcl 1 TEMPLATE_HASP_EOF_RECORD_BITS aligned static options (constant), 1 7 2 srcb bit (9) unaligned initial ("200"b3), /* SRCB -- 200-bit is always ON */ 1 8 2 eor_scb bit (9) unaligned initial ("000"b3); /* SCB -- end of record */ 1 9 1 10 dcl TEMPLATE_HASP_EOF_RECORD character (2) aligned based (addr (TEMPLATE_HASP_EOF_RECORD_BITS)); 1 11 1 12 1 13 /* HASP Sub-Record Control Byte (SRCB) -- operator's console */ 1 14 1 15 dcl HASP_CONSOLE_SRCB_BITS bit (9) aligned static options (constant) initial ("200"b3); 1 16 dcl HASP_CONSOLE_SRCB character (1) aligned based (addr (HASP_CONSOLE_SRCB_BITS)); 1 17 1 18 1 19 /* HASP Sub-Record Control Byte (SRCB) -- reader/punch */ 1 20 1 21 dcl 1 hasp_card_srcb_byte unaligned based (hasp_card_srcb_byte_ptr), 1 22 2 pad1 bit (1) unaligned, /* supplied by MCS */ 1 23 2 mbo1 bit (1) unaligned, /* always ON */ 1 24 2 count_units fixed binary (2) unaligned unsigned, /* SCB count units: 0 => 1; 1 => 2; 2 => 4 */ 1 25 2 binary bit (1) unaligned, /* ON => binary data record */ 1 26 2 mbz1 bit (4) unaligned; /* always OFF */ 1 27 1 28 dcl hasp_card_srcb_byte_ptr pointer; 1 29 1 30 dcl 1 TEMPLATE_HASP_CARD_SRCB_BITS aligned static options (constant), 1 31 2 pad1 bit (1) unaligned initial ("0"b), 1 32 2 mbo1 bit (1) unaligned initial ("1"b), 1 33 2 count_units fixed binary (2) unaligned unsigned initial (0), /* SCB counts single characters */ 1 34 2 binary bit (1) unaligned initial ("0"b), /* not binary card */ 1 35 2 mbz1 bit (4) unaligned initial ("0000"b); 1 36 1 37 dcl TEMPLATE_HASP_CARD_SRCB character (1) aligned based (addr (TEMPLATE_HASP_CARD_SRCB_BITS)); 1 38 1 39 1 40 /* HASP Sub-Record Control Byte (SRCB) -- printer */ 1 41 1 42 dcl 1 hasp_printer_srcb_byte unaligned based (hasp_printer_srcb_byte_ptr), 1 43 2 pad1 bit (1) unaligned, /* supplied by MCS */ 1 44 2 mbo1 bit (1) unaligned, /* always ON */ 1 45 2 mbz1 bit (1) unaligned, /* always OFF */ 1 46 2 prespace bit (1) unaligned, /* ON => pre-spacing; OFF => post-spacing */ 1 47 2 skip_to_channel bit (1) unaligned, /* ON => skip to given channel; OFF => skip # lines */ 1 48 2 number fixed binary (4) unaligned unsigned; /* channel # or # or lines to skip */ 1 49 1 50 dcl hasp_printer_srcb_byte_ptr pointer; 1 51 1 52 dcl 1 TEMPLATE_HASP_PRINTER_SRCB_BITS aligned static options (constant), 1 53 2 pad1 bit (1) unaligned initial ("0"b), 1 54 2 mbo1 bit (1) unaligned initial ("1"b), 1 55 2 mbz1 bit (1) unaligned initial ("0"b), 1 56 2 prespace bit (1) unaligned initial ("0"b), /* post-spacing */ 1 57 2 skip_to_channel bit (1) unaligned initial ("0"b), /* # of lines */ 1 58 2 number fixed binary (4) unaligned unsigned initial (1); 1 59 1 60 dcl TEMPLATE_HASP_PRINTER_SRCB character (1) aligned based (addr (TEMPLATE_HASP_PRINTER_SRCB_BITS)); 1 61 1 62 dcl HASP_MAX_SLEW_COUNT fixed binary static options (constant) initial (3); 1 63 /* max slew of 3 insures proper operation with 370's */ 1 64 1 65 dcl 1 HASP_FORMS_CHANGE_SRCB_BITS aligned static options (constant), 1 66 2 pad1 bit (1) unaligned initial ("0"b), 1 67 2 mbo1 bit (1) unaligned initial ("1"b), 1 68 2 mbz1 bit (1) unaligned initial ("0"b), 1 69 2 change bit (6) unaligned initial ("16"b3); /* change forms record */ 1 70 1 71 dcl HASP_FORMS_CHANGE_SRCB character (1) aligned based (addr (HASP_FORMS_CHANGE_SRCB_BITS)); 1 72 1 73 1 74 /* HASP String Control Byte (SCB) */ 1 75 1 76 dcl 1 hasp_scb_byte unaligned based (hasp_scb_byte_ptr), 1 77 2 pad1 bit (1) unaligned, /* supplied by MCS */ 1 78 2 not_eor bit (1) unaligned, /* ON => not an end of record indicator */ 1 79 2 not_compressed bit (1) unaligned, /* ON => this SCB refers to a non-compressed string */ 1 80 2 variant bit (6) unaligned; /* dependent on setting of hasp_scb_byte.not_compressed */ 1 81 1 82 dcl 1 hasp_not_compressed_scb_byte unaligned based (hasp_scb_byte_ptr), 1 83 2 pad1 bit (1) unaligned, 1 84 2 not_eor bit (1) unaligned, 1 85 2 not_compressed bit (1) unaligned, /* ON */ 1 86 2 count fixed binary (6) unaligned unsigned; /* # of characters in string following the SCB */ 1 87 1 88 dcl 1 hasp_compressed_scb_byte unaligned based (hasp_scb_byte_ptr), 1 89 2 pad1 bit (1) unaligned, 1 90 2 not_eor bit (1) unaligned, 1 91 2 not_compressed bit (1) unaligned, /* OFF */ 1 92 2 not_blank bit (1) unaligned, /* ON => repeated character isn't a blank and follows SCB */ 1 93 2 count fixed binary (5) unaligned unsigned; /* # of occurrences of the character */ 1 94 1 95 dcl hasp_scb_byte_ptr pointer; 1 96 1 97 dcl HASP_EOR_SCB_BITS bit (9) aligned static options (constant) initial ("000"b3); 1 98 dcl HASP_EOR_SCB character (1) aligned based (addr (HASP_EOR_SCB_BITS)); 1 99 1 100 dcl (HASP_MAX_NOT_COMPRESSED_TEXT_LTH initial (62), /* # of characters representable by a single SCB */ 1 101 HASP_MAX_COMPRESSED_TEXT_LTH initial (31)) /* # of occurences of a character representable by 1 102* a single SCB */ 1 103 fixed binary static options (constant); 1 104 1 105 /* END INCLUDE FILE ... hasp_srcb_scb_bytes.incl.pl1 */ 337 338 339 end hasp_util_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 12/20/82 1052.8 hasp_util_.pl1 >spec>on>12/20/82>hasp_util_.pl1 337 1 03/27/82 0436.6 hasp_srcb_scb_bytes.incl.pl1 >ldd>include>hasp_srcb_scb_bytes.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. HASP_EOR_SCB based char(1) dcl 1-98 ref 235 HASP_EOR_SCB_BITS constant bit(9) initial dcl 1-97 set ref 235 HASP_MAX_COMPRESSED_TEXT_LTH constant fixed bin(17,0) initial dcl 1-100 ref 176 HASP_MAX_NOT_COMPRESSED_TEXT_LTH constant fixed bin(17,0) initial dcl 1-100 ref 130 193 P_code parameter fixed bin(35,0) dcl 60 set ref 38* 44* 108 203* 211 286* 288* P_input_text_lth parameter fixed bin(21,0) dcl 51 ref 108 115 211 218 P_input_text_ptr parameter pointer dcl 50 ref 108 114 211 217 P_input_text_used parameter fixed bin(21,0) dcl 52 set ref 33* 36* 41* 108 116 201* 211 219 282* P_n_characters parameter fixed bin(21,0) dcl 318 ref 315 321 P_output_buffer_lth parameter fixed bin(21,0) dcl 55 ref 108 119 211 222 P_output_buffer_ptr parameter pointer dcl 54 ref 108 118 211 221 P_output_buffer_used parameter fixed bin(21,0) dcl 56 set ref 37* 43* 108 120 202* 211 223 284* P_space parameter char(1) dcl 58 ref 108 122 211 225 addr builtin function dcl 104 ref 233 235 301 amount_to_scan 000120 automatic fixed bin(21,0) dcl 95 set ref 130* 134 150* compressed_scb based structure level 1 packed unaligned dcl 85 compression_count 000122 automatic fixed bin(21,0) dcl 95 set ref 165* 166 166* 169 171 192* count 0(03) based fixed bin(6,0) level 2 in structure "not_compressed_scb" packed unsigned unaligned dcl 84 in procedure "hasp_util_" set ref 130 170 193 245 305* 329* 329 count 000123 automatic fixed bin(21,0) dcl 95 in procedure "hasp_util_" set ref 171* 172 176 185* 185 245* 247 249 251 251 254 255 263* 273 275 275 277 count 0(04) based fixed bin(5,0) level 2 in structure "compressed_scb" packed unsigned unaligned dcl 85 in procedure "hasp_util_" set ref 176* 185 186 263 error_table_$improper_data_format 000010 external static fixed bin(35,0) dcl 100 ref 44 error_table_$long_record 000012 external static fixed bin(35,0) dcl 100 ref 38 error_table_$short_record 000014 external static fixed bin(35,0) dcl 100 ref 288 expand_entry 000114 automatic bit(1) dcl 88 set ref 33 112* 215* first_duplicate_idx 000121 automatic fixed bin(21,0) dcl 95 set ref 134* 144 160 160 found_eor 000124 automatic bit(1) dcl 97 set ref 227* 236* 286 hasp_compressed_scb_byte based structure level 1 packed unaligned dcl 1-88 hasp_not_compressed_scb_byte based structure level 1 packed unaligned dcl 1-82 hasp_scb_byte based structure level 1 packed unaligned dcl 1-76 index builtin function dcl 104 ref 134 input_text based char unaligned dcl 76 ref 134 163 165 251 268 325 input_text_array based char(1) array unaligned dcl 77 set ref 233 input_text_lth 000102 automatic fixed bin(21,0) dcl 66 set ref 115* 128 130 134 151 163 165 166 188 193 218* 230 247 251 266 268 325 input_text_ptr 000100 automatic pointer dcl 65 set ref 114* 134 163 165 217* 233 251 268 325 input_text_used 000103 automatic fixed bin(21,0) dcl 66 set ref 33 36 41 116* 128 130 134 151 163 165 166 186* 186 188 193 201 219* 230 232* 232 233 247 251 254* 254 266 267* 267 268 282 325 331* 331 is_space 000117 automatic bit(1) dcl 93 set ref 164* 175 177 min builtin function dcl 104 ref 130 176 n_characters 000142 automatic fixed bin(21,0) dcl 319 set ref 321* 323 325 325 327 329 331 not_blank 0(03) based bit(1) level 2 packed unaligned dcl 85 set ref 175* 265 not_compressed 0(02) based bit(1) level 2 packed unaligned dcl 83 set ref 174* 241 304* not_compressed_scb based structure level 1 packed unaligned dcl 84 not_eor 0(01) based bit(1) level 2 packed unaligned dcl 83 set ref 303* output_buffer based char unaligned dcl 79 set ref 183* 251* 275* 325* output_buffer_array based char(1) array unaligned dcl 80 set ref 301 output_buffer_lth 000106 automatic fixed bin(21,0) dcl 69 set ref 119* 178 183 222* 249 251 273 275 297 323 325 output_buffer_ptr 000104 automatic pointer dcl 68 set ref 118* 183 221* 251 275 301 325 output_buffer_used 000107 automatic fixed bin(21,0) dcl 69 set ref 37 43 120* 170* 170 178 179* 179 182* 182 183 202 223* 249 251 255* 255 273 275 277* 277 284 297 299* 299 301 323 325 327* 327 scb based structure level 1 packed unaligned dcl 83 scb_char based char(1) unaligned dcl 82 ref 235 scb_char_ptr 000112 automatic pointer dcl 86 set ref 130 170 174 175 176 185 186 193 233* 235 241 245 263 265 301* 303 304 305 329 329 space 000110 automatic char(1) unaligned dcl 71 set ref 122* 123 123 164 225* 271 space_space 000115 automatic char(2) unaligned dcl 90 set ref 123* 134 substr builtin function dcl 104 set ref 134 163 165 183* 251* 251 268 275* 325* 325 the_character 000116 automatic char(1) unaligned dcl 92 set ref 163* 164 165 183 268* 271* 275 verify builtin function dcl 104 ref 165 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. HASP_CONSOLE_SRCB based char(1) dcl 1-16 HASP_CONSOLE_SRCB_BITS internal static bit(9) initial dcl 1-15 HASP_FORMS_CHANGE_SRCB based char(1) dcl 1-71 HASP_FORMS_CHANGE_SRCB_BITS internal static structure level 1 dcl 1-65 HASP_MAX_SLEW_COUNT internal static fixed bin(17,0) initial dcl 1-62 TEMPLATE_HASP_CARD_SRCB based char(1) dcl 1-37 TEMPLATE_HASP_CARD_SRCB_BITS internal static structure level 1 dcl 1-30 TEMPLATE_HASP_EOF_RECORD based char(2) dcl 1-10 TEMPLATE_HASP_EOF_RECORD_BITS internal static structure level 1 dcl 1-6 TEMPLATE_HASP_PRINTER_SRCB based char(1) dcl 1-60 TEMPLATE_HASP_PRINTER_SRCB_BITS internal static structure level 1 dcl 1-52 hasp_card_srcb_byte based structure level 1 packed unaligned dcl 1-21 hasp_card_srcb_byte_ptr automatic pointer dcl 1-28 hasp_printer_srcb_byte based structure level 1 packed unaligned dcl 1-42 hasp_printer_srcb_byte_ptr automatic pointer dcl 1-50 hasp_scb_byte_ptr automatic pointer dcl 1-95 NAMES DECLARED BY EXPLICIT CONTEXT. BAD_DATA_FORMAT 000034 constant label dcl 41 ref 247 266 OUTPUT_BUFFER_OVERFLOWS 000014 constant label dcl 33 ref 180 249 273 297 323 RETURN_FROM_EXPAND_TEXT 000530 constant label dcl 282 ref 237 add_scb_char 000545 constant entry internal dcl 294 ref 126 151 173 188 193 compress_text 000055 constant entry external dcl 108 copy_for_compression 000572 constant entry internal dcl 315 ref 150 160 192 expand_text 000346 constant entry external dcl 211 hasp_util_ 000006 constant entry external dcl 25 NAME DECLARED BY CONTEXT OR IMPLICATION. copy builtin function ref 275 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 744 762 651 754 Length 1150 651 16 151 73 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME hasp_util_ 100 external procedure is an external procedure. add_scb_char internal procedure shares stack frame of external procedure hasp_util_. copy_for_compression internal procedure shares stack frame of external procedure hasp_util_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME hasp_util_ 000100 input_text_ptr hasp_util_ 000102 input_text_lth hasp_util_ 000103 input_text_used hasp_util_ 000104 output_buffer_ptr hasp_util_ 000106 output_buffer_lth hasp_util_ 000107 output_buffer_used hasp_util_ 000110 space hasp_util_ 000112 scb_char_ptr hasp_util_ 000114 expand_entry hasp_util_ 000115 space_space hasp_util_ 000116 the_character hasp_util_ 000117 is_space hasp_util_ 000120 amount_to_scan hasp_util_ 000121 first_duplicate_idx hasp_util_ 000122 compression_count hasp_util_ 000123 count hasp_util_ 000124 found_eor hasp_util_ 000142 n_characters copy_for_compression THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as return shorten_stack ext_entry repeat set_cs_eis verify_eis NO EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$improper_data_format error_table_$long_record error_table_$short_record LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 25 000005 28 000013 33 000014 36 000023 37 000026 38 000030 39 000033 41 000034 43 000040 44 000042 45 000045 108 000046 112 000062 114 000063 115 000067 116 000071 118 000073 119 000076 120 000100 122 000102 123 000105 126 000110 128 000111 130 000114 134 000134 144 000147 150 000150 151 000152 152 000156 160 000157 163 000165 164 000173 165 000177 166 000211 169 000216 170 000220 171 000231 172 000233 173 000235 174 000236 175 000242 176 000250 177 000261 178 000271 179 000274 180 000276 182 000277 183 000300 185 000305 186 000307 187 000311 188 000312 189 000316 192 000317 193 000321 198 000335 201 000336 202 000340 203 000342 205 000343 211 000344 215 000353 217 000355 218 000361 219 000363 221 000365 222 000370 223 000372 225 000374 227 000377 230 000400 232 000403 233 000404 235 000412 236 000416 237 000420 241 000421 245 000425 247 000433 249 000436 251 000442 254 000453 255 000455 256 000456 263 000457 265 000465 266 000471 267 000475 268 000476 269 000503 271 000504 273 000506 275 000512 277 000525 279 000527 282 000530 284 000533 286 000535 288 000541 290 000544 294 000545 297 000546 299 000551 301 000552 303 000560 304 000563 305 000566 307 000571 315 000572 321 000574 323 000576 325 000601 327 000613 329 000615 331 000631 333 000633 ----------------------------------------------------------- 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