COMPILATION LISTING OF SEGMENT calcomp_915_ Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/18/82 1632.4 mst Thu 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 calcomp_915_: proc; 12 13 /* This module is a graphic support procedure for the CalComp 915/1036 plotter. 14* Written Dec. 1974 by C. D. Tavares */ 15 /* Modified 03/20/75 by CDT to remove call to read_list_ to get tape number, since it 16* parsed out the ",7track" suffix! */ 17 /* Modified by C. D. Tavares 03/26/75 to use the new open and close keywords in the GDT 18* to expedite detaching of the tape stream without having the hack in remove_graphics. */ 19 /* Last modified 09/29/75 by CDT to note that pen is up whenever doing a pen_select. 20* This is a curious feature of 915 which is not shared by their other products, and not documented. */ 21 22 return; 23 1 1 /* -------- BEGIN include file graphic_device_table.incl.pl1 ----------- */ 1 2 1 3 dcl gdt_version_2 fixed bin static initial (2); 1 4 1 5 dcl gdt_pointer pointer; 1 6 1 7 dcl 1 graphic_device_table aligned based (gdt_pointer), 1 8 2 device_data aligned, 1 9 3 version_number fixed bin, 1 10 3 terminal_name char (32) aligned, 1 11 3 terminal_type char (4) aligned, 1 12 3 charsizes (3) float bin, 1 13 3 message_size fixed bin (35) aligned, 1 14 3 points_per_inch float bin (63), 1 15 3 pad (10) fixed bin aligned, 1 16 2 effector_data (32 : 70) aligned, 1 17 3 force_alignment aligned, 1 18 4 (expand, call, ignore, error, flush) bit (1) unaligned; 1 19 1 20 dcl (Reference initial (37), 1 21 Process_input initial (64), 1 22 Prepare_for_graphics initial (65), 1 23 Prepare_for_text initial (66), 1 24 Expansion initial (67), 1 25 Open initial (68), 1 26 Close initial (69), 1 27 Modes initial (70)) fixed bin static options (constant); 1 28 1 29 /* --------- END include file graphic_device_table.incl.pl1 ------------ */ 24 25 26 dcl 1 USASCII static aligned, 27 2 control_chars char (32) unaligned initial ((32) ""), /* translate controls to space (- o40) */ 28 2 space_to_rightbracket char (62) unaligned, 29 2 nonimplemented char (3) unaligned initial (" "), 30 2 lowercase char (26) unaligned, 31 2 nonimplemented2 char (5) unaligned initial ((5) ""); 32 33 dcl symbol_mode char (3) aligned static, /* initialized in enter_graphic_mode */ 34 sm_ninebit (0:2) bit (9) unaligned based (addr (symbol_mode)), 35 char_size fixed bin (35) static, 36 cs_sixbit (6) bit (6) unaligned based (addr (char_size)); 37 38 position: entry (effector, instring, outstring, n_chars_out); 39 40 dcl (effector, n_chars_out) fixed bin parameter, 41 (instring, outstring) char (*) parameter; 42 43 dcl graphic_code_util_$decode_spi ext entry (pointer, fixed bin, (*) fixed bin), 44 graphic_code_util_$decode_dpi ext entry (pointer, fixed bin, (*) fixed bin), 45 (graphic_code_util_$decode_scl, 46 graphic_code_util_$decode_scl_nozero) ext entry (pointer, fixed bin, (*) float bin); 47 48 dcl graphic_matrix_util_$make_matrix ext entry ((3) fixed bin, (3) float bin, (3, 3) float bin), 49 graphic_matrix_util_$multiply_3x3_x_1x3 ext entry ((3, 3) float bin, (3) float bin, (3) float bin); 50 51 dcl (addr, substr, round, max, min, divide, collate, string) builtin; 52 53 dcl instring_array (262144) char (1) defined (instring) position (1); 54 55 dcl (pen_is_down, pen_is_satisfied, maps_active, visible) bit (1) aligned static; 56 57 dcl (matrix (3, 3), 58 identity_matrix (3, 3) initial 59 (1e0, 0e0, 0e0, 0e0, 1e0, 0e0, 0e0, 0e0, 1e0)) float bin static; 60 61 dcl ((pen_wants_at, pen_is_at_in_CC_units) static, xyz_temp, xyz_temp2, array_copy) (3) float bin; 62 dcl round_copy (3) fixed bin (35, 7); 63 64 dcl limiting bit (1) aligned static initial ("1"b), 65 erased bit (1) static initial ("0"b) aligned; 66 67 dcl plot_command bit (5) initial ("00001"b) aligned static, 68 (pen_up initial (""), pen_down initial ("")) char (1) aligned static; 69 70 dcl (rotations fixed, scalings float) bin static dimension (3); 71 72 dcl i fixed bin (21), 73 j fixed bin, 74 float_array (3) float bin, 75 fixed_array (3) fixed bin; 76 77 dcl 1 stack (0:20) aligned static, /* to keep track of abs position */ 78 2 node_val char (3) aligned, /* NOTE: 20 is currently max depth. pl1 wouldn't */ 79 2 xyz_copy (3) float bin, /* allow an exprn here. This may have to be changed. */ 80 2 pen_is_satisfied_copy bit (1) aligned; 81 82 dcl stack_depth fixed bin static initial (0); 83 84 dcl scale float bin static initial (0), 85 scale_not_settable bit (1) aligned initial (""b) static, 86 paper_size float bin static initial (11.0), /* comes in 2 sizes: 11.0 and 33.5 */ 87 points_per_inch fixed bin static initial (1000), 88 quadrant_size float bin static initial (650.0); 89 90 n_chars_out = 0; /* initialize output count */ 91 92 call graphic_code_util_$decode_scl (addr (instring_array (2)), 3, xyz_temp); /* get coord values */ 93 94 if maps_active then do; /* map into rotated or scaled coords */ 95 xyz_temp2 = xyz_temp; /* because (xyz_temp) in call blows up pl1 */ 96 call graphic_matrix_util_$multiply_3x3_x_1x3 (matrix, xyz_temp2, xyz_temp); 97 end; /* kerchunk goes the grinder */ 98 99 goto pos (effector); /* handle by type */ 100 101 pos (48): pos (49): /* setposition and setpoint */ 102 pen_wants_at = xyz_temp; /* set to abs position */ 103 pen_is_satisfied = ""b; /* say we haven't put it out yet */ 104 105 if effector = 49 then goto draw_point; /* draw the point */ 106 return; 107 108 pos (50): xyz_temp = pen_wants_at + xyz_temp; /* add to abs position */ 109 call draw_to (xyz_temp); /* draw the vector */ 110 return; 111 112 pos (51): pen_wants_at = pen_wants_at + xyz_temp; /* add shift to abs position */ 113 pen_is_satisfied = ""b; /* don't bother to put it out yet */ 114 return; 115 116 pos (52): pen_wants_at = pen_wants_at + xyz_temp; /* add shift to abs position */ 117 pen_is_satisfied = ""b; /* don't bother to put it out yet */ 118 draw_point: 119 call draw_to (pen_wants_at); /* draw the point */ 120 do i = 3, -3; /* got to do a little cha-cha to make */ 121 pen_wants_at (1) = pen_wants_at (1) + i; /* a visible point appear */ 122 call draw_to (pen_wants_at); /* so we draw a little square */ 123 pen_wants_at (2) = pen_wants_at (2) + i; /* and say take it or leave it. */ 124 call draw_to (pen_wants_at); 125 end; 126 127 return; 128 129 130 131 node_in: entry (effector, instring, outstring, n_chars_out); 132 133 dcl subscriptrange condition; 134 135 n_chars_out = 0; /* we swallow them */ 136 stack (stack_depth).xyz_copy (*) = pen_wants_at (*); /* copy where we are */ 137 stack (stack_depth).pen_is_satisfied_copy = pen_is_satisfied; /* copy if we really are */ 138 139 stack_depth = stack_depth + 1; /* push the stack */ 140 if stack_depth > hbound (stack, 1) then signal subscriptrange; /* just in case */ 141 142 stack (stack_depth).node_val = substr (instring, 3, 3); /* copy identifier */ 143 return; 144 145 node_out: entry (effector, instring, outstring, n_chars_out); 146 147 n_chars_out = 0; /* we swallow these too */ 148 stack_depth = stack_depth - 1; /* pop the stack */ 149 if stack_depth < 0 then signal subscriptrange; /* just in case */ 150 151 return; 152 153 expansion: entry (effector, instring, outstring, n_chars_out); 154 155 dcl no_node_match condition; 156 157 n_chars_out = 0; /* no output needed */ 158 do i = stack_depth to 1 by -1 while (substr (instring, 3, 3) ^= stack (i).node_val); 159 end; /* find where we've expanded to */ 160 161 if i < 1 then signal no_node_match; /* should NEVER happen */ 162 163 stack_depth = i - 1; /* pop stack to here again */ 164 pen_is_satisfied = stack (stack_depth).pen_is_satisfied_copy; /* copy all current position */ 165 pen_wants_at (*) = stack (stack_depth).xyz_copy (*); /* indicators from where we were */ 166 167 return; 168 169 170 open: entry (effector, instring, outstring, n_chars_out); 171 172 dcl char1 char (1) aligned, 173 bit9 bit (9) aligned based (addr (char1)); 174 175 dcl search_address fixed bin static, 176 sa_sixbit (6) unaligned bit (6) based (addr (search_address)); 177 178 dcl iox_$get_line ext entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 179 iox_$user_input ext pointer, 180 ioa_$nnl ext entry options (variable), 181 tape_number char (168), 182 iox_$attach_ioname ext entry (char (*), pointer, char (*), fixed bin (35)), 183 iox_$open ext entry (pointer, fixed bin, bit (1) aligned, fixed bin (35)); 184 185 dcl iocb_ptr pointer static; 186 2 1 /* Begin include file ..... iox_modes.incl.pl1 */ 2 2 2 3 /* Written by C. D. Tavares, 03/17/75 */ 2 4 /* Updated 10/31/77 by CDT to include short iox mode strings */ 2 5 2 6 dcl iox_modes (13) char (24) int static options (constant) aligned initial 2 7 ("stream_input", "stream_output", "stream_input_output", 2 8 "sequential_input", "sequential_output", "sequential_input_output", "sequential_update", 2 9 "keyed_sequential_input", "keyed_sequential_output", "keyed_sequential_update", 2 10 "direct_input", "direct_output", "direct_update"); 2 11 2 12 dcl short_iox_modes (13) char (4) int static options (constant) aligned initial 2 13 ("si", "so", "sio", "sqi", "sqo", "sqio", "squ", "ksqi", "ksqo", "ksqu", "di", "do", "du"); 2 14 2 15 dcl (Stream_input initial (1), 2 16 Stream_output initial (2), 2 17 Stream_input_output initial (3), 2 18 Sequential_input initial (4), 2 19 Sequential_output initial (5), 2 20 Sequential_input_output initial (6), 2 21 Sequential_update initial (7), 2 22 Keyed_sequential_input initial (8), 2 23 Keyed_sequential_output initial (9), 2 24 Keyed_sequential_update initial (10), 2 25 Direct_input initial (11), 2 26 Direct_output initial (12), 2 27 Direct_update initial (13)) fixed bin int static options (constant); 2 28 2 29 /* End include file ..... iox_modes.incl.pl1 */ 187 188 189 dcl search_marker char (1) aligned static initial (""); 190 191 n_chars_out = 0; /* initialize output count */ 192 193 get_tape: 194 call ioa_$nnl ("Type number of tape to be mounted: "); /* hey you... */ 195 call iox_$get_line (iox_$user_input, addr (tape_number), 168, i, code); 196 if i = 1 then goto get_tape; /* Hm. Shaky fingers. */ 197 198 substr (tape_number, i) = " "; /* kill newline */ 199 200 call iox_$attach_ioname (instring, iocb_ptr, "calcomp_915_dim_ " || tape_number, code); 201 /* use calcomp_915_dim_ for formatting */ 202 if code ^= 0 then do; 203 complain: n_chars_out = - code; /* the defined way of complaining */ 204 return; 205 end; 206 207 call iox_$open (iocb_ptr, Stream_output, ""b, code); 208 if code ^= 0 then goto complain; 209 210 space_to_rightbracket = substr (collate (), 1, 62); /* 915 works on modified USASCII */ 211 lowercase = substr (collate (), 34, 26); /* uppercase-only type of code. Barf. */ 212 213 scale_not_settable = "1"b; 214 215 return; 216 217 218 enter_graphic_mode: entry (effector, instring, outstring, n_chars_out); 219 220 search_address = 1; /* useful feature of 915 controller. */ 221 call put_out_search_address; /* you can search for plots by the numbers */ 222 223 put_out_search_address: proc; 224 225 call put_out (search_marker); /* I am a search address */ 226 227 do i = 4 to 6; 228 bit9 = "000"b || sa_sixbit (i); /* my address is: */ 229 call put_out (char1); 230 end; 231 232 search_address = search_address + 1; /* bump */ 233 234 end; 235 236 if scale = 0 then call set_scale (paper_size); 237 238 set_scale: proc (ps); 239 240 dcl ps float bin; 241 242 scale = ps * points_per_inch / (2 * quadrant_size); /* this should be very clear */ 243 char_size = ps * 7800.0 / quadrant_size; /* magic constant. Don't ask me why. */ 244 245 substr (symbol_mode, 1, 1) = "("; /* also magic constant */ 246 247 do i = 1, 2; 248 sm_ninebit (i) = "000"b || cs_sixbit (i+4); 249 end; 250 251 paper_size = ps; 252 253 end set_scale; 254 255 limiting = ""b; /* we don't care to stay inside paper margins */ 256 visible = "1"b; 257 258 call put_out (pen_up); /* whirr */ 259 pen_is_down = ""b; 260 261 do i = 1 to 3; /* ram into right end of carriage */ 262 pen_is_at_in_CC_units = 0; 263 pen_wants_at = 0; 264 pen_wants_at (2) = -2000; 265 pen_is_satisfied = ""b; 266 call draw_to (pen_wants_at); /* chunk! */ 267 end; /* have to do this in 3 steps, not enough precision */ 268 269 pen_wants_at = quadrant_size; /* find the center of the paper */ 270 pen_wants_at (2) = pen_wants_at (2) + 100; /* to get over the paper perforation margin */ 271 pen_is_at_in_CC_units = 0; 272 pen_is_satisfied = ""b; 273 call draw_to (pen_wants_at); /* go to the center */ 274 pen_is_satisfied = ""b; 275 276 stack_depth = 0; /* initialize stuff */ 277 maps_active = ""b; 278 dotted = ""b; 279 pen_is_at_in_CC_units, pen_wants_at = 0; 280 limiting = "1"b; /* NOW we wish to stay inside paper margins */ 281 erased = "1"b; /* 2 erases in a row is wasteful */ 282 matrix = identity_matrix; 283 scalings = 1e0; 284 rotations = 0; 285 286 return; 287 288 put_pen_up: proc; 289 290 if ^pen_is_down then return; 291 pen_is_down = ""b; 292 call put_out (pen_up); 293 return; 294 295 put_pen_down: entry; 296 297 if pen_is_down then return; 298 pen_is_down = "1"b; 299 call put_out (pen_down); 300 return; 301 302 end; 303 304 exit_graphic_mode: entry (effector, instring, outstring, n_chars_out); 305 306 n_chars_out = 0; 307 pen_wants_at = 0; /* do a courtesy paper feed */ 308 pen_wants_at (1) = 1200; 309 limiting = ""b; /* to let us go outside our bounds to new frame */ 310 pen_is_satisfied = ""b; 311 call draw_to (pen_wants_at); /* whirr */ 312 call put_pen_up; 313 scale = 0.0; /* close up shop */ 314 search_address = 9999; 315 call put_out_search_address; /* this tells plotter to quit */ 316 317 scale_not_settable = ""b; 318 return; 319 320 close: entry (effector, instring, outstring, n_chars_out); 321 322 dcl iox_$close ext entry (pointer, fixed bin (35)), 323 iox_$detach_iocb ext entry (pointer, fixed bin (35)); 324 325 call iox_$close (iocb_ptr, code); 326 if code ^= 0 then goto complain; 327 328 call iox_$detach_iocb (iocb_ptr, code); 329 n_chars_out = -code; 330 331 return; 332 333 334 set_modes: entry (effector, instring, outstring, n_chars_out); 335 336 n_chars_out = 0; 337 338 goto mode_effector (effector); /* one of several */ 339 340 mode_effector (56): /* intensity */ 341 call graphic_code_util_$decode_spi (addr (instring_array (2)), 1, fixed_array); /* get mode value */ 342 if fixed_array (1) = 0 then visible = ""b; /* no other value makes sense */ 343 else visible = "1"b; /* except visible or invisible */ 344 return; 345 346 mode_effector (57): /* line_type */ 347 348 dcl (dash_length, space_length) float bin static initial (0), 349 dotted bit (1) aligned static initial (""b); 350 351 call graphic_code_util_$decode_spi (addr (instring_array (2)), 1, fixed_array); 352 if fixed_array (1) = 0 then dotted = ""b; /* solid lines */ 353 else do; /* some dotted type */ 354 dotted = "1"b; 355 if fixed_array (1) = 1 then do; /* dashed line */ 356 dash_length = 10; 357 space_length = 4; /* this looks about right on this plotter */ 358 end; 359 else do; /* dotted line */ 360 dash_length = 3; /* this looks right on this plotter */ 361 space_length = 2; 362 end; 363 end; 364 365 return; 366 367 mode_effector (60): /* color */ 368 369 dcl pen_select char (1) aligned static initial (""), /* 004, pen_select */ 370 based_string_array (4) based char (1) unaligned; 371 372 call graphic_code_util_$decode_spi (addr (instring_array (2)), 3, fixed_array); 373 374 j = 1; 375 do i = 2 to 3; /* we expect pens to be L to R: red, green, blue */ 376 if fixed_array (4-i) > fixed_array (4-j) then j = i; /* and the darkest takes precedence */ 377 end; 378 379 call put_out (pen_select); 380 call put_out ((addr (j) -> based_string_array (4))); /* which pen */ 381 382 pen_is_down = ""b; /* pen select forces pen up on 915 */ 383 return; 384 385 set_maps: entry (effector, instring, outstring, n_chars_out); 386 387 n_chars_out = 0; /* we swallow maps */ 388 goto mapping_effector (effector); /* handle by type */ 389 390 mapping_effector (53): /* scaling */ 391 call graphic_code_util_$decode_scl_nozero (addr (instring_array (2)), 3, scalings); /* get scale factors */ 392 goto map_common; 393 394 mapping_effector (54): /* rotation */ 395 call graphic_code_util_$decode_dpi (addr (instring_array (2)), 3, rotations); /* get angles */ 396 397 map_common: 398 call graphic_matrix_util_$make_matrix (rotations, scalings, matrix); /* make the mappings */ 399 400 do i = 1 to 3; 401 do j = 1 to 3; /* see if it's really not unity matrix */ 402 if matrix (i, j) ^= identity_matrix (i, j) then do; /* not unity */ 403 maps_active = "1"b; 404 return; 405 end; 406 end; 407 end; 408 409 maps_active = ""b; /* matrix is nugatory */ 410 return; 411 412 413 text: entry (effector, instring, outstring, n_chars_out); 414 415 dcl (alignment, string_length) fixed bin, 416 sl_sixbit (6) bit (6) unaligned based (addr (string_length)), 417 (x_offset, y_offset) float bin, 418 charsizes (3) float bin initial (13.63636, 7.792208, 5.844156) static; 419 420 dcl hack_plotter bit (1) aligned static initial (""b); 421 422 /* hack_plotter bit neccessary because plotter does not correctly return to beginning of charstring 423* until next move _a_f_t_e_r writing string. If next move is a vector, it starts in the wrong place, 424* although ending up in the right place. So we remove our restriction on zero-length moves if it 425* is after a character string. */ 426 427 n_chars_out = 0; 428 if ^visible then return; 429 call graphic_code_util_$decode_spi (addr (instring_array (2)), 1, fixed_array); /* get alignment of string */ 430 alignment = fixed_array (1); 431 432 call graphic_code_util_$decode_dpi (addr (instring_array (3)), 1, fixed_array); /* get length of string */ 433 string_length = fixed_array (1); 434 if string_length = 0 then return; 435 436 y_offset = -divide (9 - alignment, 3, 35, 0) * charsizes (1) / 2; /* compute y alignment */ 437 438 i = mod (alignment-1, 3) + 1; /* get x-alignment */ 439 x_offset = 0; 440 if i > 1 then x_offset = -string_length * charsizes (2) /* not aligned by left edge */ 441 - (string_length - 1) * charsizes (3); 442 if i = 2 then x_offset = x_offset / 2e0; /* aligned by center */ 443 444 xyz_temp2 = pen_wants_at; 445 446 if ^pen_is_satisfied | x_offset + y_offset ^= 0 then do; /* must move */ 447 pen_is_satisfied = ""b; /* we want to move to correct place */ 448 float_array (1) = pen_wants_at (1) + x_offset; 449 float_array (2) = pen_wants_at (2) + y_offset; 450 float_array (3) = 0; 451 round_copy = float_array; 452 array_copy = round (round_copy, 6); /* because expand_assign blows up creating temps */ 453 pen_wants_at = array_copy; 454 call draw_to (array_copy); /* go to correct position */ 455 end; 456 457 call put_out (symbol_mode); 458 459 bit9 = "000"b || sl_sixbit (6); 460 461 call put_out (char1); 462 463 substr (outstring, n_chars_out + 1, string_length) 464 = translate (substr (instring, 5, string_length), string (USASCII)); /* MAGIC! ASCII -> USASCII */ 465 n_chars_out = n_chars_out + string_length; /* return text string here */ 466 467 pen_wants_at = xyz_temp2; 468 pen_is_satisfied = ""b; 469 hack_plotter = "1"b; 470 471 return; 472 473 erase: entry (effector, instring, outstring, n_chars_out); 474 475 n_chars_out = 0; 476 if erased then return; /* don't paperfeed twice */ 477 call put_out_search_address; /* new search address here */ 478 call put_pen_up; 479 pen_wants_at = 0; /* advance the paper */ 480 pen_is_satisfied = ""b; 481 pen_wants_at (1) = 1200; 482 limiting = "0"b; /* let us go outside our cage */ 483 call draw_to (pen_wants_at); 484 limiting = "1"b; /* replace the bars */ 485 dotted = ""b; 486 maps_active = ""b; /* none of this is necessary, it is all paranoia */ 487 erased = "1"b; 488 pen_wants_at = 0; 489 pen_is_at_in_CC_units = 0; 490 return; 491 492 493 draw_to: proc (coordinates); 494 495 dcl coordinates (3) float bin, 496 dash_count fixed bin, 497 (relative_coordinates, dash_increment, space_increment) (3) float bin, 498 line_length float bin, 499 (sqrt, sum) builtin, 500 array_copy (3) float bin, 501 round_copy (3) fixed bin (35, 7); 502 503 504 if ^visible then do; /* we don't put out many little shifts */ 505 pen_is_satisfied = ""b; 506 pen_wants_at = coordinates; /* note we want to be somewhere else */ 507 return; 508 end; 509 510 if ^pen_is_satisfied then do; /* go to where we should be */ 511 call put_pen_up; /* precedes invisible vector */ 512 round_copy = pen_wants_at; 513 array_copy = round (round_copy, 6); 514 call encode (array_copy); /* put out coordinates */ 515 pen_is_satisfied = "1"b; /* we are where we think we are */ 516 end; 517 518 if sum ((pen_wants_at - coordinates) ** 2) < .001 then return; /* array = array or abs (array - array) loses */ 519 520 call put_pen_down; 521 522 if dotted then do; /* the hard part */ 523 relative_coordinates = coordinates - pen_wants_at; 524 line_length = sqrt (sum (relative_coordinates ** 2)); /* isn't v2pl1 cool? */ 525 dash_increment = dash_length * relative_coordinates / line_length; /* gives one a sense */ 526 space_increment = space_length * relative_coordinates / line_length; /* of perspective */ 527 dash_count = line_length / (dash_length + space_length); 528 529 do i = 1 to dash_count; /* ping ping ping ping */ 530 pen_wants_at, round_copy = pen_wants_at + dash_increment; 531 array_copy = round (round_copy, 6); 532 call encode (array_copy); /* draw a dash */ 533 call put_pen_up; 534 pen_wants_at, round_copy = pen_wants_at + space_increment; 535 array_copy = round (round_copy, 6); 536 call encode (array_copy); /* "draw" a space */ 537 call put_pen_down; 538 end; 539 end; /* the normal case code finishes the line nicely */ 540 541 round_copy = coordinates; /* go to where we want to end up */ 542 array_copy = round (round_copy, 6); 543 call encode (array_copy); /* go where we want to be */ 544 pen_wants_at = coordinates; /* remind ourselves we are really there now */ 545 return; 546 547 end draw_to; 548 549 encode: proc (float_coords); /* puts out a vector to (float_coords) */ 550 551 dcl coords (3) float bin, 552 rel_coords_in_CC_units (3) fixed bin, 553 float_coords (3) float bin parameter; 554 555 dcl (x_significant_bit, y_significant_bit) fixed bin, 556 (x_bits bit (36) aligned, x_sixbit_char (6) unaligned bit (6)) based (addr (rel_coords_in_CC_units (1))), 557 (y_bits bit (36) aligned, y_sixbit_char (6) unaligned bit (6)) based (addr (rel_coords_in_CC_units (2))); 558 559 dcl (no_x_chars, no_y_chars) fixed bin (3), 560 search_bit bit (1) aligned; 561 562 dcl i fixed bin; 563 564 if limiting then coords = max (-quadrant_size, min (quadrant_size, float_coords)) * scale; /* stay in your cage */ 565 else coords = float_coords * scale; /* roam free */ 566 567 rel_coords_in_CC_units = coords - pen_is_at_in_CC_units; 568 pen_is_at_in_CC_units = pen_is_at_in_CC_units + rel_coords_in_CC_units; /* pen_is_at_in_CC_units is independent of pen_wants_at */ 569 /* to make roundoff error correct itself */ 570 571 search_bit = ^substr (x_bits, 1, 1); /* see how many chars needed to describe x */ 572 x_significant_bit = index (x_bits, search_bit) - 1; 573 if x_significant_bit = -1 then if search_bit then no_x_chars = 0; 574 else no_x_chars = 1; 575 else no_x_chars = min (3, divide (42 - x_significant_bit, 6, 2, 0)); /* this many. */ 576 577 search_bit = ^substr (y_bits, 1, 1); /* do the same for y */ 578 y_significant_bit = index (y_bits, search_bit) - 1; 579 if y_significant_bit = -1 then if search_bit then no_y_chars = 0; 580 else no_y_chars = 1; 581 else no_y_chars = min (3, divide (42 - y_significant_bit, 6, 2, 0)); 582 583 if no_x_chars + no_y_chars = 0 then 584 if ^hack_plotter then return; /* no move, why bother? */ 585 else hack_plotter = ""b; 586 587 bit9 = plot_command || substr (bit (no_x_chars), 2, 2) || substr (bit (no_y_chars), 2, 2); 588 call put_out (char1); /* construct the "move in x-y" command header */ 589 590 do i = 7 - no_x_chars to 6; /* put out all x chars necessary */ 591 bit9 = "000"b || x_sixbit_char (i); 592 call put_out (char1); 593 end; 594 595 do i = 7 - no_y_chars to 6; /* do same for y chars */ 596 bit9 = "000"b || y_sixbit_char (i); 597 call put_out (char1); 598 end; 599 600 return; 601 end encode; 602 603 put_out: proc (chars); /* puts chars into outstring */ 604 605 dcl chars char (*) aligned, 606 l fixed bin; 607 608 l = length (chars); 609 erased = ""b; 610 substr (outstring, n_chars_out+1, l) = chars; 611 n_chars_out = n_chars_out + l; 612 return; 613 end put_out; 614 615 set_calcomp_paper_size: scps: entry; 616 617 dcl cu_$arg_ptr ext entry (fixed bin, pointer, fixed bin, fixed bin (35)), 618 com_err_ ext entry options (variable), 619 error_table_$noarg ext fixed bin (35), 620 error_table_$request_not_recognized ext fixed bin (35), 621 code fixed bin (35), 622 ap pointer, 623 al fixed bin, 624 arg char (al) based (ap); 625 626 call cu_$arg_ptr (1, ap, al, code); /* get arg */ 627 if code ^= 0 then do; /* got to be an arg */ 628 say_err: call com_err_ (code, "set_calcomp_paper_size", "^a^/^a", 629 "Usage is: ""scps -size-""", " -size- must be ""narrow"" (11.0 in.) or ""wide"" (33.5 in.)"); 630 return; /* talk about non-standard command options! */ 631 end; 632 633 if scale_not_settable then do; /* already plotting, would screw up program */ 634 call com_err_ (0, "set_calcomp_paper_size", "Paper size cannot be set when this module is in use."); 635 return; /* also plotter operator! */ 636 end; 637 if arg = "narrow" then call set_scale (11.0); /* more magic constants */ 638 else if arg = "wide" then call set_scale (33.5); /* in this case, they're inches. */ 639 else do; 640 code = error_table_$request_not_recognized; /* huh? wot? */ 641 goto say_err; 642 end; 643 644 end calcomp_915_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/18/82 1627.7 calcomp_915_.pl1 >dumps>old>recomp>calcomp_915_.pl1 24 1 03/27/82 0439.2 graphic_device_table.incl.pl1 >ldd>include>graphic_device_table.incl.pl1 187 2 02/02/78 1229.7 iox_modes.incl.pl1 >ldd>include>iox_modes.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. Stream_output 000052 constant fixed bin(17,0) initial dcl 2-15 set ref 207* USASCII 000010 internal static structure level 1 dcl 26 set ref 463 addr builtin function dcl 51 ref 92 92 195 195 228 228 248 248 340 340 351 351 372 372 380 390 390 394 394 429 429 432 432 459 459 571 572 577 578 587 591 591 596 596 al 000222 automatic fixed bin(17,0) dcl 617 set ref 626* 637 638 alignment 000213 automatic fixed bin(17,0) dcl 415 set ref 430* 436 438 ap 000220 automatic pointer dcl 617 set ref 626* 637 638 arg based char unaligned dcl 617 ref 637 638 array_copy 000106 automatic float bin(27) array dcl 61 in procedure "calcomp_915_" set ref 452* 453 454* array_copy 000273 automatic float bin(27) array dcl 495 in procedure "draw_to" set ref 513* 514* 531* 532* 535* 536* 542* 543* based_string_array based char(1) array unaligned dcl 367 ref 380 bit9 based bit(9) dcl 172 set ref 228* 459* 587* 591* 596* char1 000140 automatic char(1) dcl 172 set ref 228 229* 459 461* 587 588* 591 592* 596 597* char_size 000051 internal static fixed bin(35,0) dcl 33 set ref 243* 248 chars parameter char dcl 605 ref 603 608 610 charsizes 000014 constant float bin(27) initial array dcl 415 ref 436 440 440 code 000217 automatic fixed bin(35,0) dcl 617 set ref 195* 200* 202 203 207* 208 325* 326 328* 329 626* 627 628* 640* collate builtin function dcl 51 ref 210 211 com_err_ 000332 constant entry external dcl 617 ref 628 634 coordinates parameter float bin(27) array dcl 495 ref 493 506 518 523 541 544 coords 000314 automatic float bin(27) array dcl 551 set ref 564* 565* 567 cs_sixbit based bit(6) array unaligned dcl 33 ref 248 cu_$arg_ptr 000330 constant entry external dcl 617 ref 626 dash_count 000260 automatic fixed bin(17,0) dcl 495 set ref 527* 529 dash_increment 000264 automatic float bin(27) array dcl 495 set ref 525* 530 dash_length 000271 internal static float bin(27) initial dcl 346 set ref 356* 360* 525 527 divide builtin function dcl 51 ref 436 575 581 dotted 000273 internal static bit(1) initial dcl 346 set ref 278* 352* 354* 485* 522 effector parameter fixed bin(17,0) dcl 40 ref 38 99 105 131 145 153 170 218 304 320 334 338 385 388 413 473 erased 000076 internal static bit(1) initial dcl 64 set ref 281* 476 487* 609* error_table_$request_not_recognized 000334 external static fixed bin(35,0) dcl 617 ref 640 fixed_array 000121 automatic fixed bin(17,0) array dcl 72 set ref 340* 342 351* 352 355 372* 376 376 429* 430 432* 433 float_array 000116 automatic float bin(27) array dcl 72 set ref 448* 449* 450* 451 float_coords parameter float bin(27) array dcl 551 ref 549 564 565 graphic_code_util_$decode_dpi 000300 constant entry external dcl 43 ref 394 432 graphic_code_util_$decode_scl 000302 constant entry external dcl 43 ref 92 graphic_code_util_$decode_scl_nozero 000304 constant entry external dcl 43 ref 390 graphic_code_util_$decode_spi 000276 constant entry external dcl 43 ref 340 351 372 429 graphic_matrix_util_$make_matrix 000306 constant entry external dcl 48 ref 397 graphic_matrix_util_$multiply_3x3_x_1x3 000310 constant entry external dcl 48 ref 96 hack_plotter 000275 internal static bit(1) initial dcl 420 set ref 469* 583 585* i 000114 automatic fixed bin(21,0) dcl 72 in procedure "calcomp_915_" set ref 120* 121 123* 158* 158* 161 163 195* 196 198 227* 228* 247* 248 248* 261* 375* 376 376* 400* 402 402* 438* 440 442 529* i 000327 automatic fixed bin(17,0) dcl 562 in procedure "encode" set ref 590* 591* 595* 596* identity_matrix 000017 constant float bin(27) initial array dcl 57 ref 282 402 instring parameter char unaligned dcl 40 set ref 38 92 92 92 92 131 142 145 153 158 170 200* 218 304 320 334 340 340 340 340 351 351 351 351 372 372 372 372 385 390 390 390 390 394 394 394 394 413 429 429 429 429 432 432 432 432 463 473 instring_array defined char(1) array unaligned dcl 53 set ref 92 92 340 340 351 351 372 372 390 390 394 394 429 429 432 432 ioa_$nnl 000316 constant entry external dcl 178 ref 193 iocb_ptr 000266 internal static pointer dcl 185 set ref 200* 207* 325* 328* iox_$attach_ioname 000320 constant entry external dcl 178 ref 200 iox_$close 000324 constant entry external dcl 322 ref 325 iox_$detach_iocb 000326 constant entry external dcl 322 ref 328 iox_$get_line 000312 constant entry external dcl 178 ref 195 iox_$open 000322 constant entry external dcl 178 ref 207 iox_$user_input 000314 external static pointer dcl 178 set ref 195* j 000115 automatic fixed bin(17,0) dcl 72 set ref 374* 376 376* 380 401* 402 402* l 000340 automatic fixed bin(17,0) dcl 605 set ref 608* 610 611 limiting 000075 internal static bit(1) initial dcl 64 set ref 255* 280* 309* 482* 484* 564 line_length 000272 automatic float bin(27) dcl 495 set ref 524* 525 526 527 lowercase 30(09) 000010 internal static char(26) level 2 packed unaligned dcl 26 set ref 211* maps_active 000054 internal static bit(1) dcl 55 set ref 94 277* 403* 409* 486* matrix 000056 internal static float bin(27) array dcl 57 set ref 96* 282* 397* 402 max builtin function dcl 51 ref 564 min builtin function dcl 51 ref 564 575 581 n_chars_out parameter fixed bin(17,0) dcl 40 set ref 38 90* 131 135* 145 147* 153 157* 170 191* 203* 218 304 306* 320 329* 334 336* 385 387* 413 427* 463 465* 465 473 475* 610 611* 611 no_node_match 000132 stack reference condition dcl 155 ref 161 no_x_chars 000324 automatic fixed bin(3,0) dcl 559 set ref 573* 574* 575* 583 587 590 no_y_chars 000325 automatic fixed bin(3,0) dcl 559 set ref 579* 580* 581* 583 587 595 node_val 000107 internal static char(3) array level 2 dcl 77 set ref 142* 158 outstring parameter char unaligned dcl 40 set ref 38 131 145 153 170 218 304 320 334 385 413 463* 473 610* paper_size 000263 internal static float bin(27) initial dcl 84 set ref 236* 251* pen_down 000100 internal static char(1) initial dcl 67 set ref 299* pen_is_at_in_CC_units 000072 internal static float bin(27) array dcl 61 set ref 262* 271* 279* 489* 567 568* 568 pen_is_down 000052 internal static bit(1) dcl 55 set ref 259* 290 291* 297 298* 382* pen_is_satisfied 000053 internal static bit(1) dcl 55 set ref 103* 113* 117* 137 164* 265* 272* 274* 310* 446 447* 468* 480* 505* 510 515* pen_is_satisfied_copy 4 000107 internal static bit(1) array level 2 dcl 77 set ref 137* 164 pen_select 000274 internal static char(1) initial dcl 367 set ref 379* pen_up 000077 internal static char(1) initial dcl 67 set ref 258* 292* pen_wants_at 000067 internal static float bin(27) array dcl 61 set ref 101* 108 112* 112 116* 116 118* 121* 121 122* 123* 123 124* 136 165* 263* 264* 266* 269* 270* 270 273* 279* 307* 308* 311* 444 448 449 453* 467* 479* 481* 483* 488* 506* 512 518 523 530 530* 534 534* 544* plot_command constant bit(5) initial dcl 67 ref 587 points_per_inch constant fixed bin(17,0) initial dcl 84 ref 242 ps parameter float bin(27) dcl 240 ref 238 242 243 251 quadrant_size constant float bin(27) initial dcl 84 ref 242 243 269 564 564 564 rel_coords_in_CC_units 000317 automatic fixed bin(17,0) array dcl 551 set ref 567* 568 571 572 577 578 591 596 relative_coordinates 000261 automatic float bin(27) array dcl 495 set ref 523* 524 525 526 rotations 000101 internal static fixed bin(17,0) array dcl 70 set ref 284* 394* 397* round builtin function dcl 51 ref 452 513 531 535 542 round_copy 000111 automatic fixed bin(35,7) array dcl 62 in procedure "calcomp_915_" set ref 451* 452 round_copy 000276 automatic fixed bin(35,7) array dcl 495 in procedure "draw_to" set ref 512* 513 530* 531 534* 535 541* 542 sa_sixbit based bit(6) array unaligned dcl 175 ref 228 scale 000261 internal static float bin(27) initial dcl 84 set ref 236 242* 313* 564 565 scale_not_settable 000262 internal static bit(1) initial dcl 84 set ref 213* 317* 633 scalings 000104 internal static float bin(27) array dcl 70 set ref 283* 390* 397* search_address 000264 internal static fixed bin(17,0) dcl 175 set ref 220* 228 232* 232 314* search_bit 000326 automatic bit(1) dcl 559 set ref 571* 572 573 577* 578 579 search_marker 000270 internal static char(1) initial dcl 189 set ref 225* sl_sixbit based bit(6) array unaligned dcl 415 ref 459 sm_ninebit based bit(9) array unaligned dcl 33 set ref 248* space_increment 000267 automatic float bin(27) array dcl 495 set ref 526* 534 space_length 000272 internal static float bin(27) initial dcl 346 set ref 357* 361* 526 527 space_to_rightbracket 10 000010 internal static char(62) level 2 packed unaligned dcl 26 set ref 210* sqrt builtin function dcl 495 ref 524 stack 000107 internal static structure array level 1 dcl 77 set ref 140 stack_depth 000260 internal static fixed bin(17,0) initial dcl 82 set ref 136 137 139* 139 140 142 148* 148 149 158 163* 164 165 276* string builtin function dcl 51 ref 463 string_length 000214 automatic fixed bin(17,0) dcl 415 set ref 433* 434 440 440 459 463 463 465 subscriptrange 000124 stack reference condition dcl 133 ref 140 149 substr builtin function dcl 51 set ref 142 158 198* 210 211 245* 463* 463 571 577 587 587 610* sum builtin function dcl 495 ref 518 524 symbol_mode 000050 internal static char(3) dcl 33 set ref 245* 248 457* tape_number 000141 automatic char(168) unaligned dcl 178 set ref 195 195 198* 200 visible 000055 internal static bit(1) dcl 55 set ref 256* 342* 343* 428 504 x_bits based bit(36) dcl 555 ref 571 572 x_offset 000215 automatic float bin(27) dcl 415 set ref 439* 440* 442* 442 446 448 x_significant_bit 000322 automatic fixed bin(17,0) dcl 555 set ref 572* 573 575 x_sixbit_char based bit(6) array unaligned dcl 555 ref 591 xyz_copy 1 000107 internal static float bin(27) array level 2 dcl 77 set ref 136* 165 xyz_temp 000100 automatic float bin(27) array dcl 61 set ref 92* 95 96* 101 108* 108 109* 112 116 xyz_temp2 000103 automatic float bin(27) array dcl 61 set ref 95* 96* 444* 467 y_bits based bit(36) dcl 555 ref 577 578 y_offset 000216 automatic float bin(27) dcl 415 set ref 436* 446 449 y_significant_bit 000323 automatic fixed bin(17,0) dcl 555 set ref 578* 579 581 y_sixbit_char based bit(6) array unaligned dcl 555 ref 596 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. Close internal static fixed bin(17,0) initial dcl 1-20 Direct_input internal static fixed bin(17,0) initial dcl 2-15 Direct_output internal static fixed bin(17,0) initial dcl 2-15 Direct_update internal static fixed bin(17,0) initial dcl 2-15 Expansion internal static fixed bin(17,0) initial dcl 1-20 Keyed_sequential_input internal static fixed bin(17,0) initial dcl 2-15 Keyed_sequential_output internal static fixed bin(17,0) initial dcl 2-15 Keyed_sequential_update internal static fixed bin(17,0) initial dcl 2-15 Modes internal static fixed bin(17,0) initial dcl 1-20 Open internal static fixed bin(17,0) initial dcl 1-20 Prepare_for_graphics internal static fixed bin(17,0) initial dcl 1-20 Prepare_for_text internal static fixed bin(17,0) initial dcl 1-20 Process_input internal static fixed bin(17,0) initial dcl 1-20 Reference internal static fixed bin(17,0) initial dcl 1-20 Sequential_input internal static fixed bin(17,0) initial dcl 2-15 Sequential_input_output internal static fixed bin(17,0) initial dcl 2-15 Sequential_output internal static fixed bin(17,0) initial dcl 2-15 Sequential_update internal static fixed bin(17,0) initial dcl 2-15 Stream_input internal static fixed bin(17,0) initial dcl 2-15 Stream_input_output internal static fixed bin(17,0) initial dcl 2-15 error_table_$noarg external static fixed bin(35,0) dcl 617 gdt_pointer automatic pointer dcl 1-5 gdt_version_2 internal static fixed bin(17,0) initial dcl 1-3 graphic_device_table based structure level 1 dcl 1-7 iox_modes internal static char(24) initial array dcl 2-6 short_iox_modes internal static char(4) initial array dcl 2-12 NAMES DECLARED BY EXPLICIT CONTEXT. calcomp_915_ 000227 constant entry external dcl 11 close 001433 constant entry external dcl 320 complain 001046 constant label dcl 203 ref 208 326 draw_point 000422 constant label dcl 118 ref 105 draw_to 003114 constant entry internal dcl 493 ref 109 118 122 124 266 273 311 454 483 encode 003552 constant entry internal dcl 549 ref 514 532 536 543 enter_graphic_mode 001107 constant entry external dcl 218 erase 002440 constant entry external dcl 473 exit_graphic_mode 001351 constant entry external dcl 304 expansion 000612 constant entry external dcl 153 get_tape 000735 constant label dcl 193 ref 196 map_common 002046 constant label dcl 397 ref 392 mapping_effector 000012 constant label array(53:54) dcl 390 ref 388 mode_effector 000005 constant label array(56:60) dcl 340 ref 338 node_in 000473 constant entry external dcl 131 node_out 000557 constant entry external dcl 145 open 000713 constant entry external dcl 170 pos 000000 constant label array(48:52) dcl 101 ref 99 position 000242 constant entry external dcl 38 put_out 004041 constant entry internal dcl 603 ref 225 229 258 292 299 379 380 457 461 588 592 597 put_out_search_address 002734 constant entry internal dcl 223 ref 221 315 477 put_pen_down 003074 constant entry internal dcl 295 ref 520 537 put_pen_up 003055 constant entry internal dcl 288 ref 312 478 511 533 say_err 002604 constant label dcl 628 ref 641 scps 002547 constant entry external dcl 615 set_calcomp_paper_size 002556 constant entry external dcl 615 set_maps 001743 constant entry external dcl 385 set_modes 001505 constant entry external dcl 334 set_scale 002773 constant entry internal dcl 238 ref 236 637 638 text 002117 constant entry external dcl 413 NAMES DECLARED BY CONTEXT OR IMPLICATION. bit builtin function ref 587 587 hbound builtin function ref 140 index builtin function ref 572 578 length builtin function ref 608 mod builtin function ref 438 translate builtin function ref 463 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4464 5022 4126 4474 Length 5400 4126 336 341 335 266 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME calcomp_915_ 371 external procedure is an external procedure. put_out_search_address internal procedure shares stack frame of external procedure calcomp_915_. set_scale internal procedure shares stack frame of external procedure calcomp_915_. put_pen_up internal procedure shares stack frame of external procedure calcomp_915_. draw_to internal procedure shares stack frame of external procedure calcomp_915_. encode internal procedure shares stack frame of external procedure calcomp_915_. put_out internal procedure shares stack frame of external procedure calcomp_915_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 USASCII calcomp_915_ 000050 symbol_mode calcomp_915_ 000051 char_size calcomp_915_ 000052 pen_is_down calcomp_915_ 000053 pen_is_satisfied calcomp_915_ 000054 maps_active calcomp_915_ 000055 visible calcomp_915_ 000056 matrix calcomp_915_ 000067 pen_wants_at calcomp_915_ 000072 pen_is_at_in_CC_units calcomp_915_ 000075 limiting calcomp_915_ 000076 erased calcomp_915_ 000077 pen_up calcomp_915_ 000100 pen_down calcomp_915_ 000101 rotations calcomp_915_ 000104 scalings calcomp_915_ 000107 stack calcomp_915_ 000260 stack_depth calcomp_915_ 000261 scale calcomp_915_ 000262 scale_not_settable calcomp_915_ 000263 paper_size calcomp_915_ 000264 search_address calcomp_915_ 000266 iocb_ptr calcomp_915_ 000270 search_marker calcomp_915_ 000271 dash_length calcomp_915_ 000272 space_length calcomp_915_ 000273 dotted calcomp_915_ 000274 pen_select calcomp_915_ 000275 hack_plotter calcomp_915_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME calcomp_915_ 000100 xyz_temp calcomp_915_ 000103 xyz_temp2 calcomp_915_ 000106 array_copy calcomp_915_ 000111 round_copy calcomp_915_ 000114 i calcomp_915_ 000115 j calcomp_915_ 000116 float_array calcomp_915_ 000121 fixed_array calcomp_915_ 000140 char1 calcomp_915_ 000141 tape_number calcomp_915_ 000213 alignment calcomp_915_ 000214 string_length calcomp_915_ 000215 x_offset calcomp_915_ 000216 y_offset calcomp_915_ 000217 code calcomp_915_ 000220 ap calcomp_915_ 000222 al calcomp_915_ 000260 dash_count draw_to 000261 relative_coordinates draw_to 000264 dash_increment draw_to 000267 space_increment draw_to 000272 line_length draw_to 000273 array_copy draw_to 000276 round_copy draw_to 000314 coords encode 000317 rel_coords_in_CC_units encode 000322 x_significant_bit encode 000323 y_significant_bit encode 000324 no_x_chars encode 000325 no_y_chars encode 000326 search_bit encode 000327 i encode 000340 l put_out THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. fx1_to_fl2 call_ext_out_desc call_ext_out return fl2_to_fx1 mod_fx1 signal shorten_stack ext_entry ext_entry_desc fl2_to_fxscaled round_fx1 set_cs_eis index_bs_1_eis translate_2 sqrt THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_ptr graphic_code_util_$decode_dpi graphic_code_util_$decode_scl graphic_code_util_$decode_scl_nozero graphic_code_util_$decode_spi graphic_matrix_util_$make_matrix graphic_matrix_util_$multiply_3x3_x_1x3 ioa_$nnl iox_$attach_ioname iox_$close iox_$detach_iocb iox_$get_line iox_$open THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$request_not_recognized iox_$user_input LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000226 22 000234 38 000235 90 000262 92 000264 94 000313 95 000316 96 000323 99 000335 101 000340 103 000346 105 000347 106 000352 108 000353 109 000366 110 000370 112 000371 113 000404 114 000405 116 000406 117 000421 118 000422 120 000430 121 000434 122 000441 123 000447 124 000454 125 000462 127 000470 131 000471 135 000513 136 000515 137 000533 139 000537 140 000540 142 000544 143 000554 145 000555 147 000577 148 000601 149 000604 151 000607 153 000610 157 000632 158 000634 159 000653 161 000656 163 000664 164 000670 165 000673 167 000710 170 000711 191 000733 193 000735 195 000751 196 000774 198 000777 200 001007 202 001044 203 001046 204 001051 207 001052 208 001071 210 001073 211 001077 213 001102 215 001104 218 001105 220 001127 221 001132 236 001133 255 001144 256 001146 258 001150 259 001160 261 001162 262 001167 263 001201 264 001213 265 001215 266 001216 267 001224 269 001226 270 001240 271 001243 272 001255 273 001256 274 001264 276 001266 277 001267 278 001270 279 001271 280 001315 281 001317 282 001320 283 001323 284 001335 286 001346 304 001347 306 001371 307 001373 308 001405 309 001407 310 001410 311 001411 312 001417 313 001420 314 001423 315 001425 317 001426 318 001430 320 001431 325 001453 326 001464 328 001466 329 001477 331 001502 334 001503 336 001525 338 001527 340 001531 342 001560 343 001565 344 001570 351 001571 352 001620 354 001625 355 001630 356 001632 357 001634 358 001636 360 001637 361 001641 365 001643 372 001644 374 001673 375 001675 376 001702 377 001715 379 001717 380 001730 382 001736 383 001740 385 001741 387 001763 388 001765 390 001767 392 002016 394 002017 397 002046 400 002061 401 002066 402 002073 403 002103 404 002105 406 002106 407 002110 409 002112 410 002114 413 002115 427 002137 428 002141 429 002144 430 002172 432 002174 433 002224 434 002226 436 002227 438 002242 439 002250 440 002252 442 002267 444 002275 446 002302 447 002307 448 002310 449 002313 450 002316 451 002320 452 002333 453 002353 454 002361 457 002363 459 002374 461 002400 463 002403 465 002423 467 002426 468 002432 469 002433 471 002435 473 002436 475 002460 476 002462 477 002465 478 002466 479 002467 480 002501 481 002502 482 002504 483 002505 484 002513 485 002516 486 002517 487 002520 488 002521 489 002533 490 002545 615 002546 626 002563 627 002602 628 002604 630 002650 633 002651 634 002654 635 002703 637 002704 638 002717 640 002730 641 002732 644 002733 223 002734 225 002735 227 002746 228 002753 229 002763 230 002766 232 002770 234 002772 238 002773 242 002775 243 003006 245 003013 247 003015 248 003021 249 003042 251 003050 253 003054 288 003055 290 003056 291 003062 292 003063 293 003073 295 003074 297 003075 298 003101 299 003103 300 003113 493 003114 504 003116 505 003121 506 003122 507 003131 510 003132 511 003134 512 003135 513 003151 514 003171 515 003173 518 003176 520 003224 522 003225 523 003230 524 003245 525 003266 526 003302 527 003316 529 003323 530 003331 531 003371 532 003411 533 003413 534 003414 535 003454 536 003474 537 003476 538 003477 541 003501 542 003516 543 003536 544 003540 545 003551 549 003552 564 003554 565 003606 567 003623 568 003637 571 003653 572 003657 573 003664 574 003672 575 003675 577 003704 578 003710 579 003715 580 003723 581 003726 583 003735 585 003743 587 003744 588 003771 590 003774 591 004002 592 004011 593 004014 595 004016 596 004024 597 004033 598 004036 600 004040 603 004041 608 004052 609 004053 610 004055 611 004065 612 004066 ----------------------------------------------------------- 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