COMPILATION LISTING OF SEGMENT gcos_syspunch Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/19/82 1544.1 mst Fri 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 /* 12* 13* This procedure takes a segment which contains BCD 14* and/or binary card images in GCOS standard format and 15* produces another segment, NAME.raw, which is 16* acceptable for punching by the daemon in "raw" mode. 17* 18**/ 19 20 /* 21* 22* Written by Dick Snyder ??? 71 23* Modified by P. Haber AUG 73 24* Modified by T. Casey DEC 74 25* Modified by R.H. Morrison MAY 76 26* Modified by S. C. Akers NOV 81 Clean up after termination. 27* Improve modularity. 28* Perform argument validation. 29* Convert to iox_. 30* Change expand_path_ to expand_pathname_. 31* Eliminate use of gcos_gsr_read_. 32* Remove GOTOs. 33* 34**/ 35 36 gcos_syspunch: gspn: proc; 37 38 on condition (cleanup) 39 call syspunch_cleanup; 40 41 call process_arg; /* Check for legal pathname. */ 42 if code = 0 43 then do; 44 45 call attach_input; /* Attach the I/O streams. */ 46 if code = 0 47 then do; 48 49 call attach_output; 50 if code = 0 51 then call convert_file; /* Do the actual work. */ 52 end; 53 54 call syspunch_cleanup; /* Clean up after ourselves */ 55 end; 56 57 return; 58 59 60 attach_input: proc; /* Attach the input stream. */ 61 62 call iox_$attach_name ("gcos_syspunch_input_", 63 in_ptr, 64 "vfile_ " || in_path, 65 (null), 66 code); 67 68 if code = 0 69 then call iox_$open (in_ptr, 1, ("0"b), code); 70 71 if code ^= 0 72 then call com_err_ (code, my_name, "^/^a", in_path); 73 74 return; 75 76 end attach_input; 77 78 /* 79* ****************************************************************************************** 80* ****************************************************************************************** 81* ****************************************************************************************** 82**/ 83 84 attach_output: proc; /* Attach the output stream. */ 85 86 call hcs_$make_seg ((out_dir), out_name, "", 11, out_ptr, code); 87 if code ^= 0 88 then do; 89 if code = error_table_$segknown 90 | code = error_table_$namedup 91 92 then code = 0; /* Certain codes are O.K. */ 93 94 else call com_err_ (code, my_name, "^/^a", out_path); 95 end; 96 97 return; 98 99 end attach_output; 100 101 convert_bcd: proc; /* Convert a BCD card image. */ 102 103 do i = 1 to record_len; /* Put a punch image of BCD char in card image */ 104 105 out_olay.cols (i) = transmog (fixed (bit (in_olay (i), 6), 17)); 106 end; 107 108 do j = i to 80; 109 out_olay.cols (j) = ""b; /* Blank fill remaining columns. */ 110 end; 111 112 call get_record; /* Get the next record. */ 113 114 return; 115 116 end convert_bcd; 117 118 /* 119* ****************************************************************************************** 120* ****************************************************************************************** 121* ****************************************************************************************** 122**/ 123 124 convert_binary: proc; /* Convert binary card image. */ 125 126 i = record_len * 6; /* Get bit length of record. */ 127 outbuf = bits; /* Copy record into output record. */ 128 if i < 960 129 then substr (outbuf, i+1, 960-i) = ""b; /* Zero out rest of punch record. */ 130 131 call get_record; /* Get the next record. */ 132 133 return; 134 135 end convert_binary; 136 137 convert_file: proc; /* Perform the actual conversion. */ 138 139 BLOCK.SIZE, curr_bsn, outindex, words_used = 0; /* Initialize some things. */ 140 data_read, eofsw = "0"b; /* Haven't read anything yet. */ 141 142 call get_record; /* Get a data record. */ 143 144 if ^eofsw 145 & code = 0 146 then data_read = "1"b; /* Remember that we read some data. */ 147 148 149 do while (^eofsw & code = 0); 150 151 outindex = outindex+1; /* Bump output card image index. */ 152 153 if RCW.MEDIA_CODE = 1 /* Binary card image. */ 154 then call convert_binary; 155 156 else if RCW.MEDIA_CODE = 2 /* Hollerith card image. */ 157 then call convert_bcd; 158 159 else do; 160 call com_err_ (0, my_name, 161 "Record not binary or Hollerith card image.^2/^a^5o^10x^a^7d^/", 162 "Block #", BLOCK.BSN, " Record #", outindex); 163 164 code = error_table_$improper_data_format; /* So we get out of the loop */ 165 end; 166 out_ptr = addr (out_olay.next_out_olay); 167 end; 168 169 if code ^= 0 170 then call com_err_ (code, my_name, 171 "^/Error while reading:^/^a", 172 in_path); 173 174 if ^data_read 175 & eofsw 176 then call com_err_ (0, my_name, 177 "No data found on file:^/^a", 178 in_path); 179 180 call hcs_$set_bc ((out_dir), out_name, /* Set bitcount of output seg. */ 181 960*outindex, code); 182 if code ^= 0 183 then call com_err_ (code, my_name, 184 "^/Attempting to set bitcount on: ^/^a", 185 out_path); 186 187 return; 188 189 end convert_file; 190 191 get_record: proc; /* Takes care of reading the 192* the input file and returning 193* a record. */ 194 195 code = 0; /* Start off clean. */ 196 if words_used >= BLOCK.SIZE /* Any more data in this block? */ 197 then do; 198 call iox_$get_chars (in_ptr, addr(BLOCK), 199 1280, how_many, code); 200 201 if code = 0 202 then do; 203 curr_bsn = curr_bsn + 1; /* Bump block counter. */ 204 if BLOCK.BSN = curr_bsn 205 then do; 206 RECORD_PTR = addr(BLOCK.DATA); 207 if RCW.EOF_MARKER = "0"b 208 then do; 209 inp = addrel (RECORD_PTR, 1); 210 words_used = RCW.LENG + 1; 211 record_len = RCW.LENG * 6; 212 if record_len > 80 213 then record_len = 80; 214 end; 215 216 else eofsw = "1"b; 217 end; 218 219 else do; 220 code = error_table_$bad_file; 221 call com_err_ (0,my_name, 222 "Block serial number error while reading block #^5o", 223 curr_bsn, 224 in_path); 225 end; 226 227 end; 228 else if code = error_table_$end_of_info 229 then do; 230 eofsw = "1"b; 231 code = 0; 232 end; 233 else call com_err_ (code, my_name, 234 "^/Error while reading:^/^a", 235 in_path); 236 237 end; 238 239 else do; 240 RECORD_PTR = addrel (RECORD_PTR, (RCW.LENG + 1)); 241 if RCW.EOF_MARKER = "0"b 242 then do; 243 inp = addrel (RECORD_PTR, 1); 244 words_used = words_used + RCW.LENG + 1; 245 record_len = RCW.LENG * 6; 246 if record_len > 80 247 then record_len = 80; 248 end; 249 250 else eofsw = "1"b; 251 end; 252 253 return; 254 255 end get_record; 256 257 process_arg: proc; /* Check the input pathname for legality */ 258 259 code = 1; /* Assume we're gonna fail. 260* It will get reset if we 261* make it to the arg-checker. */ 262 263 call cu_$arg_count (nargs); 264 if nargs < 1 265 then call com_err_ (error_table_$noarg, my_name, 266 "^/You must supply a pathname."); 267 else if nargs > 1 268 then call com_err_ (error_table_$too_many_args, my_name, 269 "^/Only one argument allowed."); 270 else do; 271 272 call cu_$arg_ptr (1, argp, arglen, code); /* Get pathname. */ 273 if code = 0 274 then do; 275 276 input_arg = substr (arg, 1, arglen); /* Chop garbage off end of arg */ 277 278 call expand_pathname_ (input_arg, in_dir, 279 in_name, code); 280 if code = 0 281 then in_path = rtrim (in_dir) 282 || ">" 283 || in_name; 284 285 else call com_err_ (code, my_name, "^/^a", input_arg); 286 287 end; 288 289 else call com_err_ (code, my_name); 290 291 end; 292 293 if code = 0 294 then do; 295 call expand_pathname_$add_suffix ( in_name, /* Build output pathname. */ 296 "raw", 297 out_dir, 298 out_name, 299 code); 300 if code = 0 301 then out_path = rtrim (out_dir) 302 || ">" 303 || out_name; 304 305 else call com_err_ (code, my_name, "^/^a.raw", in_name); 306 end; 307 308 return; 309 310 end process_arg; 311 312 syspunch_cleanup: proc; /* Close files and clean up. */ 313 314 if in_ptr ^= null 315 then do; 316 call iox_$close (in_ptr, code); 317 call iox_$detach_iocb (in_ptr, code); 318 call iox_$destroy_iocb (in_ptr, code); 319 end; 320 321 return; 322 323 end syspunch_cleanup; 324 325 dcl (arglen, i, j, outindex) fixed bin; 326 dcl (argp, inp, out_ptr) pointer; 327 dcl arg char (168) based (argp); 328 dcl bits bit (i) aligned based (inp); 329 dcl code fixed bin (35); 330 dcl curr_bsn fixed bin (35); 331 dcl data_read bit (1); 332 dcl eofsw bit (1); 333 dcl how_many fixed bin (21); 334 dcl in_dir char (168); 335 dcl in_name char (32); 336 dcl in_olay (80) bit (6) unaligned based (inp); 337 dcl in_path char (168); 338 dcl in_ptr pointer init (null); 339 dcl input_arg char (168); 340 dcl my_name char(16) internal static options (constant) 341 init ("gcos_syspunch"); 342 dcl nargs fixed bin; 343 dcl out_dir char (168); 344 dcl out_name char (32); 345 dcl outbuf bit (960) unaligned based (out_ptr); 346 dcl out_path char (168); 347 dcl record_len fixed bin; 348 dcl words_used fixed bin; 349 350 dcl 1 out_olay based (out_ptr) unaligned, 351 2 cols (80) bit (12) unaligned, 352 2 next_out_olay bit (1) unaligned; 353 354 1 1 /* BEGIN INCLUDE FILE gcos_block_overlay.incl.pl1 (Akers SCUdmp) 11/23/81 2115.2 sca Mon */ 1 2 1 3 dcl RECORD_PTR pointer; 1 4 1 5 1 6 dcl 1 BLOCK aligned, 1 7 1 8 2 BSN fixed bin (18) unsigned unaligned, 1 9 2 SIZE fixed bin (18) unsigned unaligned, 1 10 2 DATA char (1276) unaligned; 1 11 1 12 1 13 1 14 dcl 1 RCW based (RECORD_PTR) aligned, 1 15 1 16 2 LENG fixed bin (18) unsigned unaligned, 1 17 2 LAST_CHARS_USED fixed bin (2) unsigned unaligned, 1 18 2 EOF_MARKER bit (4) unaligned, 1 19 2 FILLER bit (2) unaligned, 1 20 2 MEDIA_CODE fixed bin (4) unsigned unaligned, 1 21 2 REPORT_CODE fixed bin(6) unsigned unaligned; 1 22 1 23 1 24 /* END INCLUDE FILE gcos_block_overlay.incl.pl1 */ 355 356 357 dcl cleanup condition; 358 359 dcl ( 360 addr, addrel, bit, fixed, 361 index, null, rtrim, substr 362 ) builtin; 363 364 dcl ( 365 error_table_$bad_file, 366 error_table_$end_of_info, 367 error_table_$improper_data_format, 368 error_table_$namedup, 369 error_table_$noarg, 370 error_table_$segknown, 371 error_table_$too_many_args 372 ) fixed bin(35) ext static; 373 374 dcl cu_$arg_count entry (fixed bin); 375 dcl cu_$arg_ptr ext entry (fixed bin, pointer, fixed bin, fixed bin (35)); 376 dcl com_err_ ext entry options (variable); 377 dcl expand_pathname_ ext entry (char(*), char(*), char(*), fixed bin(35)); 378 dcl expand_pathname_$add_suffix ext entry (char(*), char(*), char(*), char(*), fixed bin(35)); 379 dcl hcs_$set_bc ext entry (char(*), char(*), fixed bin(24), fixed bin(35)); 380 dcl hcs_$make_seg ext entry (char (*) aligned, char (*), char (*), fixed bin (5), pointer, fixed bin (35)); 381 382 dcl (iox_$attach_name entry (char(*), ptr, char(*), ptr, fixed bin(35)), 383 iox_$close entry (ptr, fixed bin(35)), 384 iox_$destroy_iocb entry (ptr, fixed bin(35)), 385 iox_$detach_iocb entry (ptr, fixed bin(35)), 386 iox_$get_chars entry (ptr, ptr, fixed bin(21), fixed bin(21), fixed bin(35)), 387 iox_$open entry (ptr, fixed bin, bit(1) aligned, fixed bin(35)) 388 389 ) external; 390 391 dcl transmog (0: 63) bit (12) aligned internal static init ( 392 393 "001000000000"b, /* 0 */ 394 "000100000000"b, /* 1 */ 395 "000010000000"b, /* 2 */ 396 "000001000000"b, /* 3 */ 397 "000000100000"b, /* 4 */ 398 "000000010000"b, /* 5 */ 399 "000000001000"b, /* 6 */ 400 "000000000100"b, /* 7 */ 401 "000000000010"b, /* 8 */ 402 "000000000001"b, /* 9 */ 403 "000010000010"b, /* [ */ 404 "000001000010"b, /* # */ 405 "000000100010"b, /* @ */ 406 "000000010010"b, /* : */ 407 "000000001010"b, /* > */ 408 "000000000110"b, /* ? */ 409 "000000000000"b, /* blank */ 410 "100100000000"b, /* A */ 411 "100010000000"b, /* B */ 412 "100001000000"b, /* C */ 413 "100000100000"b, /* D */ 414 "100000010000"b, /* E */ 415 "100000001000"b, /* F */ 416 "100000000100"b, /* G */ 417 "100000000010"b, /* H */ 418 "100000000001"b, /* I */ 419 "100000000000"b, /* & */ 420 "100001000010"b, /* . */ 421 "100000100010"b, /* ] */ 422 "100000010010"b, /* ( */ 423 "100000001010"b, /* < */ 424 "100000000110"b, /* \ */ 425 "011000000000"b, /* ^ */ 426 "010100000000"b, /* J */ 427 "010010000000"b, /* K */ 428 "010001000000"b, /* L */ 429 "010000100000"b, /* M */ 430 "010000010000"b, /* N */ 431 "010000001000"b, /* O */ 432 "010000000100"b, /* P */ 433 "010000000010"b, /* Q */ 434 "010000000001"b, /* R */ 435 "010000000000"b, /* - */ 436 "010001000010"b, /* $ */ 437 "010000100010"b, /* * */ 438 "010000010010"b, /* ) */ 439 "010000001010"b, /* ; */ 440 "010000000110"b, /* ' */ 441 "101000000000"b, /* + */ 442 "001100000000"b, /* / */ 443 "001010000000"b, /* S */ 444 "001001000000"b, /* T */ 445 "001000100000"b, /* U */ 446 "001000010000"b, /* V */ 447 "001000001000"b, /* W */ 448 "001000000100"b, /* X */ 449 "001000000010"b, /* Y */ 450 "001000000001"b, /* Z */ 451 "001010000010"b, /* <- (left arrow) */ 452 "001001000010"b, /* , */ 453 "001000100010"b, /* % */ 454 "001000010010"b, /* = */ 455 "001000001010"b, /* " */ 456 "001000000110"b /* ! */ 457 458 ) options (constant); 459 460 end gcos_syspunch; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/19/82 1544.1 gcos_syspunch.pl1 >special_ldd>on>11/19/82>gcos_syspunch.pl1 355 1 03/27/82 0424.8 gcos_block_overlay.incl.pl1 >ldd>include>gcos_block_overlay.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. BLOCK 000472 automatic structure level 1 dcl 1-6 set ref 198 198 BSN 000472 automatic fixed bin(18,0) level 2 packed unsigned unaligned dcl 1-6 set ref 160* 204 DATA 1 000472 automatic char(1276) level 2 packed unaligned dcl 1-6 set ref 206 EOF_MARKER 0(20) based bit(4) level 2 packed unaligned dcl 1-14 ref 207 241 LENG based fixed bin(18,0) level 2 packed unsigned unaligned dcl 1-14 ref 210 211 240 244 245 MEDIA_CODE 0(26) based fixed bin(4,0) level 2 packed unsigned unaligned dcl 1-14 ref 153 156 RCW based structure level 1 dcl 1-14 RECORD_PTR 000470 automatic pointer dcl 1-3 set ref 153 156 206* 207 209 210 211 240* 240 240 241 243 244 245 SIZE 0(18) 000472 automatic fixed bin(18,0) level 2 packed unsigned unaligned dcl 1-6 set ref 139* 196 addr builtin function dcl 359 ref 166 198 198 206 addrel builtin function dcl 359 ref 209 240 243 arg based char(168) unaligned dcl 327 ref 276 arglen 000100 automatic fixed bin(17,0) dcl 325 set ref 272* 276 argp 000104 automatic pointer dcl 326 set ref 272* 276 bit builtin function dcl 359 ref 105 bits based bit dcl 328 ref 127 cleanup 001172 stack reference condition dcl 357 ref 38 code 000112 automatic fixed bin(35,0) dcl 329 set ref 42 46 50 62* 68 68* 71 71* 86* 87 89 89 89* 94* 144 149 164* 169 169* 180* 182 182* 195* 198* 201 220* 228 231* 233* 259* 272* 273 278* 280 285* 289* 293 295* 300 305* 316* 317* 318* cols based bit(12) array level 2 packed unaligned dcl 350 set ref 105* 109* com_err_ 000032 constant entry external dcl 376 ref 71 94 160 169 174 182 221 233 264 267 285 289 305 cu_$arg_count 000026 constant entry external dcl 374 ref 263 cu_$arg_ptr 000030 constant entry external dcl 375 ref 272 curr_bsn 000113 automatic fixed bin(35,0) dcl 330 set ref 139* 203* 203 204 221* data_read 000114 automatic bit(1) unaligned dcl 331 set ref 140* 144* 174 eofsw 000115 automatic bit(1) unaligned dcl 332 set ref 140* 144 149 174 216* 230* 250* error_table_$bad_file 000010 external static fixed bin(35,0) dcl 364 ref 220 error_table_$end_of_info 000012 external static fixed bin(35,0) dcl 364 ref 228 error_table_$improper_data_format 000014 external static fixed bin(35,0) dcl 364 ref 164 error_table_$namedup 000016 external static fixed bin(35,0) dcl 364 ref 89 error_table_$noarg 000020 external static fixed bin(35,0) dcl 364 set ref 264* error_table_$segknown 000022 external static fixed bin(35,0) dcl 364 ref 89 error_table_$too_many_args 000024 external static fixed bin(35,0) dcl 364 set ref 267* expand_pathname_ 000034 constant entry external dcl 377 ref 278 expand_pathname_$add_suffix 000036 constant entry external dcl 378 ref 295 fixed builtin function dcl 359 ref 105 hcs_$make_seg 000042 constant entry external dcl 380 ref 86 hcs_$set_bc 000040 constant entry external dcl 379 ref 180 how_many 000116 automatic fixed bin(21,0) dcl 333 set ref 198* i 000101 automatic fixed bin(17,0) dcl 325 set ref 103* 105 105* 108 126* 127 128 128 128 in_dir 000117 automatic char(168) unaligned dcl 334 set ref 278* 280 in_name 000171 automatic char(32) unaligned dcl 335 set ref 278* 280 295* 305* in_olay based bit(6) array unaligned dcl 336 ref 105 in_path 000201 automatic char(168) unaligned dcl 337 set ref 62 71* 169* 174* 221* 233* 280* in_ptr 000254 automatic pointer initial dcl 338 set ref 62* 68* 198* 314 316* 317* 318* 338* inp 000106 automatic pointer dcl 326 set ref 105 127 209* 243* input_arg 000256 automatic char(168) unaligned dcl 339 set ref 276* 278* 285* iox_$attach_name 000044 constant entry external dcl 382 ref 62 iox_$close 000046 constant entry external dcl 382 ref 316 iox_$destroy_iocb 000050 constant entry external dcl 382 ref 318 iox_$detach_iocb 000052 constant entry external dcl 382 ref 317 iox_$get_chars 000054 constant entry external dcl 382 ref 198 iox_$open 000056 constant entry external dcl 382 ref 68 j 000102 automatic fixed bin(17,0) dcl 325 set ref 108* 109* my_name 000100 constant char(16) initial unaligned dcl 340 set ref 71* 94* 160* 169* 174* 182* 221* 233* 264* 267* 285* 289* 305* nargs 000330 automatic fixed bin(17,0) dcl 342 set ref 263* 264 267 next_out_olay 32(24) based bit(1) level 2 packed unaligned dcl 350 set ref 166 null builtin function dcl 359 ref 62 314 338 out_dir 000331 automatic char(168) unaligned dcl 343 set ref 86 180 295* 300 out_name 000403 automatic char(32) unaligned dcl 344 set ref 86* 180* 295* 300 out_olay based structure level 1 packed unaligned dcl 350 out_path 000413 automatic char(168) unaligned dcl 346 set ref 94* 182* 300* out_ptr 000110 automatic pointer dcl 326 set ref 86* 105 109 127 128 166* 166 outbuf based bit(960) unaligned dcl 345 set ref 127* 128* outindex 000103 automatic fixed bin(17,0) dcl 325 set ref 139* 151* 151 160* 180 record_len 000465 automatic fixed bin(17,0) dcl 347 set ref 103 126 211* 212 212* 245* 246 246* rtrim builtin function dcl 359 ref 280 300 substr builtin function dcl 359 set ref 128* 276 transmog 000000 constant bit(12) initial array dcl 391 ref 105 words_used 000466 automatic fixed bin(17,0) dcl 348 set ref 139* 196 210* 244* 244 NAME DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. index builtin function dcl 359 NAMES DECLARED BY EXPLICIT CONTEXT. attach_input 000351 constant entry internal dcl 60 ref 45 attach_output 000472 constant entry internal dcl 84 ref 49 convert_bcd 000575 constant entry internal dcl 101 ref 156 convert_binary 000643 constant entry internal dcl 124 ref 153 convert_file 000666 constant entry internal dcl 137 ref 50 gcos_syspunch 000302 constant entry external dcl 36 get_record 001167 constant entry internal dcl 191 ref 112 131 142 gspn 000272 constant entry external dcl 36 process_arg 001416 constant entry internal dcl 257 ref 41 syspunch_cleanup 002020 constant entry internal dcl 312 ref 38 54 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2342 2422 2070 2352 Length 2654 2070 60 216 252 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME gspn 1050 external procedure is an external procedure. on unit on line 38 64 on unit attach_input internal procedure shares stack frame of external procedure gspn. attach_output internal procedure shares stack frame of external procedure gspn. convert_bcd internal procedure shares stack frame of external procedure gspn. convert_binary internal procedure shares stack frame of external procedure gspn. convert_file internal procedure shares stack frame of external procedure gspn. get_record internal procedure shares stack frame of external procedure gspn. process_arg internal procedure shares stack frame of external procedure gspn. syspunch_cleanup 70 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME gspn 000100 arglen gspn 000101 i gspn 000102 j gspn 000103 outindex gspn 000104 argp gspn 000106 inp gspn 000110 out_ptr gspn 000112 code gspn 000113 curr_bsn gspn 000114 data_read gspn 000115 eofsw gspn 000116 how_many gspn 000117 in_dir gspn 000171 in_name gspn 000201 in_path gspn 000254 in_ptr gspn 000256 input_arg gspn 000330 nargs gspn 000331 out_dir gspn 000403 out_name gspn 000413 out_path gspn 000465 record_len gspn 000466 words_used gspn 000470 RECORD_PTR gspn 000472 BLOCK gspn THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out call_int_this call_int_other return enable shorten_stack ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_count cu_$arg_ptr expand_pathname_ expand_pathname_$add_suffix hcs_$make_seg hcs_$set_bc iox_$attach_name iox_$close iox_$destroy_iocb iox_$detach_iocb iox_$get_chars iox_$open THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_file error_table_$end_of_info error_table_$improper_data_format error_table_$namedup error_table_$noarg error_table_$segknown error_table_$too_many_args LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 338 000265 36 000271 38 000310 41 000332 42 000333 45 000335 46 000336 49 000340 50 000341 54 000344 57 000350 60 000351 62 000352 68 000415 71 000440 74 000471 84 000472 86 000473 87 000535 89 000537 94 000546 97 000574 101 000575 103 000576 105 000605 106 000624 108 000626 109 000632 110 000637 112 000641 114 000642 124 000643 126 000644 127 000647 128 000654 131 000664 133 000665 137 000666 139 000667 140 000674 142 000676 144 000677 149 000705 151 000711 153 000712 156 000722 160 000726 164 001001 166 001004 167 001011 169 001012 174 001044 180 001101 182 001134 187 001166 191 001167 195 001170 196 001171 198 001175 201 001220 203 001222 204 001226 206 001232 207 001234 209 001237 210 001242 211 001247 212 001252 214 001256 216 001257 217 001261 220 001262 221 001265 227 001321 228 001322 230 001325 231 001327 232 001330 233 001331 237 001360 240 001361 241 001367 243 001372 244 001375 245 001403 246 001406 248 001412 250 001413 253 001415 257 001416 259 001417 263 001421 264 001430 267 001460 272 001506 273 001525 276 001527 278 001534 280 001560 285 001622 287 001652 289 001653 293 001670 295 001672 300 001724 305 001766 308 002016 312 002017 314 002025 316 002032 317 002042 318 002054 321 002066 ----------------------------------------------------------- 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