ASSEMBLY LISTING OF SEGMENT >dumps>old>recomp>convert_string_util_.alm ASSEMBLED ON: 11/15/82 1754.3 mst Mon OPTIONS USED: list ASSEMBLED BY: ALM Version 6.4 April 1981 ASSEMBLER CREATED: 11/03/82 1423.6 mst Wed  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  000000 10 name convert_string_util_ 11  12 " " " " " " " " " " " " " " " " " " " " " " " " "  13 "  14 " Utilities for the tty DIM.  15 "  16 " These routines perform certain scanning and editing  17 " functions for the tty DIM which are faster and  18 " easier to do in ALM.  19 "  20 " Coded 10/15/75 by Mike Grady  21 "  22 " " " " " " " " " " " " " " " " " " " " " " " " "  23  000000 24 segdef find_char  000111 25 segdef mvt 000124 26 segdef scm 000156 27 segdef illegal_char  000200 28 segdef tct 29  30 " symbols for storage in callers automatic storage  31  000000 32 equ stringp,0  000002 33 equ stringl,2  000003 34 equ tally,3  000004 35 equ tablep,4  000004 36 equ bit,4  000005 37 equ match,5  000006 38 equ indicator,6  000006 39 equ targetp,6  40  41 " some temporary storage also in callers stack frame  42  000010 43 equ w1,8  000011 44 equ w2,9  45  46 " 47 " " " " " " " " " " " " " " " " " " " " " " " " "  48 "  49 " find_char finds the next interesting char for the 50 " caller. It looks first for high bits (> 177) and  51 " then for double blanks, and finally for chars in  52 " a tct table.  53 "  54 " Input:  55 " stringp - pointer to string to scan  56 " stringl - length of string 57 " tablep - pointer to table to use for tct  58 "  59 " Output:  60 " tally - number of uninteresting chars  61 " indicator - number which indicates char found  62 " 3 for white space  63 " 7 for escape char  64 " value from tct otherwise 65 "  66 " " " " " " " " " " " " " " " " " " " " " " " " "  67  000000 68 find_char:  000000 aa 0 00002 3515 20 69 epp1 pr0|2,* get ptr to block of storage in  000001 aa 1 00000 3515 20 70 epp1 pr1|0,* callers stack  000002 aa 1 00000 3521 20 71 epp2 pr1|stringp,* load ptr to string  000003 aa 1 00002 2361 00 72 ldq pr1|stringl load string length 000004 aa 003720 1160 07 73 cmpq 2000,dl use min(stringl,2000) to be quick  000005 aa 000002 6040 04 74 tmi 2,ic all set  75  000006 aa 003720 2360 07 76 ldq 2000,dl  000007 aa 1 00003 4501 00 77 stz pr1|tally zero tally  78  000010 0a 000232 7020 00 79 tsx2 find_high_bits look for interesting bits  000011 0a 000014 7100 00 80 tra look_for_blanks none, continue 81  000012 aa 1 00010 2361 00 82 ldq pr1|w1 get result 000013 0a 000037 6000 00 83 tze have_high_bit first char - done  84  000014 85 look_for_blanks:  000014 aa 0 00003 1205 40 86 scd (pr,rl),(du) look for two blanks  000015 aa 200000 000006 87 desc9a pr2|0,ql  000016 aa 040 040 000 000 88 aci " "  000017 aa 1 00011 0001 00 89 arg pr1|w2 store result here  90  000020 0a 000025 6064 00 91 ttn no_double_blanks none in string  92  000021 aa 1 00011 2351 00 93 lda pr1|w2 get length up to double blanks 000022 aa 400000 2750 03 94 ora =o400000,du set high order bit as flag 000023 aa 1 00010 7551 00 95 sta pr1|w1 save as count  000024 aa 1 00011 2361 00 96 ldq pr1|w2 reduce stringl again  97  000025 98 no_double_blanks:  000025 aa 1 00004 3535 20 99 epp3 pr1|tablep,* load table pointer  000026 aa 0 00000 1645 40 100 tct (pr,rl) look into tct table for interesting chars 000027 aa 200000 000006 101 desc9a pr2|0,ql  000030 aa 3 00000 0001 00 102 arg pr3|0  000031 aa 1 00011 0001 00 103 arg pr1|w2 104  000032 0a 000044 6070 00 105 ttf tct_hit we got hit in tct, process  106  000033 aa 000003 2350 07 107 lda 3,dl get indicator value  000034 aa 1 00010 2341 00 108 szn pr1|w1 any high bits or double blanks?  000035 0a 000067 6000 00 109 tze return_full_string no, return the whole thing  000036 aa 000002 6040 04 110 tmi 2,ic double blanks found  000037 111 have_high_bit:  000037 aa 000007 2350 07 112 lda 7,dl get indicator for \nnn type  113  000040 aa 1 00006 7551 00 114 sta pr1|indicator return it to caller  000041 aa 1 00010 7201 00 115 lxl0 pr1|w1 get count 000042 aa 1 00003 4401 00 116 sxl0 pr1|tally 000043 0a 000071 7100 00 117 tra tct_done done 118  000044 119 tct_hit:  000044 aa 1 00011 2351 00 120 lda pr1|w2 get char value hit on  000045 aa 000033 7710 00 121 arl 27 shift down 000046 aa 1 00006 7551 00 122 sta pr1|indicator return to caller 000047 aa 000005 1150 07 123 cmpa 5,dl one of the special types?  000050 0a 000064 6050 00 124 tpl return_normal nope 125  000051 aa 1 00011 7201 00 126 lxl0 pr1|w2 get the count 000052 0a 000064 6000 00 127 tze return_normal hit on first char in string  000053 aa 000001 1200 03 128 sblx0 1,du decrement the count to point a prev char  000054 aa 0 00000 1065 10 129 cmpc (pr,x0),(),fill(0)  000055 aa 200000 000001 130 desc9a pr2|0,1 look for blank 000056 0a 000110 000001 131 desc9a blank,1 132  000057 0a 000064 6010 00 133 tnz return_normal not blank, all ok  134  000060 aa 000003 2350 07 135 lda 3,dl get blank indicator  000061 aa 1 00006 7551 00 136 sta pr1|indicator return to caller 000062 aa 1 00003 4401 00 137 sxl0 pr1|tally set tally to blank locn  000063 0a 000071 7100 00 138 tra tct_done done 139  000064 140 return_normal:  000064 aa 1 00011 7201 00 141 lxl0 pr1|w2 get the count from the tct  000065 aa 1 00003 4401 00 142 sxl0 pr1|tally return to caller  000066 0a 000071 7100 00 143 tra tct_done done 144  000067 145 return_full_string: 000067 aa 1 00003 7561 00 146 stq pr1|tally use whole thing 000070 aa 1 00006 4501 00 147 stz pr1|indicator set indicator  148  000071 149 tct_done:  000071 aa 1 00003 2361 00 150 ldq pr1|tally get tally  000072 aa 1 00006 2351 00 151 lda pr1|indicator load the indicator  000073 0a 000101 6000 00 152 tze tct_nbump zero, no bump  000074 aa 000003 1150 07 153 cmpa 3,dl is it blank?  000075 0a 000101 6000 00 154 tze tct_nbump yes, done  000076 aa 000007 1150 07 155 cmpa 7,dl is it escape char type? 000077 0a 000101 6000 00 156 tze tct_nbump yes, done  000100 aa 000001 0760 07 157 adq 1,dl bump input char count  000101 158 tct_nbump:  000101 aa 2 00000 5005 06 159 a9bd pr2|0,ql bump ptr  000102 aa 1 00000 2521 00 160 spri2 pr1|stringp  161  000103 aa 1 00010 7561 00 162 stq pr1|w1 store for subtract 000104 aa 1 00002 2351 00 163 lda pr1|stringl get stringl  000105 aa 1 00010 1751 00 164 sba pr1|w1 decrement  000106 aa 1 00002 7551 00 165 sta pr1|stringl reset stringl  166  000107 aa 7 00044 7101 20 167 short_return  168  000110 aa 040 000 000 000 169 blank: aci " "  170  171 " 172 " " " " " " " " " " " " " " " " " " " " " " " " "  173 "  174 " this routine does an mvt to translate chars.  175 "  176 " Input:  177 " stringp - points to input string  178 " stringl - length of string 179 " tablep - pointer to translate table  180 "  181 " Output:  182 " targetp - pointer to output string 183 "  184 " " " " " " " " " " " " " " " " " " " " " " " " "  000111 aa 0 00002 3515 20 185 mvt: epp1 pr0|2,* get ptr to arg ptr  000112 aa 1 00000 3515 20 186 epp1 pr1|0,* get ptr to callers block 000113 aa 1 00000 3521 20 187 epp2 pr1|stringp,* get ptr to the string  000114 aa 1 00002 2361 00 188 ldq pr1|stringl load length of string  000115 aa 1 00004 3535 20 189 epp3 pr1|tablep,* load ptr to mvt table  000116 aa 1 00006 3715 20 190 epp5 pr1|targetp,* get ptr to target string  191  000117 aa 0 00140 1605 40 192 mvt (pr,rl),(pr,rl),fill(0) do the mvt 000120 aa 200000 000006 193 desc9a pr2|0,ql  000121 aa 500000 000006 194 desc9a pr5|0,ql  000122 aa 3 00000 0001 00 195 arg pr3|0  196  000123 aa 7 00044 7101 20 197 short_return that was easy  198  199  200 " 201 " " " " " " " " " " " " " " " " " " " " " " " " "  202 "  203 " routine to scan for high bits in chars and return ptr to  204 " matched char. 205 "  206 " Input:  207 " stringp - points to string 208 " stringl - length  209 " bit - bit pattern looked for  210 "  211 " Output:  212 " tally - number of chars to char with bit  213 " match - "1"b if bit matched  214 "  215 " " " " " " " " " " " " " " " " " " " " " " " " "  216  000124 aa 0 00002 3515 20 217 scm: epp1 pr0|2,* get ptr to arg ptr  000125 aa 1 00000 3515 20 218 epp1 pr1|0,* get ptr to arg block 000126 aa 1 00000 3521 20 219 epp2 pr1|stringp,* get ptr to string  000127 aa 1 00002 2361 00 220 ldq pr1|stringl get string length  000130 aa 1 00005 4501 00 221 stz pr1|match indicate initial failure  222  000131 aa 1 00004 2351 00 223 lda pr1|bit look at the bit we want  000132 aa 400000 3750 03 224 ana =o400000,du use it to select scm  000133 0a 000141 6010 00 225 tnz scm4 on, we want highest bit  226  000134 aa 5 77100 1245 40 227 scm (pr,rl),(pr),mask(577) off, we must want bit 8 000135 aa 200000 000006 228 desc9a pr2|0,ql  000136 aa 1 00004 0001 00 229 arg pr1|bit  000137 aa 1 00003 0001 00 230 arg pr1|tally  000140 0a 000145 7100 00 231 tra scm_ck look at results  232  000141 aa 3 77100 1245 40 233 scm4: scm (pr,rl),(pr),mask(377) scan string for 9th bit  000142 aa 200000 000006 234 desc9a pr2|0,ql  000143 aa 1 00004 0001 00 235 arg pr1|bit  000144 aa 1 00003 0001 00 236 arg pr1|tally result  237  000145 0a 000150 6064 00 238 scm_ck: ttn scm_done no hits  239  000146 aa 400000 2350 03 240 lda =o400000,du get flag bit  000147 aa 1 00005 7551 00 241 sta pr1|match indicate success  000150 242 scm_done:  000150 aa 1 00003 1761 00 243 sbq pr1|tally reduce stringl  000151 aa 1 00002 7561 00 244 stq pr1|stringl return to caller  000152 aa 1 00003 2361 00 245 ldq pr1|tally fetch tally word  000153 aa 2 00000 5005 06 246 a9bd pr2|0,ql bump stringp  000154 aa 1 00000 2521 00 247 spri2 pr1|stringp store for caller 248  000155 aa 7 00044 7101 20 249 short_return  250  251 " 252 " " " " " " " " " " " " " " " " " " " " " " " " "  253 "  254 " routine to look for any char with bit 8 or 9 on.  255 "  256 " Input:  257 " stringp - points to string 258 " stringl - length  259 "  260 " Output:  261 " tally - number of chars up to bad one  262 " match - if bad one found "1"b  263 "  264 " " " " " " " " " " " " " " " " " " " " " " " " "  265  000156 266 illegal_char:  000156 aa 0 00002 3515 20 267 epp1 pr0|2,* get ptr to ptr to block  000157 aa 1 00000 3515 20 268 epp1 pr1|0,* get ptr to block 000160 aa 1 00000 3521 20 269 epp2 pr1|stringp,* get ptr to string  000161 aa 1 00002 2361 00 270 ldq pr1|stringl get length 271  000162 aa 1 00005 4501 00 272 stz pr1|match zero return bit 000163 aa 1 00003 7561 00 273 stq pr1|tally set max tally  274  000164 0a 000232 7020 00 275 tsx2 find_high_bits see if any high bits on  000165 0a 000172 7100 00 276 tra no_illegal_chars none, continue  277  000166 aa 1 00010 7201 00 278 lxl0 pr1|w1 get the result  000167 aa 1 00003 4401 00 279 sxl0 pr1|tally return 000170 aa 400000 2350 03 280 lda =o400000,du get match bit  000171 aa 1 00005 7551 00 281 sta pr1|match  000172 282 no_illegal_chars:  000172 aa 1 00003 1761 00 283 sbq pr1|tally reduce stringl  000173 aa 1 00002 7561 00 284 stq pr1|stringl return to caller  000174 aa 1 00003 2361 00 285 ldq pr1|tally fetch tally word  000175 aa 2 00000 5005 06 286 a9bd pr2|0,ql bump stringp  000176 aa 1 00000 2521 00 287 spri2 pr1|stringp store for caller 288  000177 aa 7 00044 7101 20 289 short_return  290 " 291 " " " " " " " " " " " " " " " " " " " " " " " " "  292 "  293 " routine to do input tct function, similar to  294 " find_char, but does only tct function 295 "  296 " " " " " " " " " " " " " " " " " " " " " " " " "  297  000200 aa 0 00002 3515 20 298 tct: epp1 pr0|2,* get ptr to arg ptr  000201 aa 1 00000 3515 20 299 epp1 pr1|0,* get ptr to arg block 000202 aa 1 00000 3521 20 300 epp2 pr1|stringp,* get ptr to string  000203 aa 1 00002 2361 00 301 ldq pr1|stringl get string length  000204 aa 1 00003 4501 00 302 stz pr1|tally zero the tally word 303  000205 aa 1 00004 3535 20 304 epp3 pr1|tablep,* get ptr to table 000206 aa 0 00000 1645 40 305 tct (pr,rl) do the tct  000207 aa 200000 000006 306 desc9a pr2|0,ql  000210 aa 3 00000 0001 00 307 arg pr3|0  000211 aa 1 00011 0001 00 308 arg pr1|w2 result goes here  309  000212 0a 000222 6064 00 310 ttn tct_nohit no good chars  311  000213 aa 1 00011 2351 00 312 lda pr1|w2 get the indicator value  000214 aa 000033 7710 00 313 arl 27 shift down 000215 aa 1 00006 7551 00 314 sta pr1|indicator  315  000216 aa 1 00011 7201 00 316 lxl0 pr1|w2 get the tally 000217 aa 1 00003 4401 00 317 sxl0 pr1|tally 000220 aa 1 00003 2361 00 318 ldq pr1|tally load tally for ptr update  000221 0a 000224 7100 00 319 tra tct_ptr_inc  320  000222 321 tct_nohit:  000222 aa 1 00003 7561 00 322 stq pr1|tally return whole string 000223 aa 1 00006 4501 00 323 stz pr1|indicator no indicator 324  000224 325 tct_ptr_inc:  000224 aa 2 00000 5005 06 326 a9bd pr2|0,ql  000225 aa 1 00000 2521 00 327 spri2 pr1|stringp return ptr  000226 aa 1 00002 2351 00 328 lda pr1|stringl get string length  000227 aa 1 00003 1751 00 329 sba pr1|tally reduce amount processed 000230 aa 1 00002 7551 00 330 sta pr1|stringl  000231 aa 7 00044 7101 20 331 short_return  332 " 333 " " " " " " " " " " " " " " " " " " " " " " " " "  334 "  335 " internal proc to find high bits.  336 " return+1 -> none found  337 " return+2 -> high bit found  338 "  339 " " " " " " " " " " " " " " " " " " " " " " " " "  340  000232 341 find_high_bits: 000232 aa 3 77003 1245 40 342 scm (pr,rl),(du),mask(377) look for chars with bit9 on 000233 aa 200000 000006 343 desc9a pr2|0,ql  000234 aa 400000 000000 344 vfd o9/400,27/0  000235 aa 1 00010 0001 00 345 arg pr1|w1 result here  346  000236 0a 000247 6064 00 347 ttn scm_other_bit not this one try bit8  348  000237 aa 1 00010 2341 00 349 szn pr1|w1 did we hit on first char?  000240 0a 000264 6000 00 350 tze found_first_bit yes, return  351  000241 aa 5 77003 1245 40 352 scm (pr,rl),(du),mask(577) look for bit8 on  000242 aa 200000 000006 353 desc9a pr2|0,ql  000243 aa 200000 000000 354 vfd o9/200,27/0  000244 aa 1 00011 0001 00 355 arg pr1|w2 save result  356  000245 0a 000260 6064 00 357 ttn check_which_bit not bit8, must be bit9 000246 0a 000254 7100 00 358 tra found_other_bit  359  000247 360 scm_other_bit:  000247 aa 5 77003 1245 40 361 scm (pr,rl),(du),mask(577) look for bit8 on  000250 aa 200000 000006 362 desc9a pr2|0,ql  000251 aa 200000 000000 363 vfd o9/200,27/0  000252 aa 1 00011 0001 00 364 arg pr1|w2 save result  365  000253 0a 000265 6064 00 366 ttn no_high_bits good, neither bit8 or 9 was on  367  000254 368 found_other_bit:  000254 aa 1 00011 2341 00 369 szn pr1|w2 did we hit first char? 000255 0a 000260 6010 00 370 tnz check_which_bit no, find which one 371  000256 aa 1 00010 4501 00 372 stz pr1|w1 indicate offset of zero in w1  000257 0a 000264 7100 00 373 tra found_first_bit return info  374  000260 375 check_which_bit:  000260 aa 1 00011 2351 00 376 lda pr1|w2 get second count  000261 aa 1 00010 1151 00 377 cmpa pr1|w1 compare with first  000262 aa 000002 6050 04 378 tpl 2,ic more, use w1 379  000263 aa 1 00010 7551 00 380 sta pr1|w1 less use w2 as length  000264 381 found_first_bit:  000264 aa 000001 7100 12 382 tra 1,2 return  383  000265 384 no_high_bits:  000265 aa 1 00010 4501 00 385 stz pr1|w1 reset the high bits indicator  000266 aa 000000 7100 12 386 tra 0,2 return  387  388 end  NO LITERALS  NAME DEFINITIONS FOR ENTRY POINTS AND SEGDEFS 000270 5a 000003 000000 000271 5a 000054 600000 000272 aa 000000 000000 000273 55 000014 000002 000274 5a 000002 400003 000275 55 000006 000014 000276 aa 024 143 157 156 000277 aa 166 145 162 164 000300 aa 137 163 164 162 000301 aa 151 156 147 137 000302 aa 165 164 151 154 000303 aa 137 000 000 000 000304 55 000020 000003 000305 0a 000200 400000 000306 55 000017 000003 000307 aa 003 164 143 164 tct 000310 55 000027 000014 000311 0a 000156 400000 000312 55 000023 000003 000313 aa 014 151 154 154 illegal_char  000314 aa 145 147 141 154 000315 aa 137 143 150 141 000316 aa 162 000 000 000 000317 55 000033 000020 000320 0a 000124 400000 000321 55 000032 000003 000322 aa 003 163 143 155 scm 000323 55 000037 000027 000324 0a 000111 400000 000325 55 000036 000003 000326 aa 003 155 166 164 mvt 000327 55 000045 000033 000330 0a 000000 400000 000331 55 000042 000003 000332 aa 011 146 151 156 find_char  000333 aa 144 137 143 150 000334 aa 141 162 000 000 000335 55 000002 000037 000336 6a 000000 400002 000337 55 000050 000003 000340 aa 014 163 171 155 symbol_table  000341 aa 142 157 154 137 000342 aa 164 141 142 154 000343 aa 145 000 000 000 DEFINITIONS HASH TABLE  000344 aa 000000 000015 000345 aa 000000 000000 000346 aa 000000 000000 000347 5a 000020 000000 000350 aa 000000 000000 000351 aa 000000 000000 000352 aa 000000 000000 000353 5a 000027 000000 000354 5a 000037 000000 000355 5a 000045 000000 000356 aa 000000 000000 000357 5a 000033 000000 000360 aa 000000 000000 000361 5a 000014 000000 NO EXTERNAL NAMES  NO TRAP POINTER WORDS  TYPE PAIR BLOCKS  000362 aa 000001 000000 000363 aa 000000 000000 INTERNAL EXPRESSION WORDS LINKAGE INFORMATION 000000 aa 000000 000000 000001 0a 000270 000000 000002 aa 000000 000000 000003 aa 000000 000000 000004 aa 000000 000000 000005 aa 000000 000000 000006 22 000010 000010 000007 a2 000000 000000 SYMBOL INFORMATION SYMBOL TABLE HEADER  000000 aa 000000 000001 000001 aa 163171 155142 000002 aa 164162 145145 000003 aa 000000 000004 000004 aa 000000 111316 000005 aa 510113 575622 000006 aa 000000 111335 000007 aa 723073 702560 000010 aa 141154 155040 000011 aa 040040 040040 000012 aa 000024 000040 000013 aa 000034 000040 000014 aa 000044 000100 000015 aa 000002 000002 000016 aa 000064 000000 000017 aa 000000 000136 000020 aa 000000 000105 000021 aa 000000 000125 000022 aa 000130 000105 000023 aa 000064 000000 000024 aa 101114 115040 000025 aa 126145 162163 000026 aa 151157 156040 000027 aa 040066 056064 000030 aa 040040 101160 000031 aa 162151 154040 000032 aa 061071 070061 000033 aa 040040 040040 000034 aa 110157 154155 000035 aa 163164 145144 000036 aa 164056 123171 000037 aa 163115 141151 000040 aa 156164 056155 000041 aa 040040 040040 000042 aa 040040 040040 000043 aa 040040 040040 000044 aa 154151 163164 000045 aa 040040 040040 000046 aa 040040 040040 000047 aa 040040 040040 000050 aa 040040 040040 000051 aa 040040 040040 000052 aa 040040 040040 000053 aa 040040 040040 000054 aa 040040 040040 000055 aa 040040 040040 000056 aa 040040 040040 000057 aa 040040 040040 000060 aa 040040 040040 000061 aa 040040 040040 000062 aa 040040 040040 000063 aa 040040 040040 000064 aa 000000 000001 000065 aa 000000 000001 000066 aa 000072 000052 000067 aa 113331 137440 000070 aa 000000 111335 000071 aa 624641 200000 000072 aa 076144 165155 >dumps>old>recomp>convert_string_util_.alm  000073 aa 160163 076157 000074 aa 154144 076162 000075 aa 145143 157155 000076 aa 160076 143157 000077 aa 156166 145162 000100 aa 164137 163164 000101 aa 162151 156147 000102 aa 137165 164151 000103 aa 154137 056141 000104 aa 154155 040040 MULTICS ASSEMBLY CROSS REFERENCE LISTING Value Symbol Source file Line number  4 bit convert_string_util_: 36, 223, 229, 235.  110 blank convert_string_util_: 131, 169.  260 check_which_bit convert_string_util_: 357, 370, 375. 0 find_char convert_string_util_: 24, 68.  232 find_high_bits convert_string_util_: 79, 275, 341. 264 found_first_bit convert_string_util_: 350, 373, 381. 254 found_other_bit convert_string_util_: 358, 368.  37 have_high_bit convert_string_util_: 83, 111.  156 illegal_char convert_string_util_: 27, 266.  6 indicator convert_string_util_: 38, 114, 122, 136, 147, 151, 314, 323.  14 look_for_blanks convert_string_util_: 80, 85.  5 match convert_string_util_: 37, 221, 241, 272, 281. 111 mvt convert_string_util_: 25, 185.  25 no_double_blanks convert_string_util_: 91, 98.  265 no_high_bits convert_string_util_: 366, 384.  172 no_illegal_chars convert_string_util_: 276, 282.  67 return_full_string convert_string_util_: 109, 145.  64 return_normal convert_string_util_: 124, 127, 133, 140.  124 scm convert_string_util_: 26, 217.  141 scm4 convert_string_util_: 225, 233.  145 scm_ck convert_string_util_: 231, 238.  150 scm_done convert_string_util_: 238, 242.  247 scm_other_bit convert_string_util_: 347, 360.  2 stringl convert_string_util_: 33, 72, 163, 165, 188, 220, 244, 270, 284, 301,  328, 330.  0 stringp convert_string_util_: 32, 71, 160, 187, 219, 247, 269, 287, 300, 327.  4 tablep convert_string_util_: 35, 99, 189, 304.  3 tally convert_string_util_: 34, 77, 116, 137, 142, 146, 150, 230, 236, 243,  245, 273, 279, 283, 285, 302, 317, 318, 322, 329.  6 targetp convert_string_util_: 39, 190.  200 tct convert_string_util_: 28, 298.  71 tct_done convert_string_util_: 117, 138, 143, 149.  44 tct_hit convert_string_util_: 105, 119.  101 tct_nbump convert_string_util_: 152, 154, 156, 158.  222 tct_nohit convert_string_util_: 310, 321.  224 tct_ptr_inc convert_string_util_: 319, 325.  10 w1 convert_string_util_: 43, 82, 95, 108, 115, 162, 164, 278, 345, 349,  372, 377, 380, 385.  11 w2 convert_string_util_: 44, 89, 93, 96, 103, 120, 126, 141, 308, 312,  316, 355, 364, 369, 376. NO FATAL ERRORS  ----------------------------------------------------------- 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