COMPILATION LISTING OF SEGMENT speedtype_info_ Compiled by: Multics PL/I Compiler, Release 27b, of September 15, 1981 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 02/04/82 1411.8 mst Thu Options: optimize map 1 /* ************************************************************ 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1980. * 6* * * 7* ************************************************************ */ 8 9 10 speedtype_info_: procedure; 11 12 /* This procedure is an internal interface of the Speedtype subsystem. 13* * Created on 12/31/75 by Bill Silver as notescript_info_. 14* * Changed on 06/13/77 by Bill Silver to speedtype_info_. 15* * Changed on 10/28/80 by Paul Benjamin for special suffixing. 16* * Added expand_table entrypoint. 17* * Fixed deleted symbol dictionary bug. 18* * Changed on 11/09/81 by Paul Benjamin to fix bug where expanding 19* * symbol dict causes some expansions to be overlaid. 20* * 21* * It is called to set and get a pointer and pathname of the current 22* * Speedtype symbol dictionary. It has the following entry points: 23* * 24* * expand_table: Add another 100 entries to symbol dictionary. 25* * use: Set up to use new symbol dictionary. 26* * name: Return the name of the current symbol dictionary. 27* * pointer: Return a pointer to the current symbol dictionary. 28* * set_bc: Sets bit count of the current symbol dictionary. 29* * shrink_table: Remove 100 entries from symbol dictionary. 30**/ 31 32 /* ARGUMENTS */ 33 34 dcl arg_dir_name char (168); /* (I/O) Directory name of current symbol dictionary. */ 35 dcl arg_ecode fixed bin (35); /* (O) Error table code. */ 36 dcl arg_ent_name char (32); /* (I/O) Entry name of current symbol dictionary. */ 37 dcl arg_ssd_ptr ptr; /* (O) Pointer to current notescri Pt segment. */ 38 39 40 /* AUTOMATIC DATA */ 41 42 dcl account char (32); /* Just used to satisfy call arguments. */ 43 dcl answer char (4) varying; /* Answer to command query. */ 44 dcl bit_count fixed bin (24); /* Bit count of the symbol dictionary. */ 45 dcl ecode fixed bin (35); /* Error table code. */ 46 dcl (i, j) fixed bin; 47 dcl project char (9); /* Not used. */ 48 dcl words fixed bin (19); /* Size in words of symbol dictionary. */ 49 50 dcl 1 query_info aligned, /* Info structure for command_query_. */ 51 2 version fixed bin, 52 (2 yes_no bit (1), 53 2 suppress_name bit (1)) unaligned, 54 2 status_code fixed bin, 55 2 other_code fixed bin; 56 57 58 /* INTERNAL STATIC DATA */ 59 60 dcl cur_dir_name char (168) /* Directory name of current symbol dictionary. */ 61 internal static init (" "); 62 dcl cur_ent_name char (32) /* Entry name of current symbol dictionary. */ 63 internal static init (" "); 64 dcl cur_ssd_ptr ptr /* Pointer to current symbol dictionary. */ 65 internal static init (null ()); 66 67 dcl new_line char (1) /* Used to set up delimiter string. */ 68 internal static init (" 69 "); 70 71 dcl default_prefixes char (2) /* Under, upper. */ 72 internal static init ("_|"); 73 74 dcl default_suffixes char (5) /* Plural, ing, ed, ly, able. */ 75 internal static init ("+-*=|"); 76 77 dcl default_escapes char (5) /* Pad, perm, temp, trans, space */ 78 internal static init ("`~:;"); 79 80 dcl default_delimiters char (12) /* Default delimiters: ,?!"()<>[]{} */ 81 internal static init (",""()?!<>[]{}"); 82 83 84 /* EXTERNAL ENTRIES CALLED */ 85 86 dcl (addr, index, null, size, substr) builtin; 87 88 dcl error_table_$bad_arg fixed bin (35) external; 89 dcl error_table_$no_w_permission fixed bin (35) external; 90 dcl error_table_$noentry fixed bin (35) external; 91 dcl error_table_$unimplemented_version fixed bin (35) external; 92 93 dcl clock_ entry returns (fixed bin (71)); 94 dcl com_err_ entry options (variable); 95 dcl command_query_ entry options (variable); 96 dcl hcs_$chname_seg entry (ptr, char(*), char(*), fixed bin(35)); 97 dcl hcs_$delentry_seg entry (ptr, fixed bin(35)); 98 dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin, fixed bin, ptr, fixed bin (35)); 99 dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); 100 dcl hcs_$set_bc_seg entry (ptr, fixed bin (24), fixed bin (35)); 101 dcl hcs_$truncate_seg entry (ptr, fixed bin(19), fixed bin(35)); 102 dcl ioa_ entry() options(variable); 103 dcl nd_handler_ entry (char(*), char(*), char(*), fixed bin(35)); 104 dcl speedtype_info_$set_bc entry (ptr, fixed bin (35)); 105 dcl user_info_$homedir entry (char (*)); 106 dcl user_info_$whoami entry (char (*), char (*), char (*)); 107 /* */ 1 1 /* Begin include file ... speedtype_symbols.incl.pl1 1 2** Created on 09/06/76 by Bill Silver. 1 3** Modified 06/03/80 by Paul Benjamin to allow special suffixing. 1 4** 1 5** This include file defines the format of a Speedtype Symbol Dictionary. 1 6** The default Speedtype options are: 1 7** 1 8** ESCAPES: 1 9** temp "~" pad (Octal 177) perm "`" trans ":" space ";" 1 10** PREFIXES: 1 11** under "_" upper "+" 1 12** SUFFIXES: 1 13** plural "+" ed "-" ing "*" er "=" ly "|" 1 14** DELIMITERS: 1 15** ,"()?!<>[]{} 1 16**/ 1 17 dcl ssd_ptr ptr; /* Pointer to the base of a Speedtype Symbol Dictionary. */ 1 18 dcl exp_ptr ptr; /* Pointer to an expansion entry. */ 1 19 dcl sb_ptr ptr; /* Pointer to a symbol entry. */ 1 20 dcl spc_ptr ptr; /* Pointer to a special entry. */ 1 21 dcl delim_ptr ptr; /* Pointer to delimiter characters. */ 1 22 1 23 dcl ssd_version_2 fixed bin /* Version of this include file. */ 1 24 internal static init (2); 1 25 1 26 dcl 1 ssd based(ssd_ptr) aligned, /* Format of a Speedtype Symbol Dictionary. */ 1 27 2 version fixed bin, /* Version number. Currently = 2. */ 1 28 2 identifier char(12), /* "Seedtype_SD" => this is a Speedtype Symbol Dictionary. */ 1 29 2 flags bit(36), /* Not used, all zero. */ 1 30 2 delimiters char(24), /* Blank, New Line, Tab, Escapes, Others. */ 1 31 2 escapes char(5), /* Pad, Perm, Temp, Trans, Space */ 1 32 2 prefixes char(2), /* Under, Upper. */ 1 33 2 suffixes char(5), /* Plural, ed, ing, er, ly. */ 1 34 2 num_symbols fixed bin, /* Number of defined symbols. */ 1 35 2 table_size fixed bin, /* Size of the 3 tables to follow. */ 1 36 2 pad(14) bit(36), /* Round out header to 32 words. */ 1 37 2 spec_tab(table_size) like spc, /* Special entries. */ 1 38 2 exp_tab(table_size) like exp, /* Expansion entries. */ 1 39 2 sb_tab(table_size) like sb; /* Symbol entries. */ 1 40 1 41 dcl 1 delim_chars based(delim_ptr) aligned, /* Overlay of ssd.delimiters. */ 1 42 ( 2 blank char(1), 1 43 2 new_line char(1), 1 44 2 tab char(1), 1 45 2 escapes char(5), 1 46 2 others char(16)) unaligned; 1 47 1 48 dcl 1 sb based(sb_ptr) aligned, /* Symbol entry. */ 1 49 ( 2 new_line char(1), /* Needed to make index functions work. */ 1 50 2 symbol char(7)) unal; /* Actual symbol string. */ 1 51 1 52 dcl 1 exp based(exp_ptr) aligned, /* Expansion entry. */ 1 53 ( 2 actionx(5) fixed bin(8), /* Action index for each suffix. */ 1 54 2 pad fixed bin(17), /* Reserved for additional suffixes, flags, etc.. */ 1 55 2 len fixed bin(8), /* Actual length of expansion. */ 1 56 2 expansion char(56)) unal; /* Expansion of string (56 => size(exp) = 16 words). */ 1 57 dcl 1 spc based(spc_ptr) aligned, /* Special entry. */ 1 58 2 special (5) char(56) unal; /* One for each possible suffix. */ 1 59 1 60 /* End include file ... speedtype_symbols.incl.pl1 */ 108 109 /* */ 110 use: entry (arg_dir_name, arg_ent_name, arg_ecode); 111 112 /* This entry specifies the pathname of a new symbol dictionary. 113* * The current symbol dictionary (if there is one) is no longer used. 114* * This symbol dictionary is used for all future Speedtype operations 115* * for this process until a new symbol dictionary is specified. 116**/ 117 ssd_ptr = null (); 118 cur_dir_name = arg_dir_name; /* Save pathname of new symbol dictionary. */ 119 cur_ent_name = arg_ent_name; 120 121 call GET_POINTER; /* Establish new symbol dictionary. */ 122 arg_ecode = ecode; 123 return; 124 125 126 127 name: entry (arg_dir_name, arg_ent_name, arg_ecode); 128 129 /* This entry will return the pathname of the current symbol dictionary. 130**/ 131 call GET_POINTER; 132 arg_dir_name = cur_dir_name; /* Copy current pathname. */ 133 arg_ent_name = cur_ent_name; 134 arg_ecode = ecode; 135 return; 136 137 138 139 pointer: entry (arg_ssd_ptr, arg_ecode); 140 141 /* This entry is called to return a pointer to the current symbol dictionary. 142**/ 143 call GET_POINTER; /* Get pointer. */ 144 arg_ssd_ptr = cur_ssd_ptr; /* Return current pointer. */ 145 arg_ecode = ecode; 146 return; 147 148 149 150 set_bc: entry (arg_ssd_ptr, arg_ecode); 151 152 /* This entry is called to set the bit count of the current symbol dictionary. 153**/ 154 ssd_ptr = arg_ssd_ptr; 155 words = size (ssd); /* Start with the whole segment. */ 156 /* Subtract unused symbol entries. */ 157 words = words - ((hbound (sb_tab, 1) - ssd.num_symbols) * size (sb)); 158 bit_count = words * 36; 159 call hcs_$set_bc_seg (ssd_ptr, bit_count, ecode); 160 if ecode ^= 0 161 then call com_err_ (ecode, "Speedtype", "Error setting bit count of symbol dictionary."); 162 arg_ecode = ecode; 163 return; 164 165 expand_table: 166 entry (arg_ssd_ptr, arg_ecode); 167 168 /* This entry is called to add 100 more entries to the symbol dictionary. */ 169 170 ssd_ptr = arg_ssd_ptr; 171 call EXPAND; 172 arg_ecode = ecode; 173 return; 174 175 shrink_table: 176 entry (arg_ssd_ptr, arg_ecode); 177 178 /* This entry is called to remove the last 100 from the symbol dictionary. */ 179 180 ssd_ptr = arg_ssd_ptr; 181 call SHRINK; 182 arg_ecode = ecode; 183 return; 184 185 186 GET_POINTER: procedure; 187 188 /* This procedure is called to get a pointer to the current symbol dictionary. 189**/ 190 ecode = 0; 191 if cur_ent_name = " " /* Have we been told what symbol dictionary to use? */ 192 then do; /* No, use default symbol dictionary. */ 193 call user_info_$homedir (cur_dir_name); 194 call user_info_$whoami (cur_ent_name, project, account); 195 i = index (cur_ent_name, " ") - 1; /* Add ".symbols" suffix. */ 196 cur_ent_name = substr (cur_ent_name, 1, i) || ".symbols"; 197 end; 198 199 call INITIATE_SSD; /* Initiate symbol dictionary. */ 200 if ecode ^= 0 then return; 201 202 if ssd.identifier ^= "Speedtype_SD" /* Make sure this is a symbol dictionary. */ 203 then do; /* It is not. */ 204 call com_err_ (0, "Speedtype", "^a>^a is not a valid Speedtype symbol dictionary", 205 cur_dir_name, cur_ent_name); 206 ecode = error_table_$bad_arg; /* Note error. */ 207 return; 208 end; 209 210 if ssd.version ^= ssd_version_2 /* Check for current version. */ 211 then do; /* Not the current version. */ 212 call CONVERT_VERSIONS; /* Convert symbol dictionary. */ 213 if ecode ^= 0 then return; 214 end; 215 216 cur_ssd_ptr = ssd_ptr; /* Save current pointer. */ 217 218 end GET_POINTER; 219 /* */ 220 INITIATE_SSD: procedure; 221 222 /* This procedure is called to initiate the symbol dictionary whose pathname 223* * is defined in internal static. If this segment does not exist, it is 224* * created. We will ask the user if he really wants to create this 225* * new symbol dictionary. If so we will created it and initialize it. 226**/ 227 call hcs_$initiate (cur_dir_name, cur_ent_name, "", 0, 0, ssd_ptr, ecode); 228 if ssd_ptr ^= null () /* Got pointer, assume segment initiated OK. */ 229 then do; 230 ecode = 0; /* Make sure no error code. */ 231 return; 232 end; 233 234 if ecode ^= error_table_$noentry /* Fatal error? */ 235 then do; /* Yes, no way to initiate segment. */ 236 call com_err_ (ecode, "Speedtype", "Unable to get pointer to ^a>^a", 237 cur_dir_name, cur_ent_name); 238 return; 239 end; 240 241 query_info.version = 0; /* Set up query info. */ 242 query_info.yes_no = "1"b; 243 query_info.suppress_name = "0"b; 244 query_info.status_code, 245 query_info.other_code = 0; 246 call command_query_ (addr (query_info), answer, "Speedtype", 247 "^a>^a not found. ^/Do you want to create it?", cur_dir_name, cur_ent_name); 248 if answer = "no" /* Does user want new symbol dictionary? */ 249 then do; /* No. */ 250 ecode = 1; /* Note that no symbol dictionary segment created. */ 251 return; 252 end; 253 254 call hcs_$make_seg (cur_dir_name, cur_ent_name, "", 01010b, ssd_ptr, ecode); 255 if ecode ^= 0 /* Did we create segment successfully? */ 256 then do; /* No, fatal error. */ 257 call com_err_ (ecode, "Speedtype", "Unable to create ^a>^a", cur_dir_name, cur_ent_name); 258 return; 259 end; 260 261 call INIT_SSD_SEG; /* Initialize the new symbol dictionary. */ 262 263 call speedtype_info_$set_bc (ssd_ptr, ecode); /* Set bit count of new symbol dictionary. */ 264 265 end INITIATE_SSD; 266 /* */ 267 INIT_SSD_SEG: procedure; 268 269 /* This procedure is called to initialize a Speedtype symbol dictionary. 270* * Default values will be used for all fields. 271**/ 272 273 ssd.version = ssd_version_2; /* Initialize header of new symbol dictionary. */ 274 ssd.flags = "0"b; 275 delim_ptr = addr (ssd.delimiters); /* Set up overlay of delimiter string. */ 276 delim_chars.blank = " "; /* Now fill in delimiter characters. */ 277 delim_chars.new_line = new_line; 278 delim_chars.tab = " "; 279 delim_chars.escapes = default_escapes; /* Escapes are delimiters too. */ 280 delim_chars.others = default_delimiters; 281 ssd.escapes = default_escapes; /* Now set up default special characters. */ 282 ssd.prefixes = default_prefixes; 283 ssd.suffixes = default_suffixes; 284 ssd.num_symbols = 0; /* No symbols defined yet. */ 285 ssd.identifier = "Speedtype_SD"; /* Mark this as a symbol dictionary. */ 286 ssd.table_size = 100; /* Allocate 100 symbols initially. */ 287 288 end INIT_SSD_SEG; 289 /* */ 290 CONVERT_VERSIONS: procedure; 291 292 /* This procedure is called to convert old versions of symbol dictionaries into 293* * the current version. 294**/ 295 296 dcl old_ssd_ptr ptr; 297 298 dcl 1 old_ssd based(old_ssd_ptr) aligned, /* Format of a Speedtype Symbol Dictionary. */ 299 2 version fixed bin, /* Version number. Currently = 1. */ 300 2 identifier char(12), /* "Speedtype_SD" => this is a Speedtype Symbol Dictionary. */ 301 2 flags bit(36), /* Not used, all zero. */ 302 2 delimiters char(24), /* Blank, New Line, Tab, Escapes, Others. */ 303 2 escapes char(5), /* Pad, Perm, Temp, Trans, Space */ 304 2 prefixes char(2), /* Under, Upper. */ 305 2 suffixes char(5), /* Plural, ed, ing, er, ly. */ 306 2 num_symbols fixed bin, /* Number of defined symbols. */ 307 2 pad(15) bit(36), /* Round out header to 32 words. */ 308 2 sb_tab(1008) like sb, /* Symbol entries. */ 309 2 exp_tab(1008) like exp; /* Expansion entries. */ 310 311 dcl no_write_permission condition; 312 313 on no_write_permission goto nowrite; 314 315 old_ssd_ptr = ssd_ptr; 316 317 call hcs_$make_seg ("", "speedtype_scratch", "", 01010b, ssd_ptr, ecode); 318 if ssd_ptr = null() 319 then return; 320 321 ssd.version = ssd_version_2; 322 ssd.identifier = old_ssd.identifier; 323 ssd.flags = old_ssd.flags; 324 ssd.delimiters = old_ssd.delimiters; 325 ssd.escapes = old_ssd.escapes; 326 ssd.prefixes = old_ssd.prefixes; 327 ssd.suffixes = old_ssd.suffixes; 328 ssd.num_symbols = old_ssd.num_symbols; 329 ssd.table_size = (divide(old_ssd.num_symbols,100,17,0)+1)*100; 330 do i = 1 to old_ssd.num_symbols; 331 ssd.exp_tab(i) = old_ssd.exp_tab(i); 332 ssd.sb_tab(i) = old_ssd.sb_tab(i); 333 end; 334 words = words - ((hbound (spec_tab, 1) - ssd.num_symbols) * size (spc)); 335 old_ssd_ptr -> ssd = ssd; 336 337 call hcs_$delentry_seg (ssd_ptr, ecode); 338 if ecode ^= 0 339 then return; 340 341 ssd_ptr = old_ssd_ptr; 342 343 call speedtype_info_$set_bc (ssd_ptr, ecode); 344 345 return; 346 347 nowrite: call hcs_$delentry_seg (ssd_ptr, ecode); 348 ecode = error_table_$no_w_permission; 349 350 return; 351 352 end CONVERT_VERSIONS; 353 354 EXPAND: proc; 355 356 dcl (a, b, c) fixed; 357 dcl 1 new_ssd based(ssd_ptr) aligned, 358 2 pad (32) bit(36), 359 2 spec_tab (a) like spc, 360 2 exp_tab (b) like exp, 361 2 sb_tab (c) like sb; 362 363 a,b = ssd.table_size + 100; 364 c = ssd.table_size; 365 new_ssd.sb_tab = ssd.sb_tab; 366 b = ssd.table_size; 367 do i = b to 1 by -1; /* Must go backwards so as not */ 368 new_ssd.exp_tab (i) = ssd.exp_tab (i); /* to overlay any data */ 369 end; 370 ecode = 0; 371 ssd.table_size = ssd.table_size + 100; 372 end; 373 374 SHRINK: proc; 375 376 dcl (a,b,c) fixed; 377 dcl 1 old_ssd based(ssd_ptr) aligned, 378 2 pad (32) bit(36), 379 2 spec_tab (a) like spc, 380 2 exp_tab (b) like exp, 381 2 sb_tab (c) like sb; 382 383 ssd.table_size = ssd.table_size - 100; 384 a = ssd.table_size + 100; 385 b = ssd.table_size; 386 ssd.exp_tab = old_ssd.exp_tab; 387 b = ssd.table_size + 100; 388 c = ssd.table_size; 389 ssd.sb_tab = old_ssd.sb_tab; 390 ecode = 0; 391 392 end; 393 394 end speedtype_info_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 02/04/82 1351.1 speedtype_info_.pl1 >spec>on>02/04/82>speedtype_info_.pl1 108 1 11/14/80 1152.8 speedtype_symbols.incl.pl1 >ldd>include_1>speedtype_symbols.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. a 000164 automatic fixed bin(17,0) dcl 356 in procedure "EXPAND" set ref 363* 365 365 365 368 368 a 000176 automatic fixed bin(17,0) dcl 376 in procedure "SHRINK" set ref 384* 386 386 386 386 386 389 389 389 account 000100 automatic char(32) unaligned dcl 42 set ref 194* addr builtin function dcl 86 ref 246 246 275 answer 000110 automatic varying char(4) dcl 43 set ref 246* 248 arg_dir_name parameter char(168) unaligned dcl 34 set ref 110 118 127 132* arg_ecode parameter fixed bin(35,0) dcl 35 set ref 110 122* 127 134* 139 145* 150 162* 165 172* 175 182* arg_ent_name parameter char(32) unaligned dcl 36 set ref 110 119 127 133* arg_ssd_ptr parameter pointer dcl 37 set ref 139 144* 150 154 165 170 175 180 b 000177 automatic fixed bin(17,0) dcl 376 in procedure "SHRINK" set ref 385* 386 387* 389 389 389 b 000165 automatic fixed bin(17,0) dcl 356 in procedure "EXPAND" set ref 363* 365 365 365 366* 367 bit_count 000112 automatic fixed bin(24,0) dcl 44 set ref 158* 159* blank based char(1) level 2 packed unaligned dcl 1-41 set ref 276* c 000200 automatic fixed bin(17,0) dcl 376 in procedure "SHRINK" set ref 388* 389 c 000166 automatic fixed bin(17,0) dcl 356 in procedure "EXPAND" set ref 364* 365 com_err_ 000102 constant entry external dcl 94 ref 160 204 236 257 command_query_ 000104 constant entry external dcl 95 ref 246 cur_dir_name 000010 internal static char(168) initial unaligned dcl 60 set ref 118* 132 193* 204* 227* 236* 246* 254* 257* cur_ent_name 000062 internal static char(32) initial unaligned dcl 62 set ref 119* 133 191 194* 195 196* 196 204* 227* 236* 246* 254* 257* cur_ssd_ptr 000072 internal static pointer initial dcl 64 set ref 144 216* default_delimiters 000000 constant char(12) initial unaligned dcl 80 ref 280 default_escapes 000004 constant char(5) initial unaligned dcl 77 ref 279 281 default_prefixes constant char(2) initial unaligned dcl 71 ref 282 default_suffixes 000006 constant char(5) initial unaligned dcl 74 ref 283 delim_chars based structure level 1 dcl 1-41 delim_ptr 000130 automatic pointer dcl 1-21 set ref 275* 276 277 278 279 280 delimiters 5 based char(24) level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 275 324* delimiters 5 based char(24) level 2 in structure "old_ssd" dcl 298 in procedure "CONVERT_VERSIONS" ref 324 ecode 000113 automatic fixed bin(35,0) dcl 45 set ref 122 134 145 159* 160 160* 162 172 182 190* 200 206* 213 227* 230* 234 236* 250* 254* 255 257* 263* 317* 337* 338 343* 347* 348* 370* 390* error_table_$bad_arg 000074 external static fixed bin(35,0) dcl 88 ref 206 error_table_$no_w_permission 000076 external static fixed bin(35,0) dcl 89 ref 348 error_table_$noentry 000100 external static fixed bin(35,0) dcl 90 ref 234 escapes 0(27) based char(5) level 2 in structure "delim_chars" packed unaligned dcl 1-41 in procedure "speedtype_info_" set ref 279* escapes 13 based char(5) level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 281* 325* escapes 13 based char(5) level 2 in structure "old_ssd" dcl 298 in procedure "CONVERT_VERSIONS" ref 325 exp based structure level 1 dcl 1-52 exp_tab based structure array level 2 in structure "old_ssd" dcl 377 in procedure "SHRINK" ref 386 exp_tab 4000 based structure array level 2 in structure "old_ssd" dcl 298 in procedure "CONVERT_VERSIONS" ref 331 exp_tab based structure array level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 331* 368 386* exp_tab based structure array level 2 in structure "new_ssd" dcl 357 in procedure "EXPAND" set ref 368* flags 4 based bit(36) level 2 in structure "old_ssd" dcl 298 in procedure "CONVERT_VERSIONS" ref 323 flags 4 based bit(36) level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 274* 323* hcs_$delentry_seg 000106 constant entry external dcl 97 ref 337 347 hcs_$initiate 000110 constant entry external dcl 98 ref 227 hcs_$make_seg 000112 constant entry external dcl 99 ref 254 317 hcs_$set_bc_seg 000114 constant entry external dcl 100 ref 159 i 000114 automatic fixed bin(17,0) dcl 46 set ref 195* 196 330* 331 331 332 332* 367* 368 368* identifier 1 based char(12) level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 202 285* 322* identifier 1 based char(12) level 2 in structure "old_ssd" dcl 298 in procedure "CONVERT_VERSIONS" ref 322 index builtin function dcl 86 ref 195 new_line constant char(1) initial unaligned dcl 67 in procedure "speedtype_info_" ref 277 new_line 0(09) based char(1) level 2 in structure "delim_chars" packed unaligned dcl 1-41 in procedure "speedtype_info_" set ref 277* new_ssd based structure level 1 dcl 357 no_write_permission 000102 stack reference condition dcl 311 ref 313 null builtin function dcl 86 ref 117 228 318 num_symbols 20 based fixed bin(17,0) level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 157 284* 328* 334 num_symbols 20 based fixed bin(17,0) level 2 in structure "old_ssd" dcl 298 in procedure "CONVERT_VERSIONS" ref 328 329 330 old_ssd based structure level 1 dcl 377 in procedure "SHRINK" old_ssd based structure level 1 dcl 298 in procedure "CONVERT_VERSIONS" old_ssd_ptr 000100 automatic pointer dcl 296 set ref 315* 322 323 324 325 326 327 328 329 330 331 332 335 341 other_code 3 000121 automatic fixed bin(17,0) level 2 dcl 50 set ref 244* others 2 based char(16) level 2 packed unaligned dcl 1-41 set ref 280* prefixes 15 based char(2) level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 282* 326* prefixes 15 based char(2) level 2 in structure "old_ssd" dcl 298 in procedure "CONVERT_VERSIONS" ref 326 project 000115 automatic char(9) unaligned dcl 47 set ref 194* query_info 000121 automatic structure level 1 dcl 50 set ref 246 246 sb based structure level 1 dcl 1-48 ref 157 sb_ptr automatic pointer dcl 1-19 ref 157 sb_tab based structure array level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 157 332* 365 389* sb_tab 40 based structure array level 2 in structure "old_ssd" dcl 298 in procedure "CONVERT_VERSIONS" ref 332 sb_tab based structure array level 2 in structure "new_ssd" dcl 357 in procedure "EXPAND" set ref 365* sb_tab based structure array level 2 in structure "old_ssd" dcl 377 in procedure "SHRINK" ref 389 size builtin function dcl 86 ref 155 157 334 spc based structure level 1 dcl 1-57 ref 334 spc_ptr automatic pointer dcl 1-20 ref 334 spec_tab 40 based structure array level 2 dcl 1-26 set ref 334 speedtype_info_$set_bc 000116 constant entry external dcl 104 ref 263 343 ssd based structure level 1 dcl 1-26 set ref 155 335* 335 ssd_ptr 000126 automatic pointer dcl 1-17 set ref 117* 154* 155 155 155 155 157 157 157 157 157 159* 170* 180* 202 210 216 227* 228 254* 263* 273 274 275 281 282 283 284 285 286 315 317* 318 321 322 323 324 325 326 327 328 329 331 331 331 332 332 332 332 332 334 334 334 335 335 335 335 337* 341* 343* 347* 363 364 365 365 365 365 365 365 365 365 365 366 368 368 368 368 371 371 383 383 384 385 386 386 386 386 386 386 386 386 387 388 389 389 389 389 389 389 389 389 389 ssd_version_2 constant fixed bin(17,0) initial dcl 1-23 ref 210 273 321 status_code 2 000121 automatic fixed bin(17,0) level 2 dcl 50 set ref 244* substr builtin function dcl 86 ref 196 suffixes 16 based char(5) level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 283* 327* suffixes 16 based char(5) level 2 in structure "old_ssd" dcl 298 in procedure "CONVERT_VERSIONS" ref 327 suppress_name 1(01) 000121 automatic bit(1) level 2 packed unaligned dcl 50 set ref 243* tab 0(18) based char(1) level 2 packed unaligned dcl 1-41 set ref 278* table_size 21 based fixed bin(17,0) level 2 dcl 1-26 set ref 155 155 155 157 157 157 286* 329* 331 331 332 332 332 332 334 335 335 335 363 364 365 365 365 365 365 365 365 366 368 368 371* 371 383* 383 384 385 386 386 386 386 386 386 387 388 389 389 389 389 389 389 389 user_info_$homedir 000120 constant entry external dcl 105 ref 193 user_info_$whoami 000122 constant entry external dcl 106 ref 194 version based fixed bin(17,0) level 2 in structure "ssd" dcl 1-26 in procedure "speedtype_info_" set ref 210 273* 321* version 000121 automatic fixed bin(17,0) level 2 in structure "query_info" dcl 50 in procedure "speedtype_info_" set ref 241* words 000120 automatic fixed bin(19,0) dcl 48 set ref 155* 157* 157 158 334* 334 yes_no 1 000121 automatic bit(1) level 2 packed unaligned dcl 50 set ref 242* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. clock_ 000000 constant entry external dcl 93 error_table_$unimplemented_version external static fixed bin(35,0) dcl 91 exp_ptr automatic pointer dcl 1-18 hcs_$chname_seg 000000 constant entry external dcl 96 hcs_$truncate_seg 000000 constant entry external dcl 101 ioa_ 000000 constant entry external dcl 102 j automatic fixed bin(17,0) dcl 46 nd_handler_ 000000 constant entry external dcl 103 NAMES DECLARED BY EXPLICIT CONTEXT. CONVERT_VERSIONS 001207 constant entry internal dcl 290 ref 212 EXPAND 001515 constant entry internal dcl 354 ref 171 GET_POINTER 000434 constant entry internal dcl 186 ref 121 131 143 INITIATE_SSD 000616 constant entry internal dcl 220 ref 199 INIT_SSD_SEG 001142 constant entry internal dcl 267 ref 261 SHRINK 001665 constant entry internal dcl 374 ref 181 expand_table 000372 constant entry external dcl 165 name 000203 constant entry external dcl 127 nowrite 001476 constant label dcl 347 ref 313 pointer 000235 constant entry external dcl 139 set_bc 000257 constant entry external dcl 150 shrink_table 000414 constant entry external dcl 175 speedtype_info_ 000140 constant entry external dcl 10 use 000152 constant entry external dcl 110 NAMES DECLARED BY CONTEXT OR IMPLICATION. divide builtin function ref 329 hbound builtin function ref 157 334 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2376 2522 2151 2406 Length 2760 2151 124 222 224 64 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME speedtype_info_ 287 external procedure is an external procedure. GET_POINTER internal procedure shares stack frame of external procedure speedtype_info_. INITIATE_SSD internal procedure shares stack frame of external procedure speedtype_info_. INIT_SSD_SEG internal procedure shares stack frame of external procedure speedtype_info_. CONVERT_VERSIONS 108 internal procedure enables or reverts conditions. on unit on line 313 64 on unit EXPAND internal procedure shares stack frame of external procedure speedtype_info_. SHRINK internal procedure shares stack frame of external procedure speedtype_info_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 cur_dir_name speedtype_info_ 000062 cur_ent_name speedtype_info_ 000072 cur_ssd_ptr speedtype_info_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME CONVERT_VERSIONS 000100 old_ssd_ptr CONVERT_VERSIONS speedtype_info_ 000100 account speedtype_info_ 000110 answer speedtype_info_ 000112 bit_count speedtype_info_ 000113 ecode speedtype_info_ 000114 i speedtype_info_ 000115 project speedtype_info_ 000120 words speedtype_info_ 000121 query_info speedtype_info_ 000126 ssd_ptr speedtype_info_ 000130 delim_ptr speedtype_info_ 000164 a EXPAND 000165 b EXPAND 000166 c EXPAND 000176 a SHRINK 000177 b SHRINK 000200 c SHRINK THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs call_ext_out_desc call_ext_out call_int_this return tra_ext bound_check_signal enable shorten_stack ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ command_query_ hcs_$delentry_seg hcs_$initiate hcs_$make_seg hcs_$set_bc_seg speedtype_info_$set_bc user_info_$homedir user_info_$whoami THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_arg error_table_$no_w_permission error_table_$noentry LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 10 000137 110 000145 117 000162 118 000164 119 000171 121 000175 122 000176 123 000200 127 000201 131 000213 132 000214 133 000222 134 000226 135 000230 139 000231 143 000245 144 000246 145 000252 146 000254 150 000255 154 000267 155 000273 157 000307 158 000315 159 000317 160 000332 162 000365 163 000367 165 000370 170 000402 171 000406 172 000407 173 000411 175 000412 180 000424 181 000430 182 000431 183 000433 186 000434 190 000435 191 000436 193 000443 194 000453 195 000473 196 000504 197 000520 199 000521 200 000522 202 000525 204 000532 206 000574 207 000577 210 000600 212 000603 213 000607 216 000612 218 000615 220 000616 227 000617 228 000661 230 000665 231 000666 234 000667 236 000673 238 000733 241 000734 242 000735 243 000737 244 000741 246 000743 248 001011 250 001016 251 001020 254 001021 255 001060 257 001062 258 001126 261 001127 263 001130 265 001141 267 001142 273 001143 274 001145 275 001147 276 001151 277 001153 278 001155 279 001157 280 001162 281 001165 282 001170 283 001172 284 001175 285 001176 286 001203 288 001205 290 001206 313 001214 315 001233 317 001236 318 001303 321 001310 322 001312 323 001322 324 001324 325 001327 326 001333 327 001335 328 001341 329 001343 330 001350 331 001360 332 001377 333 001415 334 001417 335 001426 337 001446 338 001457 341 001462 343 001464 345 001475 347 001476 348 001510 350 001514 354 001515 363 001516 364 001523 365 001525 366 001626 367 001630 368 001634 369 001655 370 001660 371 001661 372 001664 374 001665 383 001666 384 001671 385 001674 386 001676 387 002033 388 002036 389 002040 390 002141 392 002142 ----------------------------------------------------------- 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