COMPILATION LISTING OF SEGMENT digram_table_compiler Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/15/82 1749.0 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* *********************************************************** */ 6 /* This command compiles a source segment containing digrams for 7* the word generator and puts the compiled output in a segment 8* named "digrams". 9* 10* Usage: digram_table_compiler pathname -option- 11* 12* Where: option may be one of the following: 13* 14* -ls, -list Lists the output on the terminal after compilation. 15* -ls, n, -list n Lists as above, but in n columns. 16* 17* Usage: print_digram_table -n- 18* 19* n Lists the output in n columns. Allow 14 positions for each column. 20* This call assuumes that the digrams segment already exists 21* and has been compiled correctly. 22**/ 23 24 digram_table_compiler: procedure; 25 dcl (start, size) fixed bin; 26 dcl nrows fixed bin; 27 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); 28 dcl code fixed bin (35); 29 dcl codex fixed bin; 30 dcl cv_dec_check_ entry (char (*), fixed bin) returns (fixed bin (35)); 31 dcl hcs_$truncate_seg entry (ptr, fixed bin, fixed bin (35)); 32 dcl hcs_$terminate_name entry (char (*), fixed bin (35)); 33 dcl com_err_ entry options (variable); 34 dcl (error_table_$noarg, error_table_$badopt) external fixed bin (35); 35 dcl get_line_length_$switch entry (ptr, fixed bin (35)) returns (fixed bin (17)); 36 dcl read_table_ entry (ptr, fixed bin (24)) returns (bit (1)); 37 dcl compile bit (1); 38 dcl who char (25) varying; 39 dcl list bit (1); 40 dcl segptr ptr static init (null); 41 dcl dirname char (168) aligned; 42 dcl ename char (32) aligned; 43 dcl ename_length fixed bin; 44 dcl null builtin; 45 dcl arg char (length) based (pp); 46 dcl hcs_$initiate_count entry (char (*), char (*), char (*), 47 fixed bin (24), fixed bin (2), ptr, fixed bin (35)); 48 dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); 49 dcl expand_path_ entry (ptr, fixed bin, ptr, ptr, fixed bin (35)); 50 dcl bc fixed bin (24); 51 dcl i fixed; 1 1 1 2 /* ******** include file digram_structure.incl.pl1 ******* */ 1 3 1 4 dcl digrams$digrams external; 1 5 dcl digrams$n_units fixed bin external; 1 6 dcl digrams$letters external; 1 7 dcl digrams$rules external; 1 8 1 9 /* This array contains information about all possible pairs of units */ 1 10 1 11 dcl 1 digrams (n_units, n_units) based (addr (digrams$digrams)), 1 12 2 begin bit (1), /* on if this pair must begin syllable */ 1 13 2 not_begin bit (1), /* on if this pair must not begin */ 1 14 2 end bit (1), /* on if this pair must end syllable */ 1 15 2 not_end bit (1), /* on if this pair must not end */ 1 16 2 break bit (1), /* on if this pair is a break pair */ 1 17 2 prefix bit (1), /* on if vowel must precede this pair in same syllable */ 1 18 2 suffix bit (1), /* on if vowel must follow this pair in same syllable */ 1 19 2 illegal_pair bit (1), /* on if this pair may not appear */ 1 20 2 pad bit (1); /* this makes 9 bits/entry */ 1 21 1 22 /* This array contains left justified 1 or 2-letter pairs representing each unit */ 1 23 1 24 dcl letters (0:n_units) char (2) aligned based (addr (digrams$letters)); 1 25 1 26 /* This is the same as letters, but allows reference to individual characters */ 1 27 1 28 dcl 1 letters_split (0:n_units) based (addr (digrams$letters)), 1 29 2 first char (1), 1 30 2 second char (1), 1 31 2 pad char (2); 1 32 1 33 /* This array has rules for each unit */ 1 34 1 35 dcl 1 rules (n_units) aligned based (addr (digrams$rules)), 1 36 2 no_final_split bit (1), /* can't be the only vowel in last syllable */ 1 37 2 not_begin_syllable bit (1), /* can't begin a syllable */ 1 38 2 vowel bit (1), /* this is a vowel */ 1 39 2 alternate_vowel bit (1); /* this is an alternate vowel, (i.e., "y") */ 1 40 1 41 dcl n_units defined digrams$n_units fixed bin; 1 42 1 43 /* ******** end include file digram_structure.incl.pl1 *********** */ 52 53 dcl pp ptr; 54 dcl (j, k) fixed; 55 dcl max fixed; 56 dcl length fixed bin; 57 dcl ioa_$nnl entry options (variable); 58 dcl argno fixed bin; 59 dcl (diff, last, ncolumns init (0), remainder, middle, first) fixed; 60 dcl ioa_ entry options (variable); 61 62 who = "digram_table_compiler"; 63 goto start1; 64 65 dtc: entry; 66 who = "dtc"; 67 68 start1: 69 70 compile = "1"b; /* set switch to compile */ 71 call cu_$arg_ptr (1, pp, length, code); 72 argno = 1; 73 if code ^= 0 then goto argerr; 74 call expand_path_ (pp, length, addr (dirname), addr (ename), code); 75 if code ^= 0 then goto argerr; 76 ename_length = index (ename, " "); 77 if ename_length = 0 78 then ename_length = 32; 79 else ename_length = ename_length - 1; 80 if ename_length >= 4 81 then 82 if substr (ename, ename_length - 3, 4) = ".dtc" 83 then ename_length = ename_length - 4; 84 85 argno = 2; 86 call cu_$arg_ptr (2, pp, length, code); /* get option */ 87 if code ^= 0 88 then list = "0"b; /* no listing desired */ 89 else 90 if arg = "-ls" | arg = "-list" 91 then do; 92 list = "1"b; 93 argno = 3; 94 end; 95 else do; 96 code = error_table_$badopt; 97 goto argerr; 98 end; 99 goto get_ncolumns; 100 101 pdt: entry; 102 who = "pdt"; 103 goto start2; 104 105 print_digram_table: entry; 106 who = "print_digram_table"; 107 108 start2: 109 110 list = "1"b; 111 argno = 1; 112 compile = "0"b; 113 114 get_ncolumns: 115 call cu_$arg_ptr (argno, pp, length, code); 116 if code ^= 0 117 then do; 118 ncolumns = get_line_length_$switch (null, code); 119 if code ^= 0 then do; 120 code = 0; 121 ncolumns = 132; 122 end; 123 ncolumns = divide (ncolumns, 14, 17, 0); 124 end; 125 else do; 126 ncolumns = cv_dec_check_ (arg, codex); 127 if codex ^= 0 128 then do; 129 code = error_table_$badopt; 130 goto argerr; 131 end; 132 end; 133 134 135 136 if ^compile then goto dont_compile; 137 138 /* now initiate the source segment */ 139 140 call hcs_$initiate_count ((dirname), substr (ename, 1, ename_length) || 141 ".dtc", "", bc, 0, segptr, code); 142 if segptr = null 143 then do; 144 call com_err_ (code, who, "^a>^a.dtc", dirname, substr (ename, 1, ename_length)); 145 return; 146 end; 147 148 /* compile the segment */ 149 150 call hcs_$terminate_name ("digrams", code); /* terminate previous copies */ 151 if read_table_ (segptr, bc) /* any error? */ 152 then 153 do; 154 call com_err_ (0, who, "Error in source segment."); 155 return; 156 end; 157 158 159 160 /* terminate the source now */ 161 162 163 164 call hcs_$terminate_noname (segptr, code); 165 if ^list then return; /* if no listing wanted, leave now */ 166 167 168 169 dont_compile: 170 if compile then call ioa_ ("^/^/^/^/"); 171 nrows = (n_units-1)/ncolumns + 1; /* This is the first reference to the digrams segment */ 172 if ncolumns ^= 0 173 then 174 do; 175 do i = 1 to nrows; 176 do j = i by nrows while (j <= n_units); 177 call ioa_$nnl (" ^2d ^2a ^1b^1b^1b^1b", j, letters (j), rules (j).not_begin_syllable, 178 rules (j).no_final_split, rules (j).vowel, rules (j).alternate_vowel); 179 end; 180 call ioa_ (""); 181 end; 182 call ioa_ (""); 183 do start = 1, ncolumns* (59-nrows) + 1 by ncolumns*60 184 while (startdumps>old>recomp>digram_table_compiler.pl1 52 1 06/16/75 2003.4 digram_structure.incl.pl1 >ldd>include>digram_structure.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. alternate_vowel 3 based bit(1) array level 2 dcl 1-35 set ref 177* arg based char unaligned dcl 45 set ref 89 89 126* 238* argno 000212 automatic fixed bin(17,0) dcl 58 set ref 72* 85* 93* 111* 114* 237* bc 000202 automatic fixed bin(24,0) dcl 50 set ref 140* 151* begin based bit(1) array level 2 packed unaligned dcl 1-11 set ref 199* break 0(04) based bit(1) array level 2 packed unaligned dcl 1-11 set ref 199* c parameter fixed bin(17,0) dcl 226 ref 225 227 227 229 code 000103 automatic fixed bin(35,0) dcl 28 set ref 71* 73 74* 75 86* 87 96* 114* 116 118* 119 120* 129* 140* 144* 150* 164* 232 232* 238* codex 000104 automatic fixed bin(17,0) dcl 29 set ref 126* 127 com_err_ 000020 constant entry external dcl 33 ref 144 154 232 238 compile 000105 automatic bit(1) unaligned dcl 37 set ref 68* 112* 136 169 cu_$arg_ptr 000012 constant entry external dcl 27 ref 71 86 114 237 cv_dec_check_ 000014 constant entry external dcl 30 ref 126 diff 000213 automatic fixed bin(17,0) dcl 59 set ref 188* 189 192 193 195 196 196 196 digrams based structure array level 1 packed unaligned dcl 1-11 digrams$digrams 000040 external static fixed bin(17,0) dcl 1-4 set ref 199 199 199 199 199 213 217 219 digrams$letters 000044 external static fixed bin(17,0) dcl 1-6 set ref 177 199 227 227 229 digrams$n_units 000042 external static fixed bin(17,0) dcl 1-5 ref 171 171 176 176 185 185 185 185 187 187 187 187 197 197 198 198 199 199 199 199 199 199 199 199 199 199 199 199 199 199 199 199 199 199 199 199 208 208 213 213 213 213 217 217 217 217 219 219 219 219 digrams$rules 000046 external static fixed bin(17,0) dcl 1-7 set ref 177 177 177 177 dirname 000117 automatic char(168) dcl 41 set ref 74 74 140 144* ename 000171 automatic char(32) dcl 42 set ref 74 74 76 80 140 144 144 ename_length 000201 automatic fixed bin(17,0) dcl 43 set ref 76* 77 77* 79* 79 80 80 80* 80 140 144 144 end 0(02) based bit(1) array level 2 packed unaligned dcl 1-11 set ref 199* error_table_$badopt 000024 external static fixed bin(35,0) dcl 34 ref 96 129 error_table_$noarg 000022 external static fixed bin(35,0) dcl 34 ref 232 expand_path_ 000036 constant entry external dcl 49 ref 74 first 000220 automatic fixed bin(17,0) dcl 59 in procedure "digram_table_compiler" set ref 191* 192 193 193 196* 205 205 207 207 first based char(1) array level 2 in structure "letters_split" packed unaligned dcl 1-28 in procedure "digram_table_compiler" ref 227 get_line_length_$switch 000026 constant entry external dcl 35 ref 118 hcs_$initiate_count 000032 constant entry external dcl 46 ref 140 hcs_$terminate_name 000016 constant entry external dcl 32 ref 150 hcs_$terminate_noname 000034 constant entry external dcl 48 ref 164 i 000203 automatic fixed bin(17,0) dcl 51 set ref 175* 176* 196* 196* 197 198* illegal_pair 0(07) based bit(1) array level 2 packed unaligned dcl 1-11 ref 217 ioa_ 000052 constant entry external dcl 60 ref 169 180 182 203 ioa_$nnl 000050 constant entry external dcl 57 ref 177 199 205 207 j 000206 automatic fixed bin(17,0) dcl 54 set ref 176* 176* 177* 177 177 177 177 177* 197* 198 199* 199 199 199 199 199 213 217 219 k 000207 automatic fixed bin(17,0) dcl 54 set ref 198* 199 199 199 199 199 199 213 217 219 last 000214 automatic fixed bin(17,0) dcl 59 set ref 190* 191 193 length 000211 automatic fixed bin(17,0) dcl 56 set ref 71* 74* 86* 89 89 114* 126 126 237* 238 238 letters based char(2) array dcl 1-24 set ref 177* 199 229 letters_split based structure array level 1 packed unaligned dcl 1-28 list 000116 automatic bit(1) unaligned dcl 39 set ref 87* 92* 108* 165 max 000210 automatic fixed bin(17,0) dcl 55 set ref 193* 195* 196 196 middle 000217 automatic fixed bin(17,0) dcl 59 set ref 192* 193 193 195 196 196 n_units defined fixed bin(17,0) dcl 1-41 ref 171 176 185 185 187 187 197 198 199 199 199 199 199 199 199 199 199 199 208 213 213 217 217 219 219 ncolumns 000215 automatic fixed bin(17,0) initial dcl 59 set ref 59* 118* 121* 123* 123 126* 171 172 183 183 185 187 188 189 190 190 195 no_final_split based bit(1) array level 2 dcl 1-35 set ref 177* not_begin 0(01) based bit(1) array level 2 packed unaligned dcl 1-11 set ref 199* not_begin_syllable 1 based bit(1) array level 2 dcl 1-35 set ref 177* not_end 0(03) based bit(1) array level 2 packed unaligned dcl 1-11 set ref 199* nrows 000102 automatic fixed bin(17,0) dcl 26 set ref 171* 175 176 183 185 205 205 null builtin function dcl 44 ref 118 118 142 pp 000204 automatic pointer dcl 53 set ref 71* 74* 86* 89 89 114* 126 237* 238 prefix 0(05) based bit(1) array level 2 packed unaligned dcl 1-11 ref 213 read_table_ 000030 constant entry external dcl 36 ref 151 remainder 000216 automatic fixed bin(17,0) dcl 59 set ref 189* 192 195 rules based structure array level 1 dcl 1-35 second 0(09) based char(1) array level 2 packed unaligned dcl 1-28 ref 227 segptr 000010 internal static pointer initial dcl 40 set ref 140* 142 151* 164* size 000101 automatic fixed bin(17,0) dcl 25 set ref 185* 187* 188 189 190 start 000100 automatic fixed bin(17,0) dcl 25 set ref 183* 185 187 190 191 205 207 207* 208* suffix 0(06) based bit(1) array level 2 packed unaligned dcl 1-11 ref 219 vowel 2 based bit(1) array level 2 dcl 1-35 set ref 177* who 000106 automatic varying char(25) dcl 38 set ref 62* 66* 102* 106* 144* 154* 232* 238* NAME DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. hcs_$truncate_seg 000000 constant entry external dcl 31 NAMES DECLARED BY EXPLICIT CONTEXT. argerr 001577 constant label dcl 232 ref 73 75 97 130 chara 001714 constant entry internal dcl 216 ref 199 charac 001661 constant entry internal dcl 212 ref 199 characc 001762 constant entry internal dcl 225 ref 199 digram_table_compiler 000104 constant entry external dcl 24 dont_compile 000700 constant label dcl 169 ref 136 dtc 000121 constant entry external dcl 65 get_ncolumns 000342 constant label dcl 114 ref 99 pdt 000306 constant entry external dcl 101 print_digram_table 000322 constant entry external dcl 105 start1 000133 constant label dcl 68 ref 63 start2 000335 constant label dcl 108 ref 103 NAMES DECLARED BY CONTEXT OR IMPLICATION. addr builtin function ref 74 74 74 74 177 177 177 177 177 199 199 199 199 199 199 213 217 219 227 227 229 copy builtin function ref 205 205 207 207 divide builtin function ref 123 index builtin function ref 76 min builtin function ref 185 187 substr builtin function ref 80 140 144 144 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2266 2342 2042 2276 Length 2602 2042 54 224 224 2 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME digram_table_compiler 306 external procedure is an external procedure. charac internal procedure shares stack frame of external procedure digram_table_compiler. chara internal procedure shares stack frame of external procedure digram_table_compiler. characc internal procedure shares stack frame of external procedure digram_table_compiler. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 segptr digram_table_compiler STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME digram_table_compiler 000100 start digram_table_compiler 000101 size digram_table_compiler 000102 nrows digram_table_compiler 000103 code digram_table_compiler 000104 codex digram_table_compiler 000105 compile digram_table_compiler 000106 who digram_table_compiler 000116 list digram_table_compiler 000117 dirname digram_table_compiler 000171 ename digram_table_compiler 000201 ename_length digram_table_compiler 000202 bc digram_table_compiler 000203 i digram_table_compiler 000204 pp digram_table_compiler 000206 j digram_table_compiler 000207 k digram_table_compiler 000210 max digram_table_compiler 000211 length digram_table_compiler 000212 argno digram_table_compiler 000213 diff digram_table_compiler 000214 last digram_table_compiler 000215 ncolumns digram_table_compiler 000216 remainder digram_table_compiler 000217 middle digram_table_compiler 000220 first digram_table_compiler THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out return shorten_stack ext_entry trunc_fx2 repeat set_cs_eis divide_fx1 THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_ptr cv_dec_check_ expand_path_ get_line_length_$switch hcs_$initiate_count hcs_$terminate_name hcs_$terminate_noname ioa_ ioa_$nnl read_table_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. digrams$digrams digrams$letters digrams$n_units digrams$rules error_table_$badopt error_table_$noarg LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 59 000100 24 000103 62 000112 63 000117 65 000120 66 000127 68 000133 71 000135 72 000154 73 000156 74 000160 75 000203 76 000205 77 000216 79 000222 80 000224 85 000235 86 000237 87 000255 89 000261 92 000273 93 000275 94 000277 96 000300 97 000303 99 000304 101 000305 102 000314 103 000320 105 000321 106 000330 108 000335 111 000337 112 000341 114 000342 116 000357 118 000361 119 000376 120 000400 121 000401 123 000403 124 000406 126 000407 127 000435 129 000437 130 000442 136 000443 140 000445 142 000527 144 000535 145 000601 150 000603 151 000621 154 000637 155 000664 164 000665 165 000676 169 000700 171 000715 172 000732 175 000734 176 000743 177 000753 179 001031 180 001034 181 001044 182 001046 183 001057 185 001063 187 001104 188 001127 189 001135 190 001145 191 001165 192 001173 193 001201 195 001212 196 001220 197 001246 198 001263 199 001270 202 001425 203 001460 204 001471 205 001473 207 001524 208 001551 210 001576 232 001577 237 001617 238 001634 241 001660 212 001661 213 001663 213 001707 216 001714 217 001716 219 001744 222 001755 225 001762 227 001764 229 002013 ----------------------------------------------------------- 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