1with WORD_SUPPORT_PACKAGE; use WORD_SUPPORT_PACKAGE; -- for STEM_IO 2with STRINGS_PACKAGE; use STRINGS_PACKAGE; 3with LATIN_FILE_NAMES; use LATIN_FILE_NAMES; 4with PREFACE; 5with INFLECTIONS_PACKAGE; use INFLECTIONS_PACKAGE; 6with DICTIONARY_PACKAGE; use DICTIONARY_PACKAGE; 7with ADDONS_PACKAGE; use ADDONS_PACKAGE; 8with UNIQUES_PACKAGE; use UNIQUES_PACKAGE; 9pragma ELABORATE(INFLECTIONS_PACKAGE); 10pragma ELABORATE(DICTIONARY_PACKAGE); 11pragma ELABORATE(ADDONS_PACKAGE); 12package body LINE_STUFF is 13 14 15 16 17 procedure LOAD_DICTIONARY(DICT : in out DICTIONARY; 18 DICTIONARY_FILE_NAME : STRING) is 19 -- For loading a DICTIONARY list from a file 20 -- Only used now for DICT.LOC 21 22 DICTIONARY_FILE : FILE_TYPE; 23 BLK_STEM : constant STEM_TYPE := NULL_STEM_TYPE; 24 STS : STEMS_TYPE := NULL_STEMS_TYPE; 25 PT : PART_ENTRY := NULL_PART_ENTRY; 26 TRAN : TRANSLATION_RECORD := NULL_TRANSLATION_RECORD; 27 KIND : KIND_ENTRY := NULL_KIND_ENTRY; 28 VALUE : NUMERAL_VALUE_TYPE := 0; 29 MEAN : MEANING_TYPE := NULL_MEANING_TYPE; 30 31 FC1, FC2, FC3, FC4 : CHARACTER; 32 33 LINE, ST_LINE, BLANK_LINE : STRING(1..100) := (others => ' '); 34 L, LL, LLL, LAST : INTEGER := 0; 35 NUMBER_OF_DICTIONARY_ENTRIES : INTEGER := 0; 36 37 procedure GET_STEM(S : in STRING; 38 STEM : out STEM_TYPE; LAST : out INTEGER) is 39 I : INTEGER := 1; 40 L : INTEGER := S'FIRST; 41 begin 42 STEM := NULL_STEM_TYPE; 43 -- Squeeze left 44 while L <= S'LAST and then S(L) = ' ' loop 45 L := L + 1; 46 end loop; 47 -- Count until the first blank 48 -- Return that string 49 while L <= S'LAST and then S(L) /= ' ' loop 50 STEM(I) := S(L); 51 I := I + 1; 52 L := L + 1; 53 end loop; 54 -- Return last 55 LAST := L; 56 57 end GET_STEM; 58 59 60 begin 61 62 OPEN(DICTIONARY_FILE, IN_FILE, DICTIONARY_FILE_NAME); 63 PREFACE.PUT("Dictionary loading"); 64 65 while not END_OF_FILE(DICTIONARY_FILE) loop 66--TEXT_IO.PUT_LINE("GETTING"); 67 ST_LINE := BLANK_LINE; 68 GET_NON_COMMENT_LINE(DICTIONARY_FILE, ST_LINE, LAST); -- STEMS 69--TEXT_IO.PUT_LINE("READ STEMS"); 70 71 LINE := BLANK_LINE; 72--TEXT_IO.PUT("1 "); 73 GET_NON_COMMENT_LINE(DICTIONARY_FILE, LINE, L); -- PART 74--TEXT_IO.PUT("2 "); 75 PART_ENTRY_IO.GET(LINE(1..L), PT, LL); 76--TEXT_IO.PUT("3 "); 77 ---- KIND_ENTRY_IO.GET(LINE(LL+1..L), PT.POFS, KIND, LL); 78--TEXT_IO.PUT("4 "); 79 TRANSLATION_RECORD_IO.GET(LINE(LL+1..L), TRAN, LLL); 80--TEXT_IO.PUT("5 "); 81--TEXT_IO.PUT_LINE("READ PART"); 82 83-- Specialize for parts 84-- If ADV then look if the CO is something other than X 85-- If so (like POS) then only that stem is active, and the others => xxx 86-- Same for ADJ 87-- If the ADJ or ADV stems have different first letters then make them 88-- different dictionary entries -- Do this in LOAD and in DICT.DIC 89--TEXT_IO.PUT_LINE("GETTING STEMS IN LOAD_DICTIONARY"); 90 91 STS := NULL_STEMS_TYPE; 92 LL := 1; 93 -- Extract up to 4 stems 94 for I in 1..NUMBER_OF_STEMS(PT.POFS) loop -- EXTRACT STEMS 95 GET_STEM(ST_LINE(LL..LAST), STS(I), LL); 96 end loop; 97 98 99--for I in 1..NUMBER_OF_STEMS(PT.POFS) loop 100-- TEXT_IO.PUT(STS(I)); 101--end loop; 102--TEXT_IO.NEW_LINE; 103 104 LINE := BLANK_LINE; 105 GET_NON_COMMENT_LINE(DICTIONARY_FILE, LINE, L); -- MEANING 106 MEAN := HEAD(TRIM(LINE(1..L)), MAX_MEANING_SIZE); 107--TEXT_IO.PUT_LINE("READ MEANING"); 108 109 110 111 -- Now take care of other first letters in a gross way 112 FC1 := LOWER_CASE(STS(1)(1)); 113 FC2 := LOWER_CASE(STS(2)(1)); 114 FC3 := LOWER_CASE(STS(3)(1)); 115 FC4 := LOWER_CASE(STS(4)(1)); 116 if FC1 = 'v' then FC1 := 'u'; end if; 117 if FC1 = 'j' then FC1 := 'i'; end if; 118 if FC2 = 'v' then FC2 := 'u'; end if; 119 if FC2 = 'j' then FC2 := 'i'; end if; 120 if FC3 = 'v' then FC3 := 'u'; end if; 121 if FC3 = 'j' then FC3 := 'i'; end if; 122 if FC4 = 'v' then FC4 := 'u'; end if; 123 if FC4 = 'j' then FC4 := 'i'; end if; 124 if PT.POFS = N then 125 if (STS(2)(1) /= STS(1)(1) and then 126 STS(2)(1) /= ' ' and then 127 STS(2)(1..3) /= ZZZ_STEM ) then 128 DICT(FC1) := 129 new DICTIONARY_ITEM'(( (STS(1), ZZZ_STEM, BLK_STEM, BLK_STEM), 130 --PT, KIND, TRAN, MEAN), DICT(FC1)); 131 PT, TRAN, MEAN), DICT(FC1)); 132 DICT(FC2) := 133 new DICTIONARY_ITEM'( ( (ZZZ_STEM, STS(2), BLK_STEM, BLK_STEM), 134 --PT, KIND, TRAN, MEAN), DICT(FC2) ); 135 PT, TRAN, MEAN), DICT(FC2) ); 136 else 137 --DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, KIND, TRAN, MEAN), 138 DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, TRAN, MEAN), 139 DICT(FC1)); 140 end if; 141 142 elsif (PT.POFS = PRON) or (PT.POFS = PACK) then 143 if (STS(2)(1) /= STS(1)(1) and then 144 STS(2)(1) /= ' ' and then 145 STS(2)(1..3) /= ZZZ_STEM ) then 146 DICT(FC1) := 147 new DICTIONARY_ITEM'(( (STS(1), ZZZ_STEM, BLK_STEM, BLK_STEM), 148 --PT, KIND, TRAN, MEAN), DICT(FC1)); 149 PT, TRAN, MEAN), DICT(FC1)); 150 DICT(FC2) := 151 new DICTIONARY_ITEM'( ( (ZZZ_STEM, STS(2), BLK_STEM, BLK_STEM), 152 --PT, KIND, TRAN, MEAN), DICT(FC2) ); 153 PT, TRAN, MEAN), DICT(FC2) ); 154 else 155 --DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, KIND, TRAN, MEAN), 156 DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, TRAN, MEAN), 157 DICT(FC1)); 158 end if; 159 160 elsif PT.POFS = ADJ then 161 if PT.ADJ.CO = X then -- X for all KINDs 162 if (STS(2)(1) /= STS(1)(1) and then 163 STS(2)(1) /= ' ' and then 164 STS(2)(1..3) /= ZZZ_STEM ) or 165 (STS(3)(1) /= STS(1)(1) and then 166 STS(3)(1) /= ' ' and then 167 STS(3)(1..3) /= ZZZ_STEM ) or 168 (STS(4)(1) /= STS(1)(1) and then 169 STS(4)(1) /= ' ' and then 170 STS(4)(1..3) /= ZZZ_STEM ) then 171 DICT(FC1) := 172 new DICTIONARY_ITEM'(( (STS(1), BLK_STEM, BLK_STEM, BLK_STEM), 173 (ADJ, (PT.ADJ.DECL, POS)), 174 --KIND, TRAN, MEAN), DICT(FC1)); 175 TRAN, MEAN), DICT(FC1)); 176 DICT(FC2) := 177 new DICTIONARY_ITEM'( ( (ZZZ_STEM, STS(2), BLK_STEM, BLK_STEM), 178 (ADJ, (PT.ADJ.DECL, POS)), 179 --KIND, TRAN, MEAN), DICT(FC2) ); 180 TRAN, MEAN), DICT(FC2) ); 181 DICT(FC3) := 182 new DICTIONARY_ITEM'(( (ZZZ_STEM, ZZZ_STEM, STS(3), BLK_STEM), 183 (ADJ, (PT.ADJ.DECL, COMP)), 184 --KIND, TRAN, MEAN), DICT(FC3)); 185 TRAN, MEAN), DICT(FC3)); 186 DICT(FC4) := 187 new DICTIONARY_ITEM'(( (ZZZ_STEM, ZZZ_STEM, ZZZ_STEM, STS(4)), 188 (ADJ, (PT.ADJ.DECL, SUPER)), 189 --KIND, TRAN, MEAN), DICT(FC4)); 190 TRAN, MEAN), DICT(FC4)); 191 end if; 192 elsif PT.ADJ.CO = POS then 193 DICT(FC1) := 194 new DICTIONARY_ITEM'(( (STS(1), BLK_STEM, BLK_STEM, BLK_STEM), 195 --(ADJ, (PT.ADJ.DECL, POS)), KIND, TRAN, MEAN), 196 (ADJ, (PT.ADJ.DECL, POS)), TRAN, MEAN), 197 DICT(FC1)); 198 DICT(FC2) := 199 new DICTIONARY_ITEM'(((BLK_STEM, STS(2), BLK_STEM, BLK_STEM), 200 --(ADJ, (PT.ADJ.DECL, POS)), KIND, TRAN, MEAN), 201 (ADJ, (PT.ADJ.DECL, POS)), TRAN, MEAN), 202 DICT(FC2)); 203 elsif PT.ADJ.CO = COMP then 204 DICT(FC1) := 205 new DICTIONARY_ITEM'(( (BLK_STEM, BLK_STEM, STS(1), BLK_STEM), 206 --(ADJ, (PT.ADJ.DECL, COMP)), KIND, TRAN, MEAN), 207 (ADJ, (PT.ADJ.DECL, COMP)), TRAN, MEAN), 208 DICT(FC1)); 209 elsif PT.ADJ.CO = SUPER then 210 DICT(FC1) := 211 new DICTIONARY_ITEM'(( (BLK_STEM, BLK_STEM, BLK_STEM, STS(1)), 212 --(ADJ, (PT.ADJ.DECL, SUPER)), KIND, TRAN, MEAN), 213 (ADJ, (PT.ADJ.DECL, SUPER)), TRAN, MEAN), 214 DICT(FC1)); 215 216 else 217 --DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, KIND, TRAN, MEAN), 218 DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, TRAN, MEAN), 219 DICT(FC1)); 220 end if; 221 222 elsif PT.POFS = ADV then 223 if PT.ADV.CO = X then -- X for all KINDs 224 if (STS(2)(1) /= STS(1)(1) and then 225 STS(2)(1) /= ' ' and then 226 STS(2)(1..3) /= ZZZ_STEM ) or 227 (STS(3)(1) /= STS(1)(1) and then 228 STS(3)(1) /= ' ' and then 229 STS(3)(1..3) /= ZZZ_STEM ) then 230 DICT(FC1) := 231 new DICTIONARY_ITEM'(( (STS(1), BLK_STEM, BLK_STEM, BLK_STEM), 232 --(ADV, (CO => POS)), KIND, TRAN, MEAN), DICT(FC1)); 233 (ADV, (CO => POS)), TRAN, MEAN), DICT(FC1)); 234 DICT(FC2) := 235 new DICTIONARY_ITEM'(( (STS(2), BLK_STEM, BLK_STEM, BLK_STEM), 236 --(ADV, (CO => COMP)), KIND, TRAN, MEAN), DICT(FC2)); 237 (ADV, (CO => COMP)), TRAN, MEAN), DICT(FC2)); 238 DICT(FC3) := 239 new DICTIONARY_ITEM'(( (STS(3), BLK_STEM, BLK_STEM, BLK_STEM), 240 --(ADV, (CO => SUPER)), KIND, TRAN, MEAN), DICT(FC3)); 241 (ADV, (CO => SUPER)), TRAN, MEAN), DICT(FC3)); 242 end if; 243 elsif PT.ADV.CO = POS then -- just a specific KIND 244 DICT(FC1) := 245 new DICTIONARY_ITEM'(( (STS(1), BLK_STEM, BLK_STEM, BLK_STEM), 246 --(ADV, (CO => POS)), KIND, TRAN, MEAN), 247 (ADV, (CO => POS)), TRAN, MEAN), 248 DICT(FC1)); 249 elsif PT.ADV.CO = COMP then 250 DICT(FC1) := 251 new DICTIONARY_ITEM'(( (BLK_STEM, STS(1), BLK_STEM, BLK_STEM), 252 --(ADV, (CO => COMP)), KIND, TRAN, MEAN), 253 (ADV, (CO => COMP)), TRAN, MEAN), 254 DICT(FC1)); 255 elsif PT.ADV.CO = SUPER then 256 DICT(FC1) := 257 new DICTIONARY_ITEM'(( (BLK_STEM, BLK_STEM, STS(1), BLK_STEM), 258 --(ADV, (CO => SUPER)), KIND, TRAN, MEAN), 259 (ADV, (CO => SUPER)), TRAN, MEAN), 260 DICT(FC1)); 261 else 262 --DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, KIND, TRAN, MEAN), 263 DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, TRAN, MEAN), 264 DICT(FC1)); 265 end if; 266 267 elsif PT.POFS = V then 268 if (STS(2)(1) /= STS(1)(1) and then 269 STS(2)(1) /= ' ' and then 270 STS(2)(1..3) /= ZZZ_STEM ) or 271 (STS(3)(1) /= STS(1)(1) and then 272 STS(3)(1) /= ' ' and then 273 STS(3)(1..3) /= ZZZ_STEM ) or 274 (STS(4)(1) /= STS(1)(1) and then 275 STS(4)(1) /= ' ' and then 276 STS(4)(1..3) /= ZZZ_STEM ) then 277 DICT(FC1) := 278 new DICTIONARY_ITEM'(( (STS(1), ZZZ_STEM, ZZZ_STEM, ZZZ_STEM), 279 --PT, KIND, TRAN, MEAN), DICT(FC1) ); 280 PT, TRAN, MEAN), DICT(FC1) ); 281 DICT(FC2) := 282 new DICTIONARY_ITEM'(( (ZZZ_STEM, STS(2), ZZZ_STEM, ZZZ_STEM), 283 --PT, KIND, TRAN, MEAN), DICT(FC2)); 284 PT, TRAN, MEAN), DICT(FC2)); 285 DICT(FC3) := 286 new DICTIONARY_ITEM'(( (ZZZ_STEM, ZZZ_STEM, STS(3), ZZZ_STEM), 287 --PT, KIND, TRAN, MEAN), DICT(FC3)); 288 PT, TRAN, MEAN), DICT(FC3)); 289 DICT(FC4) := 290 new DICTIONARY_ITEM'(( (ZZZ_STEM, ZZZ_STEM, ZZZ_STEM, STS(4)), 291 --PT, KIND, TRAN, MEAN), DICT(FC4)); 292 PT, TRAN, MEAN), DICT(FC4)); 293 else 294 --DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, KIND, TRAN, MEAN), 295 DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, TRAN, MEAN), 296 DICT(FC1)); 297 end if; 298 299 elsif PT.POFS = NUM then 300 if PT.NUM.SORT = X then -- X for all KINDs 301 if (STS(1)(1) /= ' ' and then 302 STS(1)(1..3) /= ZZZ_STEM ) then 303 DICT(FC1) := 304 new DICTIONARY_ITEM'(( (STS(1), BLK_STEM, BLK_STEM, BLK_STEM), 305 --(NUM, (PT.NUM.DECL, CARD)), KIND, TRAN, MEAN), 306 (NUM, (PT.NUM.DECL, CARD, VALUE)), TRAN, MEAN), 307 DICT(FC1)); 308 end if; 309 if (STS(2)(1) /= ' ' and then 310 STS(2)(1..3) /= ZZZ_STEM ) then 311 DICT(FC2) := 312 new DICTIONARY_ITEM'(( (ZZZ_STEM, STS(2), BLK_STEM, BLK_STEM), 313 --(NUM, ((0, 0), ORD)), KIND, TRAN, MEAN), 314 (NUM, ((0, 0), ORD, VALUE)), TRAN, MEAN), 315 DICT(FC2)); 316 end if; 317 if (STS(3)(1) /= ' ' and then 318 STS(3)(1..3) /= ZZZ_STEM ) then 319 DICT(FC3) := 320 new DICTIONARY_ITEM'(( (ZZZ_STEM, ZZZ_STEM, STS(3), BLK_STEM), 321 --(NUM, (PT.NUM.DECL, DIST)), KIND, TRAN, MEAN), 322 (NUM, (PT.NUM.DECL, DIST, VALUE)), TRAN, MEAN), 323 DICT(FC3)); 324 end if; 325 if (STS(4)(1) /= ' ' and then 326 STS(4)(1..3) /= ZZZ_STEM ) then 327 DICT(FC4) := 328 new DICTIONARY_ITEM'(( (ZZZ_STEM, ZZZ_STEM, ZZZ_STEM, STS(4)), 329 --(NUM, (PT.NUM.DECL, ADVERB)), KIND, TRAN, MEAN), 330 (NUM, (PT.NUM.DECL, ADVERB, VALUE)), TRAN, MEAN), 331 DICT(FC4)); 332 end if; 333 elsif PT.NUM.SORT = CARD then 334 DICT(FC1) := 335 new DICTIONARY_ITEM'(( (STS(1), BLK_STEM, BLK_STEM, BLK_STEM), 336 --(NUM, (PT.NUM.DECL, CARD)), KIND, TRAN, MEAN), 337 (NUM, (PT.NUM.DECL, CARD, VALUE)), TRAN, MEAN), 338 DICT(FC1)); 339 elsif PT.NUM.SORT = ORD then 340 DICT(FC1) := 341 new DICTIONARY_ITEM'(( (BLK_STEM, STS(1), BLK_STEM, BLK_STEM), 342 --(NUM, (PT.NUM.DECL, ORD)), KIND, TRAN, MEAN), 343 (NUM, (PT.NUM.DECL, ORD, VALUE)), TRAN, MEAN), 344 DICT(FC1)); 345 elsif PT.NUM.SORT = DIST then 346 DICT(FC1) := 347 new DICTIONARY_ITEM'(( (BLK_STEM, BLK_STEM, STS(1), BLK_STEM), 348 --(NUM, (PT.NUM.DECL, DIST)), KIND, TRAN, MEAN), 349 (NUM, (PT.NUM.DECL, DIST, VALUE)), TRAN, MEAN), 350 DICT(FC1)); 351 elsif PT.NUM.SORT = ADVERB then 352 DICT(FC1) := 353 new DICTIONARY_ITEM'(( (BLK_STEM, BLK_STEM, BLK_STEM, STS(1)), 354 --(NUM, (PT.NUM.DECL, ADVERB)), KIND, TRAN, MEAN), 355 (NUM, (PT.NUM.DECL, ADVERB, VALUE)), TRAN, MEAN), 356 DICT(FC1)); 357 end if; 358 359 else 360 --DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, KIND, TRAN, MEAN), 361 DICT(FC1) := new DICTIONARY_ITEM'((STS, PT, TRAN, MEAN), 362 DICT(FC1)); 363 364 end if; 365 NUMBER_OF_DICTIONARY_ENTRIES := NUMBER_OF_DICTIONARY_ENTRIES + 1; 366 end loop; 367 CLOSE(DICTIONARY_FILE); 368 PREFACE.SET_COL(33); PREFACE.PUT("-- "); 369 PREFACE.PUT(NUMBER_OF_DICTIONARY_ENTRIES, 6); 370 PREFACE.PUT(" entries"); PREFACE.SET_COL(55); 371 PREFACE.PUT_LINE("-- Loaded correctly"); 372 exception 373 when others => 374 PREFACE.PUT_LINE(" LOAD_DICTIONARY exception !!!!!!!!!!"); 375 PREFACE.PUT_LINE(ST_LINE(1..LAST)); 376 PREFACE.PUT_LINE(LINE(1..L)); 377 CLOSE(DICTIONARY_FILE); 378 PREFACE.SET_COL(33); PREFACE.PUT("-- "); 379 PREFACE.PUT(NUMBER_OF_DICTIONARY_ENTRIES, 6); 380 PREFACE.PUT(" entries"); PREFACE.SET_COL(55); 381 PREFACE.PUT_LINE("-- Loaded anyway "); 382 end LOAD_DICTIONARY; 383 384 procedure LOAD_STEM_FILE(D_K : DICTIONARY_KIND) is 385 -- This is used to load a dictionary access file, like DIC.LOC 386 -- It uses the single first letter index rather than the two letter 387 -- This dictionary must be searched with a somewhat different procedure 388 -- Not used when one loads from a regular STEMFILE (which uses two letters) 389 --use LATIN_DEBUG; 390 use STEM_IO; 391 use DICT_IO; 392 I : STEM_IO.COUNT := 1; 393 --M_P_R : MEANING_TYPE; 394 M : DICT_IO.POSITIVE_COUNT := 1; 395 DLC : DICTIONARY := DICT_LOC; 396 --DS : DICTIONARY_STEM; 397 --ZZZ_STEM : constant STEM_TYPE := "zzz" & (4..MAX_STEM_SIZE => ' '); --#### 398 begin 399--PUT_LINE("LOAD_STEM_FILE for LOC"); 400 if IS_OPEN(STEM_FILE(D_K)) then 401 DELETE(STEM_FILE(D_K)); 402 end if; 403 CREATE(STEM_FILE(D_K), INOUT_FILE, ADD_FILE_NAME_EXTENSION(STEM_FILE_NAME, 404 DICTIONARY_KIND'IMAGE(D_K))); 405--PUT_LINE("LOAD_STEM_FILE for LOC - Created STEM_FILE"); 406 if IS_OPEN(DICT_FILE(D_K)) then 407 DELETE(DICT_FILE(D_K)); 408 end if; 409 CREATE(DICT_FILE(D_K), INOUT_FILE, ADD_FILE_NAME_EXTENSION(DICT_FILE_NAME, 410 DICTIONARY_KIND'IMAGE(D_K))); 411--PUT_LINE("LOAD_STEM_FILE for LOC - Created DICT_FILE"); 412 413--PUT_LINE("L_D_F Start M = " & INTEGER'IMAGE(INTEGER(M))); 414 415 for FC in CHARACTER range 'a'..'z' loop 416 -- LOAD_DICTIONARY should have assured that all v were in u 417--LATIN_DEBUG.PUT_LINE("L_D_F Entering FC loop"); 418 DDLF(FC, 'a', D_K) := I; 419 DDLL(FC, 'a', D_K) := 0; 420 while DLC(FC) /= null loop 421--PUT_LINE("L_D_F Setting Dictfile index M = " & INTEGER'IMAGE(INTEGER(M))); 422 DICT_IO.SET_INDEX(DICT_FILE(D_K), M); 423-- %%%%%%%%%%%!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!%%%%%%%%%%%%%%%%%%%%%%% 424--PUT_LINE(DLC(FC).DE.TRAN.MEAN); 425 -- M_P_R := DLC(FC).DE.TRAN.MEAN; 426 --DICT_IO.WRITE(DICT_FILE(D_K), M_P_R); --@@@@@@@@@@@@@@@@@@@@@ 427 DICT_IO.WRITE(DICT_FILE(D_K), DLC(FC).DE); 428 for K in STEM_KEY_TYPE range 1..4 loop 429 if DLC(FC).DE.STEMS(K) /= NULL_STEM_TYPE and 430 DLC(FC).DE.STEMS(K) /= ZZZ_STEM then 431--LATIN_DEBUG.PUT(DLC(FC).DE.STEMS(K)); LATIN_DEBUG.PUT(" .. "); 432--LATIN_DEBUG.PUT(DLC(FC).DE.PART); LATIN_DEBUG.PUT(" .. "); LATIN_DEBUG.PUT(K); 433--LATIN_DEBUG.PUT(" .. "); LATIN_DEBUG.PUT(INTEGER(M)); LATIN_DEBUG.NEW_LINE; 434 WRITE(STEM_FILE(D_K), 435 (DLC(FC).DE.STEMS(K), DLC(FC).DE.PART, K, M)); 436 DDLL(FC, 'a', D_K) := I; 437--LATIN_DEBUG.PUT_LINE("L_D_F DDLL(FC, 'a', D_K) := I = " & INTEGER'IMAGE(I)); 438 I := I + 1; 439 end if; 440 end loop; 441 DLC(FC) := DLC(FC).SUCC; 442 M := M + 1; 443--PUT_LINE("L_D_F 22222 M = " & INTEGER'IMAGE(INTEGER(M))); 444 end loop; 445--PUT_LINE("L_D_F 33333 M = " & INTEGER'IMAGE(INTEGER(M))); 446 end loop; 447--PUT_LINE("L_D_F 44444 M = " & INTEGER'IMAGE(INTEGER(M))); 448 end LOAD_STEM_FILE; 449 450 451 452 package body TACKON_LINE_IO is 453 use PART_OF_SPEECH_TYPE_IO; 454 use TACKON_ENTRY_IO; 455 use TEXT_IO; 456 SPACER : CHARACTER := ' '; 457 458 459 procedure GET(F : in FILE_TYPE; P : out TACKON_LINE) is 460 begin 461 GET(F, P.POFS); 462 GET(F, SPACER); 463 GET(F, P.TACK); 464 GET(F, SPACER); 465 GET(F, P.ENTR); 466 GET(F, SPACER); 467 GET(F, P.MEAN); 468 end GET; 469 470 471 procedure GET(P : out TACKON_LINE) is 472 begin 473 GET(P.POFS); 474 GET(SPACER); 475 GET(P.TACK); 476 GET(SPACER); 477 GET(P.ENTR); 478 GET(SPACER); 479 GET(P.MEAN); 480 end GET; 481 482 procedure PUT(F : in FILE_TYPE; P : in TACKON_LINE) is 483 begin 484 PUT(F, P.POFS); 485 PUT(F, ' '); 486 PUT(F, P.TACK); 487 PUT(F, ' '); 488 PUT(F, P.ENTR); 489 PUT(F, ' '); 490 PUT(F, P.MEAN); 491 end PUT; 492 493 procedure PUT(P : in TACKON_LINE) is 494 begin 495 PUT(P.POFS); 496 PUT(' '); 497 PUT(P.TACK); 498 PUT(' '); 499 PUT(P.ENTR); 500 PUT(' '); 501 PUT(P.MEAN); 502 end PUT; 503 504 procedure GET(S : in STRING; P : out TACKON_LINE; LAST : out INTEGER) is 505 L : INTEGER := S'FIRST - 1; 506 M : INTEGER := 0; 507 begin 508 M := L + DICTIONARY_KIND_IO.DEFAULT_WIDTH; 509 GET(S(L+1..M), P.POFS, L); 510 L := M + 1; 511 M := L + MAX_STEM_SIZE; 512 P.TACK := S(L+1..M); 513 L := M + 1; 514 M := L + TACKON_ENTRY_IO.DEFAULT_WIDTH; 515 GET(S(L+1..M), P.ENTR, L); 516 L := M + 1; 517 M := L + MAX_MEANING_SIZE; 518 P.MEAN := S(L+1..M); 519 LAST := M; 520 end GET; 521 522 523 procedure PUT(S : out STRING; P : in TACKON_LINE) is 524 L : INTEGER := S'FIRST - 1; 525 M : INTEGER := 0; 526 begin 527 M := L + DICTIONARY_KIND_IO.DEFAULT_WIDTH; 528 PUT(S(L+1..M), P.POFS); 529 L := M + 1; 530 S(L) := ' '; 531 M := L + MAX_STEM_SIZE; 532 S(L+1..M) := P.TACK; 533 L := M + 1; 534 S(L) := ' '; 535 M := L + TACKON_ENTRY_IO.DEFAULT_WIDTH; 536 PUT(S(L+1..M), P.ENTR); 537 L := M + 1; 538 S(L) := ' '; 539 M := L + MAX_MEANING_SIZE; 540 S(L+1..M) := P.MEAN; 541 S(M+1..S'LAST) := (others => ' '); 542 end PUT; 543 544 end TACKON_LINE_IO; 545 546 package body PREFIX_LINE_IO is 547 use PART_OF_SPEECH_TYPE_IO; 548 use PREFIX_ENTRY_IO; 549 use TEXT_IO; 550 SPACER : CHARACTER := ' '; 551 552 553 procedure GET(F : in FILE_TYPE; P : out PREFIX_LINE) is 554 begin 555 GET(F, P.POFS); 556 GET(F, SPACER); 557 GET(F, P.FIX); 558 GET(F, SPACER); 559 GET(F, P.CONNECT); 560 GET(F, SPACER); 561 GET(F, P.ENTR); 562 GET(F, SPACER); 563 GET(F, P.MEAN); 564 end GET; 565 566 567 procedure GET(P : out PREFIX_LINE) is 568 begin 569 GET(P.POFS); 570 GET(SPACER); 571 GET(P.FIX); 572 GET(SPACER); 573 GET(P.CONNECT); 574 GET(SPACER); 575 GET(P.ENTR); 576 GET(SPACER); 577 GET(P.MEAN); 578 end GET; 579 580 procedure PUT(F : in FILE_TYPE; P : in PREFIX_LINE) is 581 begin 582 PUT(F, P.POFS); 583 PUT(F, ' '); 584 PUT(F, P.FIX); 585 PUT(F, ' '); 586 PUT(F, P.CONNECT); 587 PUT(F, ' '); 588 PUT(F, P.ENTR); 589 PUT(F, ' '); 590 PUT(F, P.MEAN); 591 end PUT; 592 593 procedure PUT(P : in PREFIX_LINE) is 594 begin 595 PUT(P.POFS); 596 PUT(' '); 597 PUT(P.FIX); 598 PUT(' '); 599 PUT(P.CONNECT); 600 PUT(' '); 601 PUT(P.ENTR); 602 PUT(' '); 603 PUT(P.MEAN); 604 end PUT; 605 606 procedure GET(S : in STRING; P : out PREFIX_LINE; LAST : out INTEGER) is 607 L : INTEGER := S'FIRST - 1; 608 M : INTEGER := 0; 609 begin 610 M := L + DICTIONARY_KIND_IO.DEFAULT_WIDTH; 611 GET(S(L+1..S'LAST), P.POFS, L); 612 L := M; 613 L := L + 1; 614 M := L + MAX_STEM_SIZE; 615 P.FIX := S(L+1..M); 616 L := M; 617 L := L + 1; 618 M := L + 1; 619 P.CONNECT := S(L+1); 620 L := L + 1; 621 M := L + PREFIX_ENTRY_IO.DEFAULT_WIDTH; 622 GET(S(L+1..S'LAST), P.ENTR, L); 623 L := M + 1; 624 M := L + MAX_MEANING_SIZE; 625 P.MEAN := S(L+1..M); 626 LAST := M; 627 end GET; 628 629 630 procedure PUT(S : out STRING; P : in PREFIX_LINE) is 631 L : INTEGER := S'FIRST - 1; 632 M : INTEGER := 0; 633 begin 634 M := L + DICTIONARY_KIND_IO.DEFAULT_WIDTH; 635 PUT(S(L+1..M), P.POFS); 636 L := M + 1; 637 S(L) := ' '; 638 M := L + MAX_STEM_SIZE; 639 S(L+1..M) := P.FIX; 640 L := M + 1; 641 S(L) := ' '; 642 M := L + 1; 643 S(L+1) := P.CONNECT; 644 M := L + PREFIX_ENTRY_IO.DEFAULT_WIDTH; 645 PUT(S(L+1..M), P.ENTR); 646 L := M + 1; 647 S(L) := ' '; 648 M := L + MAX_MEANING_SIZE; 649 S(L+1..M) := P.MEAN; 650 M := L + 1; 651 S(M+1..S'LAST) := (others => ' '); 652 end PUT; 653 654 end PREFIX_LINE_IO; 655 656 657 package body SUFFIX_LINE_IO is 658 use PART_OF_SPEECH_TYPE_IO; 659 use SUFFIX_ENTRY_IO; 660 use TEXT_IO; 661 SPACER : CHARACTER := ' '; 662 663 procedure GET(F : in FILE_TYPE; P : out SUFFIX_LINE) is 664 begin 665 GET(F, P.POFS); 666 GET(F, SPACER); 667 GET(F, P.FIX); 668 GET(F, SPACER); 669 GET(F, P.CONNECT); 670 GET(F, SPACER); 671 GET(F, P.ENTR); 672 GET(F, SPACER); 673 GET(F, P.MEAN); 674 end GET; 675 676 677 procedure GET(P : out SUFFIX_LINE) is 678 begin 679 GET(P.POFS); 680 GET(SPACER); 681 GET(P.FIX); 682 GET(SPACER); 683 GET(P.CONNECT); 684 GET(SPACER); 685 GET(P.ENTR); 686 GET(SPACER); 687 GET(P.MEAN); 688 end GET; 689 690 procedure PUT(F : in FILE_TYPE; P : in SUFFIX_LINE) is 691 begin 692 PUT(F, P.POFS); 693 PUT(F, ' '); 694 PUT(F, P.FIX); 695 PUT(F, ' '); 696 PUT(F, P.CONNECT); 697 PUT(F, ' '); 698 PUT(F, P.ENTR); 699 PUT(F, ' '); 700 PUT(F, P.MEAN); 701 end PUT; 702 703 procedure PUT(P : in SUFFIX_LINE) is 704 begin 705 PUT(P.POFS); 706 PUT(' '); 707 PUT(P.FIX); 708 PUT(' '); 709 PUT(P.CONNECT); 710 PUT(' '); 711 PUT(P.ENTR); 712 PUT(' '); 713 PUT(P.MEAN); 714 end PUT; 715 716 procedure GET(S : in STRING; P : out SUFFIX_LINE; LAST : out INTEGER) is 717 L : INTEGER := S'FIRST - 1; 718 M : INTEGER := 0; 719 begin 720 M := L + DICTIONARY_KIND_IO.DEFAULT_WIDTH; 721 GET(S(L+1..S'LAST), P.POFS, L); 722 L := M; 723 L := L + 1; 724 M := L + MAX_STEM_SIZE; 725 P.FIX := S(L+1..M); 726 L := M; 727 L := L + 1; 728 M := L + 1; 729 P.CONNECT := S(L+1); 730 L := L + 1; 731 M := L + SUFFIX_ENTRY_IO.DEFAULT_WIDTH; 732 GET(S(L+1..S'LAST), P.ENTR, L); 733 L := M + 1; 734 M := L + MAX_MEANING_SIZE; 735 P.MEAN := S(L+1..M); 736 LAST := M; 737 end GET; 738 739 740 procedure PUT(S : out STRING; P : in SUFFIX_LINE) is 741 L : INTEGER := S'FIRST - 1; 742 M : INTEGER := 0; 743 begin 744 M := L + DICTIONARY_KIND_IO.DEFAULT_WIDTH; 745 PUT(S(L+1..M), P.POFS); 746 L := M + 1; 747 S(L) := ' '; 748 M := L + MAX_STEM_SIZE; 749 S(L+1..M) := P.FIX; 750 L := M + 1; 751 S(L) := ' '; 752 M := L + 1; 753 S(L+1) := P.CONNECT; 754 L := M + 1; 755 S(L) := ' '; 756 M := L + SUFFIX_ENTRY_IO.DEFAULT_WIDTH; 757 PUT(S(L+1..M), P.ENTR); 758 L := M + 1; 759 S(L) := ' '; 760 M := L + MAX_MEANING_SIZE; 761 S(L+1..M) := P.MEAN; 762 S(M+1..S'LAST) := (others => ' '); 763 end PUT; 764 765 end SUFFIX_LINE_IO; 766 767 package body UNIQUE_ENTRY_IO is 768 use QUALITY_RECORD_IO; 769 use KIND_ENTRY_IO; 770 use TRANSLATION_RECORD_IO; 771 SPACER : CHARACTER; 772 773 PE : UNIQUE_ENTRY; 774 775 procedure GET(F : in FILE_TYPE; P : out UNIQUE_ENTRY) is 776 UE : UNIQUE_ENTRY; 777 begin 778 GET(F, UE.STEM); 779 GET(F, SPACER); 780 GET(F, UE.QUAL); 781 GET(F, SPACER); 782 GET(F, UE.QUAL.POFS, UE.KIND); 783 GET(F, SPACER); 784 GET(F, UE.TRAN); 785 P := UE; 786 end GET; 787 788 789 procedure GET(P : out UNIQUE_ENTRY) is 790 UE : UNIQUE_ENTRY; 791 begin 792 GET(P.STEM); 793 GET(SPACER); 794 GET(UE.QUAL); 795 GET(SPACER); 796 GET(UE.QUAL.POFS, UE.KIND); 797 GET(SPACER); 798 GET(P.TRAN); 799 end GET; 800 801 procedure PUT(F : in FILE_TYPE; P : in UNIQUE_ENTRY) is 802 begin 803 PUT(F, P.STEM); 804 PUT(F, ' '); 805 PUT(F, P.QUAL); 806 PUT(F, ' '); 807 PUT(F, P.QUAL.POFS, P.KIND); 808 PUT(F, ' '); 809 PUT(F, P.TRAN); 810 end PUT; 811 812 procedure PUT(P : in UNIQUE_ENTRY) is 813 begin 814 PUT(P.STEM); 815 PUT(' '); 816 PUT(P.QUAL); 817 PUT(' '); 818 PUT(P.QUAL.POFS, P.KIND); 819 PUT(' '); 820 PUT(P.TRAN); 821 end PUT; 822 823 procedure GET(S : in STRING; P : out UNIQUE_ENTRY; LAST : out INTEGER) is 824 L : INTEGER := S'FIRST - 1; 825 M : INTEGER := 0; 826 begin 827 M := L + MAX_STEM_SIZE; 828 P.STEM := S(L+1..M); 829 L := L + 1; 830 M := L + QUALITY_RECORD_IO.DEFAULT_WIDTH; 831 GET(S(L+1..S'LAST), P.QUAL, L); 832 L := L + 1; 833 M := L + KIND_ENTRY_IO.DEFAULT_WIDTH; 834 GET(S(L+1..S'LAST), P.QUAL.POFS, P.KIND, L); 835 L := L + 1; 836 M := L + MAX_MEANING_SIZE; 837 GET(S(L+1..S'LAST), P.TRAN, LAST); 838 end GET; 839 840 841 procedure PUT(S : out STRING; P : in UNIQUE_ENTRY) is 842 L : INTEGER := S'FIRST - 1; 843 M : INTEGER := 0; 844 begin 845 M := L + MAX_STEM_SIZE; 846 S(L+1..M) := P.STEM; 847 L := M + 1; 848 S(L) := ' '; 849 M := L + QUALITY_RECORD_IO.DEFAULT_WIDTH; 850 PUT(S(L+1..M), P.QUAL); 851 L := M + 1; 852 S(L) := ' '; 853 M := L + KIND_ENTRY_IO.DEFAULT_WIDTH; 854 PUT(S(L+1..M), P.QUAL.POFS, P.KIND); 855 L := M + 1; 856 S(L) := ' '; 857 M := M + MAX_MEANING_SIZE; 858 PUT(S(L+1..M), P.TRAN); 859 S(M+1..S'LAST) := (others => ' '); 860 end PUT; 861 862 end UNIQUE_ENTRY_IO; 863 864 865 866 procedure LOAD_UNIQUES(UNQ : in out LATIN_UNIQUES; FILE_NAME : in STRING) is 867 use INFLECTIONS_PACKAGE.INTEGER_IO; 868 use QUALITY_RECORD_IO; 869 use PART_ENTRY_IO; 870 use KIND_ENTRY_IO; 871 use TRANSLATION_RECORD_IO; 872 use DICT_IO; 873 874 UNIQUES_FILE : TEXT_IO.FILE_TYPE; 875 LINE, STEM_LINE, BLANKS : STRING(1..100) := (others => ' '); 876 LAST, L : INTEGER := 0; 877 STEM : STEM_TYPE := NULL_STEM_TYPE; 878 QUAL : QUALITY_RECORD; 879 KIND : KIND_ENTRY; 880 --PART : PART_ENTRY := NULL_PART_ENTRY; 881 TRAN : TRANSLATION_RECORD := NULL_TRANSLATION_RECORD; 882 MNPC : MNPC_TYPE := NULL_MNPC; 883 MEAN : MEANING_TYPE := NULL_MEANING_TYPE; 884 M : DICT_IO.POSITIVE_COUNT := 1; 885 D_K : constant DICTIONARY_KIND := UNIQUE; 886 887 NUMBER_OF_UNIQUES_ENTRIES : INTEGER := 0; 888 889 begin 890--TEXT_IO.PUT_LINE("UNIQUES started"); 891 TEXT_IO.OPEN(UNIQUES_FILE, TEXT_IO.IN_FILE, FILE_NAME); 892 PREFACE.SET_COL(1); 893 PREFACE.PUT("UNIQUES file loading"); 894 895-- if DICT_IO.IS_OPEN(DICT_FILE(D_K)) then 896-- DICT_IO.DELETE(DICT_FILE(D_K)); 897-- end if; 898-- DICT_IO.CREATE(DICT_FILE(D_K), DICT_IO.INOUT_FILE, ""); 899-- -- ADD_FILE_NAME_EXTENSION(DICT_FILE_NAME, DICTIONARY_KIND'IMAGE(D_K))); 900 901 while not END_OF_FILE(UNIQUES_FILE) loop 902 STEM_LINE := BLANKS; 903 GET_LINE(UNIQUES_FILE, STEM_LINE, LAST); -- STEM 904 STEM := HEAD(TRIM(STEM_LINE(1..LAST)), MAX_STEM_SIZE); 905 906 LINE := BLANKS; 907 GET_LINE(UNIQUES_FILE, LINE, LAST); -- QUAL, KIND, TRAN 908 GET(LINE(1..LAST), QUAL, L); 909 GET(LINE(L+1..LAST), QUAL.POFS, KIND, L); 910 AGE_TYPE_IO.GET(LINE(L+1..LAST), TRAN.AGE, L); 911 AREA_TYPE_IO.GET(LINE(L+1..LAST), TRAN.AREA, L); 912 GEO_TYPE_IO.GET(LINE(L+1..LAST), TRAN.GEO, L); 913 FREQUENCY_TYPE_IO.GET(LINE(L+1..LAST), TRAN.FREQ, L); 914 SOURCE_TYPE_IO.GET(LINE(L+1..LAST), TRAN.SOURCE, L); 915 916 917 LINE := BLANKS; 918 GET_LINE(UNIQUES_FILE, LINE, L); -- MEAN 919 MEAN := HEAD(TRIM(LINE(1..L)), MAX_MEANING_SIZE); 920--@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ 921 declare 922 UNIQUE_DE : DICTIONARY_ENTRY; 923 PART : PART_ENTRY := NULL_PART_ENTRY; 924 begin 925 case PART.POFS is 926 when N => 927 PART := (N, (QUAL.N.DECL, QUAL.N.GENDER, KIND.N_KIND)); 928 when PRON => 929 PART := (PRON, (QUAL.PRON.DECL, KIND.PRON_KIND)); 930 when PACK => 931 PART := (PACK, (QUAL.PACK.DECL, KIND.PACK_KIND)); 932 when ADJ => 933 PART := (ADJ, (QUAL.ADJ.DECL, QUAL.ADJ.CO)); 934 when NUM => 935 PART := (NUM, (QUAL.NUM.DECL, QUAL.NUM.SORT, KIND.NUM_VALUE)); 936 when ADV => 937 PART := (ADV, (CO => QUAL.ADV.CO)); 938 when V => 939 PART := (V, (QUAL.V.CON, KIND.V_KIND)); 940 when others => 941 PART := NULL_PART_ENTRY; 942 end case; 943 944 945 946 UNIQUE_DE.STEMS := (STEM, 947 NULL_STEM_TYPE, NULL_STEM_TYPE, NULL_STEM_TYPE); 948 UNIQUE_DE.PART := PART; 949 --UNIQUE_DE.KIND := KIND; 950 UNIQUE_DE.TRAN := TRAN; 951 UNIQUE_DE.MEAN := MEAN; 952 953-- DICT_IO.SET_INDEX(DICT_FILE(D_K), M); 954-- DICT_IO.WRITE(DICT_FILE(D_K), UNIQUE_DE); 955 956 UNIQUES_DE(M) := UNIQUE_DE; 957 end; 958--@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ 959 960 MNPC := M; 961 962 if (LOWER_CASE(STEM(1)) = 'v') then 963 UNQ('u') := 964 new UNIQUE_ITEM'(STEM, QUAL, KIND, MNPC, UNQ(LOWER_CASE('u'))); 965 elsif (LOWER_CASE(STEM(1)) = 'j') then 966 UNQ('i') := 967 new UNIQUE_ITEM'(STEM, QUAL, KIND, MNPC, UNQ(LOWER_CASE('i'))); 968 else 969 UNQ(LOWER_CASE(STEM(1))) := 970 new UNIQUE_ITEM'(STEM, QUAL, KIND, MNPC, UNQ(LOWER_CASE(STEM(1)))); 971 end if; 972 973 M := M + 1; 974 NUMBER_OF_UNIQUES_ENTRIES := INTEGER(M) - 1; 975 976 end loop; 977 CLOSE(UNIQUES_FILE); 978 PREFACE.SET_COL(33); 979 PREFACE.PUT("-- "); PREFACE.PUT(NUMBER_OF_UNIQUES_ENTRIES, 6); 980 PREFACE.PUT(" entries"); 981 PREFACE.SET_COL(55); PREFACE.PUT_LINE("-- Loaded correctly"); 982 exception 983 when TEXT_IO.NAME_ERROR => 984 PREFACE.PUT_LINE("There is no UNIQUES file"); 985 when others => 986 PREFACE.NEW_LINE; 987 PREFACE.PUT_LINE("LOAD_UNIQUES exception !!!!!!!!!!!!!!!!!!!!!"); 988 PREFACE.PUT_LINE(STEM_LINE(1..LAST)); 989 PREFACE.PUT_LINE(LINE(1..L)); 990 CLOSE(UNIQUES_FILE); 991 PREFACE.SET_COL(33); 992 PREFACE.PUT("-- "); PREFACE.PUT(NUMBER_OF_UNIQUES_ENTRIES, 6); 993 PREFACE.PUT(" entries"); 994 PREFACE.SET_COL(55); PREFACE.PUT_LINE("-- Loaded before error"); 995 --raise; 996 end LOAD_UNIQUES; 997 998 999 1000 1001 1002begin 1003 1004-- PARSE_LINE_IO.DEFAULT_WIDTH := 1005-- MAX_STEM_SIZE + 1 + 1006-- INFLECTION_RECORD_IO.DEFAULT_WIDTH + 1 + 1007-- DICTIONARY_KIND_IO.DEFAULT_WIDTH + 1 + 1008-- MAX_MEANING_SIZE; 1009 1010 1011 PREFIX_LINE_IO.DEFAULT_WIDTH := PART_OF_SPEECH_TYPE_IO.DEFAULT_WIDTH + 1 + 1012 MAX_STEM_SIZE + 1 + 1013 1 + 1 + 1014 PREFIX_ENTRY_IO.DEFAULT_WIDTH + 1 + 1015 MAX_MEANING_SIZE; 1016 SUFFIX_LINE_IO.DEFAULT_WIDTH := PART_OF_SPEECH_TYPE_IO.DEFAULT_WIDTH + 1 + 1017 MAX_STEM_SIZE + 1 + 1018 1 + 1 + 1019 SUFFIX_ENTRY_IO.DEFAULT_WIDTH + 1 + 1020 MAX_MEANING_SIZE; 1021 TACKON_LINE_IO.DEFAULT_WIDTH := PART_OF_SPEECH_TYPE_IO.DEFAULT_WIDTH + 1 + 1022 MAX_STEM_SIZE + 1 + 1023 TACKON_ENTRY_IO.DEFAULT_WIDTH + 1 + 1024 MAX_MEANING_SIZE; 1025 1026 UNIQUE_ENTRY_IO.DEFAULT_WIDTH := MAX_STEM_SIZE + 1 + 1027 INFLECTION_RECORD_IO.DEFAULT_WIDTH + 1 + 1028 TRANSLATION_RECORD_IO.DEFAULT_WIDTH; 1029 1030 1031 1032end LINE_STUFF; 1033