COMPILATION LISTING OF SEGMENT pps_modes Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 02/02/88 1648.3 mst Tue 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 pps_modes: proc (iocb_ptr_arg, new_modes, old_modes, code); 12 13 14 15 /* PARAMETERS */ 16 17 18 dcl code fixed bin (35); 19 dcl iocb_ptr_arg ptr; 20 dcl new_modes char (*); 21 dcl old_modes char (*); 22 23 24 /* ENTRY CONSTANTS */ 25 26 27 dcl cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin (35)); 28 dcl default_handler_$set entry (entry); 29 dcl hcs_$reset_ips_mask entry (fixed bin (35), fixed bin (35)); 30 dcl hcs_$set_ips_mask entry (fixed bin (35), fixed bin (35)); 31 dcl pps_print$set_debug_sw entry (bit (1)); 32 33 34 /* EXTERNAL DATA */ 35 36 37 dcl error_table_$bad_mode fixed bin (35) ext; 38 39 40 /* BUILTIN FUNCTIONS */ 41 42 43 dcl addr builtin; 44 dcl divide builtin; 45 dcl index builtin; 46 dcl length builtin; 47 dcl ltrim builtin; 48 dcl substr builtin; 49 dcl verify builtin; 50 51 52 /* AUTOMATIC STORAGE */ 53 54 55 dcl bot_label_length fixed bin; 56 dcl ctl_char bit (1); 57 dcl debug bit (1); 58 dcl esc bit (1); 59 dcl indent fixed bin; 60 dcl iocb_ptr ptr; 61 dcl line_length fixed bin; 62 dcl mask fixed bin (35); 63 dcl no_print bit (1); 64 dcl non_edited bit (1); 65 dcl overflow_off bit (1); 66 dcl page_length fixed bin; 67 dcl physical_line_length fixed bin; 68 dcl physical_page_length fixed bin; 69 dcl sheets_per_page fixed bin; 70 dcl single_page bit (1); 71 dcl single_space bit (1); 72 dcl stop_count fixed bin (71); 73 dcl stop_every fixed bin; 74 dcl top_label_length fixed bin; 75 dcl truncate bit (1); 76 77 78 /* CONSTANTS */ 79 80 81 82 83 /* INTERNAL STATIC */ 84 85 86 87 88 /* BASED VARIABLES */ 89 90 iocb_ptr = iocb_ptr_arg -> iocb.actual_iocb_ptr; 91 ppsab_ptr = iocb.attach_data_ptr; 92 code = 0; 93 mask = 0; 94 95 call default_handler_$set (Default_Condition_Handler); 96 97 call Get_Old_Modes (); 98 99 call Parse_New_Modes (); 100 101 call Check_New_Modes (); 102 103 call Set_New_Modes (); 104 105 return; 106 107 108 bad_mode: 109 110 code = error_table_$bad_mode; 111 return; 112 113 Check_New_Modes: proc (); 114 115 116 if line_length > physical_line_length then goto bad_mode; 117 118 if indent >= line_length then goto bad_mode; 119 120 if overflow_off then do; 121 top_label_length, 122 bot_label_length = 0; 123 sheets_per_page = 1; 124 page_length = physical_page_length - pps_pci.lpi; 125 end; 126 else sheets_per_page = 127 divide (page_length+pps_pci.lpi-1+physical_page_length, physical_page_length, 17, 0); 128 129 return; 130 131 132 end Check_New_Modes; 133 134 Get_Old_Modes: proc (); 135 136 137 dcl oldm char (length (old_modes)) varying; 138 dcl pic pic "zzzzzzz9"; 139 140 141 indent = pps_pci.lmarg; 142 line_length = pps_pci.rmarg; 143 page_length = pps_pci.page_length; 144 physical_line_length = pps_pci.phys_line_length; 145 physical_page_length = pps_pci.phys_page_length; 146 non_edited = pps_pci.modes.non_edited; 147 overflow_off = pps_pci.modes.overflow_off ; 148 truncate = pps_pci.modes.truncate ; 149 single_space = pps_pci.modes.single_space ; 150 esc = ppsab.pps_pci.modes.esc; 151 ctl_char = ppsab.pps_pci.modes.ctl_char; 152 debug = ppsab.modes.debug; 153 top_label_length = pps_pci.top_label_length; 154 bot_label_length = pps_pci.bot_label_length; 155 stop_every = ppsab.stop_every; 156 stop_count = ppsab.stop_count; 157 single_page = ppsab.modes.single_page; 158 no_print = ppsab.modes.no_print; 159 160 if length (old_modes) <= 0 then return; 161 162 oldm = ""; 163 if non_edited then oldm = oldm || "^edited,"; 164 if overflow_off then oldm = oldm || "^endpage,"; 165 if truncate then oldm = oldm || "^fold,"; 166 if single_space then oldm = oldm || "^vertsp,"; 167 if esc then oldm = oldm || "esc,"; 168 if debug then oldm = oldm || "debug,"; 169 if stop_every > 0 then do; 170 pic = stop_every; 171 oldm = oldm || "stop" || ltrim (pic) || ","; 172 end; 173 if indent > 1 then do; 174 pic = indent; 175 oldm = oldm || "in" || ltrim (pic) || ","; 176 end; 177 pic = line_length; 178 oldm = oldm || "ll" || ltrim (pic) || ","; 179 pic = page_length; 180 oldm = oldm || "pl" || ltrim (pic) || ","; 181 pic = physical_line_length; 182 oldm = oldm || "pll" || ltrim (pic) || ","; 183 pic = physical_page_length; 184 oldm = oldm || "ppl" || ltrim (pic); 185 186 old_modes = oldm; 187 188 189 return; 190 191 192 end Get_Old_Modes; 193 194 Parse_New_Modes: proc (); 195 196 197 dcl bitval bit (1); 198 dcl i fixed bin; 199 dcl l fixed bin; 200 dcl mode char (32); 201 202 203 i = verify (new_modes, " "); 204 if i <= 0 then return; 205 206 207 do while (i <= length (new_modes)); 208 209 l = index (substr (new_modes, i), ",")-1; 210 if l < 0 then l = length (new_modes)-i+1; 211 212 if l > 0 then do; 213 214 if substr (new_modes, i, 1) = "^" then do; 215 bitval = "0"b; 216 i = i+1; 217 if i > length (new_modes) then return; 218 l = l-1; 219 if l = 0 then goto bad_mode; 220 end; 221 else bitval = "1"b; 222 223 mode = substr (new_modes, i, l); 224 i = i+l+1; 225 226 if mode = "default" then do; 227 overflow_off, 228 single_space, 229 non_edited, 230 truncate, 231 esc, 232 ctl_char, 233 no_print = "0"b; 234 top_label_length, 235 bot_label_length = 0; 236 physical_line_length = 132; /* for 11 inch paper */ 237 physical_page_length = 58+6; /* for 8.5 inch paper */ 238 line_length = physical_line_length; 239 indent = 0; 240 page_length = physical_page_length - pps_pci.lpi; 241 stop_every, 242 stop_count = 0; 243 end; 244 else if mode = "edited" then non_edited = ^bitval; 245 else if mode = "non_edited" then non_edited = bitval; 246 else if mode = "endpage" then overflow_off = ^bitval; 247 else if mode = "noskip" then overflow_off = bitval; 248 else if mode = "fold" then truncate = ^bitval; 249 else if mode = "truncate" then truncate = bitval; 250 else if mode = "vertsp" then single_space = ^bitval; 251 else if mode = "single" then single_space = bitval; 252 else if mode = "esc" then esc = bitval; 253 else if mode = "debug" then debug = bitval; 254 else if mode = "1pg" then single_page = bitval; 255 else if mode = "print" then no_print = ^bitval; 256 else if substr (mode, 1, 4) = "stop" then do; 257 stop_every = cv_dec_check_ (substr (mode, 5), code); 258 stop_count = 0; 259 if code ^= 0 then goto bad_mode; 260 end; 261 else if substr (mode, 1, 2) = "in" then do; 262 indent = cv_dec_check_ (substr (mode, 3), code); 263 if code ^= 0 then goto bad_mode; 264 end; 265 else if substr (mode, 1, 3) = "pll" then do; 266 physical_line_length = cv_dec_check_ (substr (mode, 4), code); 267 if code ^= 0 then goto bad_mode; 268 end; 269 else if substr (mode, 1, 3) = "ppl" then do; 270 physical_page_length = cv_dec_check_ (substr (mode, 4), code); 271 if code ^= 0 then goto bad_mode; 272 end; 273 else if substr (mode, 1, 2) = "ll" then do; 274 line_length = cv_dec_check_ (substr (mode, 3), code); 275 if code ^= 0 then goto bad_mode; 276 end; 277 else if substr (mode, 1, 2) = "pl" then do; 278 page_length = cv_dec_check_ (substr (mode, 3), code); 279 if code ^= 0 then goto bad_mode; 280 end; 281 else goto bad_mode; 282 283 end; 284 285 end; 286 287 288 return; 289 290 291 end Parse_New_Modes; 292 293 Set_New_Modes: proc (); 294 295 296 call hcs_$set_ips_mask (0, mask); 297 298 pps_pci.lmarg = indent; 299 pps_pci.rmarg = line_length; 300 pps_pci.page_length = page_length; 301 pps_pci.phys_line_length = physical_line_length; 302 pps_pci.phys_page_length = physical_page_length; 303 pps_pci.modes.non_edited = non_edited; 304 pps_pci.modes.overflow_off = overflow_off; 305 pps_pci.modes.truncate = truncate; 306 pps_pci.modes.single_space = single_space; 307 ppsab.pps_pci.modes.esc = esc; 308 ppsab.modes.debug = debug; 309 ppsab.stop_every = stop_every; 310 ppsab.stop_count = stop_count; 311 ppsab.modes.single_page = single_page; 312 ppsab.modes.no_print = no_print; 313 314 call hcs_$reset_ips_mask (mask, mask); 315 316 317 call pps_print$set_debug_sw (ppsab.modes.debug); 318 319 320 return; 321 322 323 end Set_New_Modes; 324 325 /* 326* 327* Internal procedure to handle faults while IPS interrupts are masked. While not masked, any signals are simply 328* passed on up the stack to their normal handlers. For a fault while masked, the process is terminated (with the 329* reason "unable to do critical I/O") because the I/O control blocks are in an inconsistent state, and we can 330* tolerate neither spawning a command loop with interrupts masked nor a restart with a possibly changed mask. 331* 332**/ 333 334 335 Default_Condition_Handler: proc (p1, name, p2, p3, continue); 336 337 338 dcl continue bit (1) aligned; 339 dcl error_table_$unable_to_do_io fixed (35) ext; 340 dcl name char (*); 341 dcl p1 ptr; 342 dcl p2 ptr; 343 dcl p3 ptr; 344 dcl terminate_process_ entry (char (*), ptr); 345 346 dcl 1 ti aligned, 347 2 version fixed, 348 2 code fixed (35); 349 350 351 if mask ^= 0 then do; 352 ti.version = 0; 353 ti.code = error_table_$unable_to_do_io; 354 call terminate_process_ ("fatal_error", addr (ti)); 355 end; 356 if name ^= "cleanup" then continue = "1"b; 357 return; 358 359 360 end Default_Condition_Handler; 361 1 1 1 2 dcl 1 iocb aligned based (iocb_ptr), 1 3 /* I/O control block. */ 1 4 2 iocb_version fixed init (1), /* Version number of structure. */ 1 5 2 name char (32), /* I/O name of this block. */ 1 6 2 actual_iocb_ptr ptr, /* IOCB ultimately SYNed to. */ 1 7 2 attach_descrip_ptr ptr, /* Ptr to printable attach description. */ 1 8 2 attach_data_ptr ptr, /* Ptr to attach data structure. */ 1 9 2 open_descrip_ptr ptr, /* Ptr to printable open description. */ 1 10 2 open_data_ptr ptr, /* Ptr to open data structure (old SDB). */ 1 11 2 reserved bit (72), /* Reserved for future use. */ 1 12 2 detach_iocb entry (ptr, fixed (35)),/* detach_iocb(p,s) */ 1 13 2 open entry (ptr, fixed, bit (1) aligned, fixed (35)), 1 14 /* open(p,mode,not_used,s) */ 1 15 2 close entry (ptr, fixed (35)),/* close(p,s) */ 1 16 2 get_line entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 1 17 /* get_line(p,bufptr,buflen,actlen,s) */ 1 18 2 get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 1 19 /* get_chars(p,bufptr,buflen,actlen,s) */ 1 20 2 put_chars entry (ptr, ptr, fixed (21), fixed (35)), 1 21 /* put_chars(p,bufptr,buflen,s) */ 1 22 2 modes entry (ptr, char (*), char (*), fixed (35)), 1 23 /* modes(p,newmode,oldmode,s) */ 1 24 2 position entry (ptr, fixed, fixed (21), fixed (35)), 1 25 /* position(p,u1,u2,s) */ 1 26 2 control entry (ptr, char (*), ptr, fixed (35)), 1 27 /* control(p,order,infptr,s) */ 1 28 2 read_record entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 1 29 /* read_record(p,bufptr,buflen,actlen,s) */ 1 30 2 write_record entry (ptr, ptr, fixed (21), fixed (35)), 1 31 /* write_record(p,bufptr,buflen,s) */ 1 32 2 rewrite_record entry (ptr, ptr, fixed (21), fixed (35)), 1 33 /* rewrite_record(p,bufptr,buflen,s) */ 1 34 2 delete_record entry (ptr, fixed (35)),/* delete_record(p,s) */ 1 35 2 seek_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 1 36 /* seek_key(p,key,len,s) */ 1 37 2 read_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 1 38 /* read_key(p,key,len,s) */ 1 39 2 read_length entry (ptr, fixed (21), fixed (35)); 1 40 /* read_length(p,len,s) */ 1 41 362 2 1 /* Begin include file ... pps_attach_block.incl.pl1 */ 2 2 2 3 2 4 dcl pps_attach_block_version_1 fixed bin static internal options (constant) init (1); 2 5 dcl ppsab_ptr ptr; 2 6 2 7 dcl 1 ppsab based (ppsab_ptr) aligned, 2 8 2 version fixed bin, 2 9 2 attach_descrip char (256) varying, 2 10 2 target_name char (32) unal, 2 11 2 target_attach_descrip char (256) unal, 2 12 2 detach_time_attach_descrip char (256) unal, 2 13 2 target_iocb_ptr ptr, 2 14 2 modes, 2 15 3 debug bit (1) unal, 2 16 3 no_print bit (1) unal, 2 17 3 single_page bit (1) unal, 2 18 2 ppscb_dir char (168) unal, 2 19 2 ppscb_entry char (32) unal, 2 20 2 ppscb_name char (32) unal, 2 21 2 ppscb_ptr ptr, 2 22 2 tape_density fixed bin, 2 23 2 file_number fixed bin, 2 24 2 file_name char (17), 2 25 2 retain_option char (4) varying, 2 26 2 volids char (256) varying, 2 27 2 open_descrip char (256) varying, 2 28 2 table_ptr ptr, 2 29 2 mvt_entry entry, 2 30 2 stop_every fixed bin (71), 2 31 2 stop_count fixed bin (71), 2 32 2 chars_printed fixed bin (35), 2 33 2 paper_info, 2 34 3 cpii fixed bin, 2 35 3 lpii fixed bin, 2 36 3 swi fixed bin, 2 37 3 sli fixed bin, 2 38 2 pps_pci like pci; 2 39 3 1 3 2 /* BEGIN INCLUDE FILE ... prt_conv_info.incl.pl1 */ 3 3 /* Modified: 12 September 1980 by G. Palter */ 3 4 3 5 3 6 /****^ HISTORY COMMENTS: 3 7* 1) change(87-05-10,Gilcrease), approve(87-07-31,MCR7686), 3 8* audit(88-02-01,Farley), install(88-02-02,MR12.2-1019): 3 9* Add modes.line_nbrs, flags.(eol eof) bits for eor -nb. 3 10* END HISTORY COMMENTS */ 3 11 3 12 3 13 dcl pcip ptr; /* pointer to conversion info structure */ 3 14 3 15 dcl 1 pci based (pcip) aligned, /* printer conversion info structure */ 3 16 2 cv_proc ptr, /* pointer to character conversion procedure */ 3 17 2 lmarg fixed bin, /* left margin indentation */ 3 18 2 rmarg fixed bin, /* right margin limit */ 3 19 2 page_length fixed bin, /* number of lines on page */ 3 20 2 phys_line_length fixed bin, /* physical width of paper */ 3 21 2 phys_page_length fixed bin, /* physical length of paper */ 3 22 2 lpi fixed bin, /* lines per inch */ 3 23 2 sheets_per_page fixed bin, /* sheets of paper per logical page */ 3 24 2 line_count fixed bin, /* count of converted lines */ 3 25 2 page_count fixed bin, /* count of converted pages */ 3 26 2 func fixed bin, /* special conversion function */ 3 27 /* 0 => normal conversion */ 3 28 /* 1 => change NL to FF */ 3 29 /* 2 => change NL to top inside page */ 3 30 /* 3 => change NL to end of page */ 3 31 /* 4 => change NL to top of outside page */ 3 32 (2 modes, /* conversion modes */ 3 33 3 overflow_off bit (1), /* "1"b to suppress end of page overflow */ 3 34 3 single_space bit (1), /* "1"b to change all forms advance chars to NL */ 3 35 3 non_edited bit (1), /* "1"b to print ASCII control chars */ 3 36 3 truncate bit (1), /* "1"b to truncate lines that are too long */ 3 37 3 esc bit (1), /* "1"b to process ESC character */ 3 38 3 ctl_char bit (1), /* "1"b to output control characters */ 3 39 3 line_nbrs bit (1), /* "1"b to output line numbers */ 3 40 3 pci_pad bit (5), 3 41 2 flags, /* flags internal to prt_conv_ */ 3 42 3 ignore_next_ff bit (1), /* ON => prt_conv_ just output a FF; ignore next character if 3 43* it's a FF */ 3 44 3 eol bit (1), /* "1"b = end-of-line encountered */ 3 45 3 eof bit (1), /* "1"b = end-of-segment encountered */ 3 46 3 flags_pad bit (3), 3 47 2 coroutine_modes, 3 48 3 upper_case bit(1), /* "1"b to convert to upper case */ 3 49 3 ht bit(1), /* "1"b to skip tab conversion */ 3 50 3 coroutine_pad bit(13), 3 51 3 slew_table_idx bit(3) ) unal, /* slew table index */ 3 52 2 top_label_line char (136), /* contains an optional top of page label */ 3 53 2 bot_label_line char (136), /* contains an optional bottom of page label */ 3 54 2 top_label_length fixed bin, /* length of top label line */ 3 55 2 bot_label_length fixed bin, /* length of bottom label line */ 3 56 2 form_stops (256) unal, /* logical form stops */ 3 57 3 lbits bit (9), /* leftmost bits */ 3 58 3 rbits bit (9), /* rightmost bits */ 3 59 3 60 /* The following items are for internal use by the print conversion procedure. 3 61* They should be zeroed once and then never referenced again. */ 3 62 3 63 2 level fixed bin, /* overstrike level */ 3 64 2 pos fixed bin, /* print position at end of incomplete line */ 3 65 2 line fixed bin, /* current line number */ 3 66 2 slew_residue fixed bin, /* number of lines remaining to be slewed */ 3 67 2 label_nelem fixed bin, /* characters remaining in label */ 3 68 2 label_wksp ptr, /* pointer to label being processed */ 3 69 2 sav_pos fixed bin, /* position saved during label processing */ 3 70 2 esc_state fixed bin, /* state of ESC processing */ 3 71 2 esc_num fixed bin, /* number following ESC sequence */ 3 72 2 temp bit (36); /* conversion proc temporary */ 3 73 3 74 /* End of include file ...... prt_conv_info.incl.pl1 */ 3 75 2 40 2 41 2 42 2 43 /* End include file ... pps_attach_block.incl.pl1 */ 363 364 365 366 end pps_modes; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 02/02/88 1540.0 pps_modes.pl1 >special_ldd>install>MR12.2-1019>pps_modes.pl1 362 1 07/02/81 1905.0 iocbv.incl.pl1 >ldd>include>iocbv.incl.pl1 363 2 03/27/82 0438.0 pps_attach_block.incl.pl1 >ldd>include>pps_attach_block.incl.pl1 2-40 3 02/02/88 1529.2 prt_conv_info.incl.pl1 >special_ldd>install>MR12.2-1019>prt_conv_info.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. actual_iocb_ptr 12 based pointer level 2 dcl 1-2 ref 90 addr builtin function dcl 43 ref 354 354 attach_data_ptr 16 based pointer level 2 dcl 1-2 ref 91 bitval 000150 automatic bit(1) unaligned dcl 197 set ref 215* 221* 244 245 246 247 248 249 250 251 252 253 254 255 bot_label_length 770 based fixed bin(17,0) level 3 in structure "ppsab" dcl 2-7 in procedure "pps_modes" ref 154 bot_label_length 000100 automatic fixed bin(17,0) dcl 55 in procedure "pps_modes" set ref 121* 154* 234* code parameter fixed bin(35,0) dcl 18 in procedure "pps_modes" set ref 11 92* 108* 257* 259 262* 263 266* 267 270* 271 274* 275 278* 279 code 1 000100 automatic fixed bin(35,0) level 2 in structure "ti" dcl 346 in procedure "Default_Condition_Handler" set ref 353* continue parameter bit(1) dcl 338 set ref 335 356* ctl_char 000101 automatic bit(1) unaligned dcl 56 in procedure "pps_modes" set ref 151* 227* ctl_char 662(05) based bit(1) level 4 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" ref 151 cv_dec_check_ 000010 constant entry external dcl 27 ref 257 262 266 270 274 278 debug 000102 automatic bit(1) unaligned dcl 57 in procedure "pps_modes" set ref 152* 168 253* 308 debug 314 based bit(1) level 3 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" set ref 152 308* 317* default_handler_$set 000012 constant entry external dcl 28 ref 95 divide builtin function dcl 44 ref 126 error_table_$bad_mode 000022 external static fixed bin(35,0) dcl 37 ref 108 error_table_$unable_to_do_io 000024 external static fixed bin(35,0) dcl 339 ref 353 esc 000103 automatic bit(1) unaligned dcl 58 in procedure "pps_modes" set ref 150* 167 227* 252* 307 esc 662(04) based bit(1) level 4 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" set ref 150 307* hcs_$reset_ips_mask 000014 constant entry external dcl 29 ref 314 hcs_$set_ips_mask 000016 constant entry external dcl 30 ref 296 i 000151 automatic fixed bin(17,0) dcl 198 set ref 203* 204 207 209 210 214 216* 216 217 223 224* 224 indent 000104 automatic fixed bin(17,0) dcl 59 set ref 118 141* 173 174 239* 262* 298 index builtin function dcl 45 ref 209 iocb based structure level 1 dcl 1-2 iocb_ptr 000106 automatic pointer dcl 60 set ref 90* 91 iocb_ptr_arg parameter pointer dcl 19 ref 11 90 l 000152 automatic fixed bin(17,0) dcl 199 set ref 209* 210 210* 212 218* 218 219 223 224 length builtin function dcl 46 ref 137 160 207 210 217 line_length 000110 automatic fixed bin(17,0) dcl 61 set ref 116 118 142* 177 238* 274* 299 lmarg 650 based fixed bin(17,0) level 3 dcl 2-7 set ref 141 298* lpi 655 based fixed bin(17,0) level 3 dcl 2-7 ref 124 126 240 ltrim builtin function dcl 47 ref 171 175 178 180 182 184 mask 000111 automatic fixed bin(35,0) dcl 62 set ref 93* 296* 314* 314* 351 mode 000153 automatic char(32) unaligned dcl 200 set ref 223* 226 244 245 246 247 248 249 250 251 252 253 254 255 256 257 257 261 262 262 265 266 266 269 270 270 273 274 274 277 278 278 modes 662 based structure level 3 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" modes 314 based structure level 2 in structure "ppsab" dcl 2-7 in procedure "pps_modes" name parameter char unaligned dcl 340 ref 335 356 new_modes parameter char unaligned dcl 20 ref 11 203 207 209 210 214 217 223 no_print 000112 automatic bit(1) unaligned dcl 63 in procedure "pps_modes" set ref 158* 227* 255* 312 no_print 314(01) based bit(1) level 3 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" set ref 158 312* non_edited 662(02) based bit(1) level 4 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" set ref 146 303* non_edited 000113 automatic bit(1) unaligned dcl 64 in procedure "pps_modes" set ref 146* 163 227* 244* 245* 303 old_modes parameter char unaligned dcl 21 set ref 11 137 160 186* oldm 000100 automatic varying char dcl 137 set ref 162* 163* 163 164* 164 165* 165 166* 166 167* 167 168* 168 171* 171 175* 175 178* 178 180* 180 182* 182 184* 184 186 overflow_off 662 based bit(1) level 4 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" set ref 147 304* overflow_off 000114 automatic bit(1) unaligned dcl 65 in procedure "pps_modes" set ref 120 147* 164 227* 246* 247* 304 p1 parameter pointer dcl 341 ref 335 p2 parameter pointer dcl 342 ref 335 p3 parameter pointer dcl 343 ref 335 page_length 652 based fixed bin(17,0) level 3 in structure "ppsab" dcl 2-7 in procedure "pps_modes" set ref 143 300* page_length 000115 automatic fixed bin(17,0) dcl 66 in procedure "pps_modes" set ref 124* 126 143* 179 240* 278* 300 pci based structure level 1 dcl 3-15 phys_line_length 653 based fixed bin(17,0) level 3 dcl 2-7 set ref 144 301* phys_page_length 654 based fixed bin(17,0) level 3 dcl 2-7 set ref 145 302* physical_line_length 000116 automatic fixed bin(17,0) dcl 67 set ref 116 144* 181 236* 238 266* 301 physical_page_length 000117 automatic fixed bin(17,0) dcl 68 set ref 124 126 126 145* 183 237* 240 270* 302 pic 000100 automatic picture(8) unaligned dcl 138 set ref 170* 171 174* 175 177* 178 179* 180 181* 182 183* 184 pps_pci 646 based structure level 2 dcl 2-7 pps_print$set_debug_sw 000020 constant entry external dcl 31 ref 317 ppsab based structure level 1 dcl 2-7 ppsab_ptr 000132 automatic pointer dcl 2-5 set ref 91* 124 126 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 240 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 317 rmarg 651 based fixed bin(17,0) level 3 dcl 2-7 set ref 142 299* sheets_per_page 000120 automatic fixed bin(17,0) dcl 69 set ref 123* 126* single_page 314(02) based bit(1) level 3 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" set ref 157 311* single_page 000121 automatic bit(1) unaligned dcl 70 in procedure "pps_modes" set ref 157* 254* 311 single_space 000122 automatic bit(1) unaligned dcl 71 in procedure "pps_modes" set ref 149* 166 227* 250* 251* 306 single_space 662(01) based bit(1) level 4 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" set ref 149 306* stop_count 636 based fixed bin(71,0) level 2 in structure "ppsab" dcl 2-7 in procedure "pps_modes" set ref 156 310* stop_count 000124 automatic fixed bin(71,0) dcl 72 in procedure "pps_modes" set ref 156* 241* 258* 310 stop_every 634 based fixed bin(71,0) level 2 in structure "ppsab" dcl 2-7 in procedure "pps_modes" set ref 155 309* stop_every 000126 automatic fixed bin(17,0) dcl 73 in procedure "pps_modes" set ref 155* 169 170 241* 257* 309 substr builtin function dcl 48 ref 209 214 223 256 257 257 261 262 262 265 266 266 269 270 270 273 274 274 277 278 278 terminate_process_ 000026 constant entry external dcl 344 ref 354 ti 000100 automatic structure level 1 dcl 346 set ref 354 354 top_label_length 767 based fixed bin(17,0) level 3 in structure "ppsab" dcl 2-7 in procedure "pps_modes" ref 153 top_label_length 000127 automatic fixed bin(17,0) dcl 74 in procedure "pps_modes" set ref 121* 153* 234* truncate 662(03) based bit(1) level 4 in structure "ppsab" packed unaligned dcl 2-7 in procedure "pps_modes" set ref 148 305* truncate 000130 automatic bit(1) unaligned dcl 75 in procedure "pps_modes" set ref 148* 165 227* 248* 249* 305 verify builtin function dcl 49 ref 203 version 000100 automatic fixed bin(17,0) level 2 dcl 346 set ref 352* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. pcip automatic pointer dcl 3-13 pps_attach_block_version_1 internal static fixed bin(17,0) initial dcl 2-4 NAMES DECLARED BY EXPLICIT CONTEXT. Check_New_Modes 000153 constant entry internal dcl 113 ref 101 Default_Condition_Handler 002053 constant entry internal dcl 335 ref 95 95 Get_Old_Modes 000205 constant entry internal dcl 134 ref 97 Parse_New_Modes 001165 constant entry internal dcl 194 ref 99 Set_New_Modes 001730 constant entry internal dcl 293 ref 103 bad_mode 000146 constant label dcl 108 ref 116 118 219 259 263 267 271 275 277 279 pps_modes 000074 constant entry external dcl 11 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2306 2336 2136 2316 Length 2600 2136 30 226 150 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME pps_modes 178 external procedure is an external procedure. Check_New_Modes internal procedure shares stack frame of external procedure pps_modes. Get_Old_Modes 77 internal procedure uses auto adjustable storage. Parse_New_Modes internal procedure shares stack frame of external procedure pps_modes. Set_New_Modes internal procedure shares stack frame of external procedure pps_modes. Default_Condition_Handler 84 internal procedure is assigned to an entry variable. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME Default_Condition_Handler 000100 ti Default_Condition_Handler Get_Old_Modes 000100 oldm Get_Old_Modes 000100 pic Get_Old_Modes pps_modes 000100 bot_label_length pps_modes 000101 ctl_char pps_modes 000102 debug pps_modes 000103 esc pps_modes 000104 indent pps_modes 000106 iocb_ptr pps_modes 000110 line_length pps_modes 000111 mask pps_modes 000112 no_print pps_modes 000113 non_edited pps_modes 000114 overflow_off pps_modes 000115 page_length pps_modes 000116 physical_line_length pps_modes 000117 physical_page_length pps_modes 000120 sheets_per_page pps_modes 000121 single_page pps_modes 000122 single_space pps_modes 000124 stop_count pps_modes 000126 stop_every pps_modes 000127 top_label_length pps_modes 000130 truncate pps_modes 000132 ppsab_ptr pps_modes 000150 bitval Parse_New_Modes 000151 i Parse_New_Modes 000152 l Parse_New_Modes 000153 mode Parse_New_Modes THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this return_mac alloc_auto_adj shorten_stack ext_entry_desc int_entry int_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cv_dec_check_ default_handler_$set hcs_$reset_ips_mask hcs_$set_ips_mask pps_print$set_debug_sw terminate_process_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_mode error_table_$unable_to_do_io LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000067 90 000114 91 000121 92 000123 93 000124 95 000125 97 000136 99 000142 101 000143 103 000144 105 000145 108 000146 111 000152 113 000153 116 000154 118 000157 120 000161 121 000163 123 000165 124 000167 125 000173 126 000174 129 000203 134 000204 137 000212 141 000227 142 000232 143 000234 144 000236 145 000240 146 000242 147 000246 148 000251 149 000255 150 000261 151 000265 152 000271 153 000274 154 000276 155 000300 156 000302 157 000304 158 000310 160 000314 162 000316 163 000317 164 000333 165 000347 166 000363 167 000377 168 000413 169 000427 170 000431 171 000440 172 000522 173 000523 174 000526 175 000535 176 000617 177 000620 178 000627 179 000711 180 000721 181 001002 182 001012 183 001073 184 001103 186 001154 189 001164 194 001165 203 001166 204 001203 207 001205 209 001211 210 001230 212 001235 214 001236 215 001242 216 001243 217 001244 218 001250 219 001252 220 001254 221 001255 223 001257 224 001263 226 001266 227 001272 234 001301 236 001303 237 001305 238 001307 239 001311 240 001312 241 001316 243 001321 244 001322 245 001332 246 001341 247 001351 248 001360 249 001370 250 001377 251 001407 252 001416 253 001425 254 001434 255 001443 256 001453 257 001456 258 001503 259 001505 260 001510 261 001511 262 001516 263 001543 264 001546 265 001547 266 001554 267 001601 268 001604 269 001605 270 001607 271 001634 272 001637 273 001640 274 001643 275 001670 276 001673 277 001674 278 001676 279 001723 285 001726 288 001727 293 001730 296 001731 298 001743 299 001746 300 001750 301 001752 302 001754 303 001756 304 001763 305 001767 306 001774 307 002001 308 002006 309 002012 310 002015 311 002017 312 002024 314 002031 317 002041 320 002051 335 002052 351 002066 352 002071 353 002072 354 002074 356 002116 357 002127 ----------------------------------------------------------- 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