COMPILATION LISTING OF SEGMENT hyphenate_ 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.2 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* *********************************************************** */ 6 /* This procedure tries to hyphenate a word supplied by the caller. 7* 8* dcl hyphenate_ entry(char(*), (*) bit(1) aligned, fixed bin); 9* 10* call hyphenate_ (word, returned_hyphens, code); 11* 12* 1) word A word consisting of ASCII letters to be hyphenated. 13* The first character may be uppercase or lowercase; the other 14* characters may be lowercase only. 15* 16* 3) returned_hyphens 17* A one bit in this array means that the corresponding 18* character in word is to have a hyphen after it. 19* 20* 3) code Status code: 0 word has been successfully hyphenated. 21* -1 word contains illegal characters. 22* -2 word was more than 20 or less than 3 characters. 23* Any positive value of code means the word couldn't 24* be hyphenated. In this case code is the position of the 25* first character that was not accepted. 26* 27* The word is hyphenated by using random_word_ and whatever existing digram 28* table is in use by random_word_ to determine the syllabification and pronounceability 29* of the word supplied. The standard random_unit_ routine is not used, 30* except that random_unit_$probabilities is called by hyphenate_$probability. 31**/ 32 33 hyphenate_: procedure (word, returned_hyphens, code); 34 dcl word char (*); 35 dcl code fixed bin; 36 dcl debug static bit (1) init ("0"b); 37 dcl ioa_$nnl entry options (variable); 38 dcl word_array (20) fixed bin static; /* word spread out into units */ 39 dcl hyphenated_word (0:20) bit (1) aligned; /* returned hyphens from random_word_ */ 40 dcl returned_hyphens (*) bit (1) aligned; /* hyphens to be returned to caller */ 41 dcl split_point fixed bin; /* set on internal call at 2-letter unit to be split */ 42 dcl word_length_in_chars fixed bin static; /* length of word in characters */ 43 dcl word_length fixed bin static; /* length of word_array in units */ 44 dcl i fixed bin; 45 dcl j fixed bin; 46 dcl chars char (2); 47 dcl char char (1); 48 dcl word_index fixed bin static; /* index into word_array */ 49 dcl returned_word (0:20) fixed bin; /* word returned by random_word_ */ 50 dcl vowel_flag bit (1); /* 1 when random_vowel is called */ 51 dcl last_good_unit static fixed bin; /* word_index of last good unit */ 52 dcl new_unit fixed bin; 53 dcl random_word_ entry ((0:*)fixed bin, (0:*) bit (1) aligned, 54 fixed bin, fixed bin, entry, entry); 55 dcl random_unit_$probabilities entry ((*) float bin, (*) float bin); 56 dcl probability float bin; /* value of p returned to user */ 57 dcl calculate bit (1) static; /* says we're calculating the probability of a word */ 58 dcl p float bin static; /* accumulated product of probability for the word */ 59 dcl total_p_this_unit float bin; /* total sum of probabilities of units that could be accepted in this position */ 60 dcl returned_length fixed bin; 61 62 /* probabilities of generating each unit at random */ 63 /* obtained from a call to random_unit_$probabilities */ 64 65 dcl (unit_probabilities based (u_p_ptr), vowel_probabilities based (v_p_ptr)) dim (n_units) float bin; 66 dcl (u_p_ptr, v_p_ptr) static ptr init (null ()); 67 dcl first_call static bit (1) init ("1"b); 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 *********** */ 68 69 split_point = 0; 70 calculate = "0"b; /* we aren't calculating probabilities, just hyphenating */ 71 goto continue; 72 /* */ 73 /* This entry is the same as hyphenate_, except that an additional value returned 74* is the probability that the word would have been generated by random_word_ 75* using the current digram table and random_unit_ subroutine. On the first call 76* to this entry, random_unit_$probabilities is called to obtain the probabilities 77* of all units. If these change within a process, hyphenate_$reset must be called 78* before hyphenate_$probability is called again. 79* */ 80 81 hyphenate_$probability: entry (word, returned_hyphens, code, probability); 82 split_point = 0; 83 p = 1; 84 calculate = "1"b; 85 if first_call then do; 86 allocate unit_probabilities, vowel_probabilities; 87 call random_unit_$probabilities (unit_probabilities, vowel_probabilities); 88 first_call = "0"b; 89 end; 90 goto continue; 91 92 /* This entry is used to reset the probability arrays in case a new 93* version of random_unit_ (with different probabilities) is used. 94* Note that if a new version of digrams is also supplied, the old 95* digrams must be terminated. */ 96 97 hyphenate_$reset: entry; first_call = "1"b; 98 if v_p_ptr ^= null () then free unit_probabilities, vowel_probabilities; 99 return; 100 101 /* This entry point is called internally as a recursive call to hyphenate_. 102* It is referenced when random_word_ did not accept the word because a 2-letter unit 103* was illegal. In this case we call this entry and tell hyphenate_ to split the 2-letter 104* unit into 2 separate units. The splitpoint argument specifies which one to do this with. */ 105 106 hyphenate_$split: entry (word, returned_hyphens, code, splitpoint); 107 dcl splitpoint fixed bin; 108 split_point = splitpoint; 109 110 continue: 111 word_length_in_chars = length (word); 112 if word_length_in_chars > 20 | word_length_in_chars < 3 113 then 114 do; 115 code = -2; 116 if calculate then probability = 0; 117 return; 118 end; 119 120 /* Now that we have the word we want to hyphenate, we try to divide it up ino units as defined 121* in the digram table. We start with the first two letters in the word, and see if they are equal to any 122* of the 2-letter units. If they are, we store the index of that unit in the word_array, and increment 123* our word_index by 2. If they are not, we see if the first letter is equal to any of the 1-letter units. 124* If it is, we store that unit and increment the word_index by 1. If still not found, the character is 125* not defined as a unit in the digram table and the word is illegal. Of course, the word may still not be 126* "legal" according to random_word_ rules of pronunciation and the digram table, but we'll find that out 127* later. 128**/ 129 130 word_index = 1; 131 do i = 1 to word_length_in_chars; 132 chars = substr (word, i, min (2, word_length_in_chars - i + 1)); 133 if i = 1 then substr (chars, 1, 1) = translate (substr (chars, 1, 1), "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); 134 j = 1; 135 do j = 1 to n_units while (chars ^= letters (j)); /* look for 2-letter unit match */ 136 end; 137 if j <= n_units & word_index ^= split_point 138 then /* match found */ 139 do; 140 word_array (word_index) = j; /* store 2-letter unit index */ 141 word_index = word_index + 1; 142 i = i + 1; /* skip over next unit */ 143 end; 144 else 145 do; /* two-letter unit not found, search for 1-letter unit */ 146 char = substr (chars, 1, 1); 147 if i = 1 148 then char = translate (char, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); 149 char = substr (char, 1, 1); 150 j = 1; 151 do j = 1 to n_units while (char ^= letters (j)); 152 end; 153 if j <= n_units 154 then /* match found */ 155 do; 156 word_array (word_index) = j; /* store 1-letter unit index */ 157 word_index = word_index + 1; 158 end; 159 else 160 do; /* not found, unit is illegal */ 161 code = -1; 162 if calculate then probability = 0; 163 return; 164 end; 165 end; 166 end; 167 word_length = word_index - 1; 168 word_index = 0; 169 170 /* Now call random_word_, trying to get the word hyphenated. Special versions of random_unit and 171* random_vowel are supplied that return units of the word we are trying to hyphenate rather than 172* random units. 173**/ 174 175 call random_word_ (returned_word, hyphenated_word, word_length_in_chars, returned_length, random_unit, random_vowel); 176 goto accepted; 177 178 /* If random_unit ever finds that random_word_ did not accept a unit from the word to be hyphenated, 179* a nonlocal goto directly to this label (which pops random_word_ off the stack) is made, and we 180* abort the whole operation. If the last unit tried (i.e. the one not accepted) was a 2-letter unit, 181* we might be able to make the word legal by splitting that unit up into two 1-letter units and 182* starting all over. Unfortunately, this is a lot of code and complication for a relatively rare case. 183**/ 184 185 not_accepted: word_index = word_index - 1; /* index of last unit accepted */ 186 p = 0; /* zero probability if word was not accepted */ 187 188 accepted: if debug then if calculate then call ioa_$nnl ("^/"); 189 j = 1; 190 returned_hyphens = "0"b; 191 do i = 1 to word_length; 192 if i > word_index & word_index < word_length /* we never got done with the word */ 193 then 194 do; 195 code = j; /* word was not accepted */ 196 if letters_split (word_array (i)).second ^= " " /* was it not accepted because of an illegal */ 197 & split_point = 0 198 then do; /* 2-letter unit? */ 199 p = 1; 200 call hyphenate_$split (word, returned_hyphens, code, i); /* try again with split pair */ 201 end; /* Note: in even rarer cases, the unit that might be split to make this word legal is not the 202* unit that was rejected, but a previous unit. It's too hard to deal with this case, so we'll refuse the word, 203* even though it might be legal. As an example, using the standard digram table, "preeg-hu-o" is a legal word. 204* However, our first attempt was to supply p-r-e-e-gh-u-o units. Random_word_ rejects the 205* "u" because it may not follow a "gh" unit in this context. Since "u" is not a 2-letter 206* unit, we can't try to split it up, so the word is thrown out. However, p-r-e-e-g-h-u-o 207* would have been acceptable to random_word_. This is the only case where a 208* word that could have been produced by random_word_ will be rejected by hyphenate_. */ 209 if calculate then probability = p; 210 return; /* otherwise, return */ 211 end; 212 213 /* set returned_hyphens bits corresponding to character in word. Note that 214* hyphens returned from random_word_ (hyphenated_word array) point to units, 215* not characters. */ 216 217 if letters_split (word_array (i)).second ^= " " 218 then j = j + 2; 219 else j = j + 1; 220 returned_hyphens (j-1) = hyphenated_word (i); 221 end; 222 code = 0; 223 if calculate then probability = p; 224 return; 225 /* */ 226 /* The internal procedures random_unit and random_vowel keep track of the acceptance or rejectance of 227* units they are supplying to random_word_. Most of the code in the first part is to calculate probabilities 228* when hyphenate_$probability is called. 229* */ 230 random_vowel: proc (returned_unit); 231 dcl returned_unit fixed bin; 232 vowel_flag = "1"b; 233 goto generate; 234 235 random_unit: entry (returned_unit); 236 vowel_flag = "0"b; 237 238 generate: 239 240 /* at this point, we either calculate probabilities or just go for another unit */ 241 242 /* If probabilities are being calculated, we proceed as follows: 243* In every position of the word, we send off to random_word_ all possible units except the one 244* that is actually in the word. We send these as negative numbers so that random_word_ will not actually use 245* them, but will tell us whether they are legal. Since we know the probabiliies of all units, the 246* total of the probabilities of the acceptable units can be calculated and normalized to 1 in order 247* to determine the probability of the unit we are actually trying. For example, if "e" is the only legal 248* unit in a given position of the word, then its probability of appearing in that position is 1, since 249* random_word_ will not accept anything else. 250* 251* When all units but the actual unit have been tried, we send off the actual unit with a positive sign. 252* It should be accepted by random_word_ if the word is legal, and the ratio of its probability 253* to the total probability of the legal units is the probability of the unit being in this word position. 254* This multiplied by the product of these probabilities of the previous units gives us a "running product" 255* that will eventually yield the probability of the whole word. 256**/ 257 258 if calculate then do; /* we are calculating */ 259 if debug then 260 if returned_unit < 0 then 261 if returned_unit ^= -new_unit then 262 call ioa_$nnl ("^a,", letters (-returned_unit)); 263 if returned_unit = 0 & word_index = 0 then do; /* this is the first unit of the word */ 264 total_p_this_unit = 0; /* initialize probabilities */ 265 word_index = 1; 266 end; 267 else if returned_unit = 0 & word_index ^= 0 then goto not_accepted; /* it tried to start a word all over on us */ 268 new_unit = word_array (word_index); /* get the current unit from the word */ 269 if returned_unit > 0 then do; /* was the last unit accepted */ 270 if returned_unit = new_unit then do; /* yes, was it the one from this word position? */ 271 total_p_this_unit = 0; /* initialize for next word position */ 272 word_index = word_index + 1; 273 new_unit = word_array (word_index); /* get next unit from word, which now becomes current unit */ 274 returned_unit = 0; 275 end; 276 else do; /* unit just accepted was not the one at this word position */ 277 if vowel_flag /* add its probability to total for this position and keep trying more units */ 278 then total_p_this_unit = total_p_this_unit + vowel_probabilities (returned_unit); 279 else total_p_this_unit = total_p_this_unit + unit_probabilities (returned_unit); 280 end; 281 end; 282 if -returned_unit = new_unit then goto not_accepted; /* current unit was not accepted */ 283 skip_unit: 284 returned_unit = abs (returned_unit) + 1; /* try next unit in unit table */ 285 if returned_unit = new_unit then returned_unit = returned_unit + 1; /* but skip the current one */ 286 if returned_unit > n_units 287 then do; /* we've tried all the other units, try the current one now */ 288 /* If we are trying the current unit for real, we can calculate the probability of 289* of this unit appearing at this position, assuming it will be accepted. 290* Ratio of probability of this unit to total 291* probability for the units accepted at this position gives the probability of this unit 292* having legally been generated at this position */ 293 if vowel_flag 294 then p = p * vowel_probabilities (new_unit)/ (vowel_probabilities (new_unit) + total_p_this_unit); 295 else p = p * unit_probabilities (new_unit)/ (unit_probabilities (new_unit) + total_p_this_unit); 296 returned_unit = new_unit; 297 end; 298 else returned_unit = -returned_unit; /* if not the current one, make it negative so it won't be used */ 299 if vowel_flag /* if vowel was wanted and this isn't one, it can't be used */ 300 then if ^rules.vowel (abs (returned_unit)) 301 then if ^rules.alternate_vowel (abs (returned_unit)) 302 then 303 if returned_unit < 0 /* if we didn't care to keep it anyway, just ignore */ 304 then goto skip_unit; 305 else goto not_accepted; /* if we wanted to keep it, the word is illegal */ 306 if debug then 307 if returned_unit > 0 then call ioa_$nnl ("^a^a_; ", letters (returned_unit), ""); 308 end; 309 310 /* This section of code just supplies the next unit of the word */ 311 312 else do; 313 if returned_unit < 0 | (returned_unit = 0 & word_index ^= 0) 314 then goto not_accepted; /* if last unit was not accepted */ 315 word_index = word_index + 1; 316 new_unit = word_array (word_index); /* get next unit from word */ 317 if vowel_flag /* if random_word_ wanted a vowel, and this next unit is not one, */ 318 then if ^rules.vowel (new_unit) /* then we have to give up */ 319 then if ^rules.alternate_vowel (new_unit) /* I wouldn't dare give random_word_ a non-vowel when it expects a vowel */ 320 then goto not_accepted; 321 returned_unit = new_unit; 322 return; 323 end; 324 end; 325 326 debug_on: entry; debug = "1"b; return; 327 328 debug_off: entry; debug = "0"b; return; 329 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/15/82 1530.1 hyphenate_.pl1 >dumps>old>recomp>hyphenate_.pl1 68 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 ref 299 317 calculate 000040 internal static bit(1) unaligned dcl 57 set ref 70* 84* 116 162 188 209 223 238 char 000131 automatic char(1) unaligned dcl 47 set ref 146* 147* 147 149* 149 151 chars 000130 automatic char(2) unaligned dcl 46 set ref 132* 133* 133 135 146 code parameter fixed bin(17,0) dcl 35 set ref 33 81 106 115* 161* 195* 200* 222* debug 000010 internal static bit(1) initial unaligned dcl 36 set ref 188 259 306 326* 328* digrams$letters 000060 external static fixed bin(17,0) dcl 1-6 set ref 135 151 196 217 259 306 digrams$n_units 000056 external static fixed bin(17,0) dcl 1-5 ref 86 86 86 86 87 87 87 87 98 98 98 98 135 135 137 137 151 151 153 153 286 286 digrams$rules 000062 external static fixed bin(17,0) dcl 1-7 set ref 299 299 317 317 first_call 000046 internal static bit(1) initial unaligned dcl 67 set ref 85 88* 97* hyphenated_word 000100 automatic bit(1) array dcl 39 set ref 175* 220 i 000126 automatic fixed bin(17,0) dcl 44 set ref 131* 132 132 133 142* 142 147* 191* 192 196 200* 217 220* ioa_$nnl 000050 constant entry external dcl 37 ref 188 259 306 j 000127 automatic fixed bin(17,0) dcl 45 set ref 134* 135* 135* 137 140 150* 151* 151* 153 156 189* 195 217* 217 219* 219 220 letters based char(2) array dcl 1-24 set ref 135 151 259* 306* letters_split based structure array level 1 packed unaligned dcl 1-28 n_units defined fixed bin(17,0) dcl 1-41 ref 86 86 87 87 98 98 135 137 151 153 286 new_unit 000160 automatic fixed bin(17,0) dcl 52 set ref 259 268* 270 273* 282 285 293 293 295 295 296 316* 317 317 321 p 000041 internal static float bin(27) dcl 58 set ref 83* 186* 199* 209 223 293* 293 295* 295 probability parameter float bin(27) dcl 56 set ref 81 116* 162* 209* 223* random_unit_$probabilities 000054 constant entry external dcl 55 ref 87 random_word_ 000052 constant entry external dcl 53 ref 175 returned_hyphens parameter bit(1) array dcl 40 set ref 33 81 106 190* 200* 220* returned_length 000162 automatic fixed bin(17,0) dcl 60 set ref 175* returned_unit parameter fixed bin(17,0) dcl 231 set ref 230 235 259 259 259 263 267 269 270 274* 277 279 282 283* 283 285 285* 285 286 296* 298* 298 299 299 299 306 306 313 313 321* returned_word 000132 automatic fixed bin(17,0) array dcl 49 set ref 175* rules based structure array level 1 dcl 1-35 second 0(09) based char(1) array level 2 packed unaligned dcl 1-28 ref 196 217 split_point 000125 automatic fixed bin(17,0) dcl 41 set ref 69* 82* 108* 137 196 splitpoint parameter fixed bin(17,0) dcl 107 ref 106 108 total_p_this_unit 000161 automatic float bin(27) dcl 59 set ref 264* 271* 277* 277 279* 279 293 295 u_p_ptr 000042 internal static pointer initial dcl 66 set ref 86* 87 98 279 295 295 unit_probabilities based float bin(27) array dcl 65 set ref 86 87* 98 279 295 295 v_p_ptr 000044 internal static pointer initial dcl 66 set ref 86* 87 98 98 277 293 293 vowel 2 based bit(1) array level 2 dcl 1-35 ref 299 317 vowel_flag 000157 automatic bit(1) unaligned dcl 50 set ref 232* 236* 277 293 299 317 vowel_probabilities based float bin(27) array dcl 65 set ref 86 87* 98 277 293 293 word parameter char unaligned dcl 34 set ref 33 81 106 110 132 200* word_array 000011 internal static fixed bin(17,0) array dcl 38 set ref 140* 156* 196 217 268 273 316 word_index 000037 internal static fixed bin(17,0) dcl 48 set ref 130* 137 140 141* 141 156 157* 157 167 168* 185* 185 192 192 263 265* 267 268 272* 272 273 313 315* 315 316 word_length 000036 internal static fixed bin(17,0) dcl 43 set ref 167* 191 192 word_length_in_chars 000035 internal static fixed bin(17,0) dcl 42 set ref 110* 112 112 131 132 175* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. digrams based structure array level 1 packed unaligned dcl 1-11 digrams$digrams external static fixed bin(17,0) dcl 1-4 last_good_unit internal static fixed bin(17,0) dcl 51 NAMES DECLARED BY EXPLICIT CONTEXT. accepted 000520 constant label dcl 188 ref 176 continue 000243 constant label dcl 110 ref 71 90 debug_off 000742 constant entry external dcl 328 debug_on 000730 constant entry external dcl 326 generate 000774 constant label dcl 238 ref 233 hyphenate_ 000054 constant entry external dcl 33 hyphenate_$probability 000077 constant entry external dcl 81 hyphenate_$reset 000176 constant entry external dcl 97 hyphenate_$split 000225 constant entry external dcl 106 ref 200 not_accepted 000513 constant label dcl 185 ref 267 282 305 313 317 random_unit 000765 constant entry internal dcl 235 ref 175 175 random_vowel 000753 constant entry internal dcl 230 ref 175 175 skip_unit 001123 constant label dcl 283 ref 299 NAMES DECLARED BY CONTEXT OR IMPLICATION. abs builtin function ref 283 299 299 addr builtin function ref 135 151 196 217 259 299 299 306 317 317 length builtin function ref 110 min builtin function ref 132 null builtin function ref 98 substr builtin function set ref 132 133* 133 146 149 translate builtin function ref 133 147 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1724 2010 1524 1734 Length 2254 1524 64 227 177 40 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME hyphenate_ 167 external procedure is an external procedure. random_vowel 92 internal procedure is assigned to an entry variable. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 debug hyphenate_ 000011 word_array hyphenate_ 000035 word_length_in_chars hyphenate_ 000036 word_length hyphenate_ 000037 word_index hyphenate_ 000040 calculate hyphenate_ 000041 p hyphenate_ 000042 u_p_ptr hyphenate_ 000044 v_p_ptr hyphenate_ 000046 first_call hyphenate_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME hyphenate_ 000100 hyphenated_word hyphenate_ 000125 split_point hyphenate_ 000126 i hyphenate_ 000127 j hyphenate_ 000130 chars hyphenate_ 000131 char hyphenate_ 000132 returned_word hyphenate_ 000157 vowel_flag hyphenate_ 000160 new_unit hyphenate_ 000161 total_p_this_unit hyphenate_ 000162 returned_length hyphenate_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_in_desc call_ext_out_desc return tra_ext ext_entry ext_entry_desc int_entry alloc_based_storage free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. ioa_$nnl random_unit_$probabilities random_word_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. digrams$letters digrams$n_units digrams$rules LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 33 000050 69 000067 70 000070 71 000071 81 000072 82 000112 83 000113 84 000116 85 000120 86 000122 87 000136 88 000172 90 000174 97 000175 97 000203 98 000206 99 000217 106 000220 108 000240 110 000243 112 000246 115 000252 116 000255 117 000261 130 000262 131 000264 132 000273 133 000311 134 000323 135 000325 136 000342 137 000344 140 000353 141 000356 142 000357 143 000360 146 000361 147 000364 149 000376 150 000401 151 000403 152 000421 153 000423 156 000427 157 000431 158 000432 161 000433 162 000436 163 000442 166 000443 167 000445 168 000451 175 000452 176 000512 185 000513 186 000516 188 000520 189 000537 190 000541 191 000573 192 000603 195 000611 196 000614 199 000626 200 000630 209 000654 210 000662 217 000663 219 000676 220 000677 221 000715 222 000717 223 000721 224 000726 326 000727 326 000735 326 000740 328 000741 328 000747 328 000751 230 000752 232 000760 233 000763 235 000764 236 000772 238 000774 259 000777 263 001030 264 001040 265 001043 266 001045 267 001046 268 001056 269 001063 270 001066 271 001070 272 001072 273 001073 274 001076 275 001077 277 001100 279 001110 282 001115 283 001123 285 001132 286 001136 293 001142 295 001156 296 001167 297 001171 298 001172 299 001174 305 001214 306 001217 308 001252 313 001253 315 001272 316 001274 317 001300 321 001315 322 001321 324 001322 ----------------------------------------------------------- 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