10 ! ----- [LOMASKY.EVE]MRPGRP_EVE_SPELL.BAS ----- ! ----- SPELLING CORRECTION FUNCTION PROGRAM FOR EVE ----- ! ----- Last Change 12/24/92 by Brian Lomasky ----- ! ! ----- Note: The SPELL_DIR:SPELL.DAT general dictionary ----- ! ----- must have W:RE protection and SPELL_DIR:SPELL.EXE ----- ! ----- must have W:E protection. ----- ! FUNCTION LONG BRL_SPELL(LONG SPELL_FUNCTION, STRING SPELL_WORD, & STRING CORRECTED_WORD) OPTION TYPE = EXPLICIT ! FORCE DECLARATIONS %LET %DEBUG = 0% ! 1 IF DEBUG ON, 0 IF OFF ON ERROR GOTO ERROR_ROUTINE ! ENABLE ERROR TRAPPING ! ----- SYSTEM SERVICE ERROR CODES AND FUNCTION VALUES ----- EXTERNAL LONG CONSTANT SS$_NORMAL ! NORMAL STATUS DECLARE WORD CONSTANT TRUE = (1% = 1%) DECLARE WORD CONSTANT FALSE = NOT TRUE ! ----- BASIC ERROR CODES ----- DECLARE WORD CONSTANT BUCKET_LOCKED = 154% DECLARE WORD CONSTANT END_OF_FILE = 11% DECLARE WORD CONSTANT FILE_ATTRS_NOT_MATCHED = 160% DECLARE WORD CONSTANT NO_SUCH_FILE = 5% DECLARE WORD CONSTANT REC_NOT_FOUND = 155% DECLARE WORD CONSTANT RECORD_ATTRS_NOT_MATCHED = 228% DECLARE STRING CONSTANT ERASE_TO_END_OF_LINE = ESC + "[K" DECLARE STRING CONSTANT ERASE_TO_END_OF_SCREEN = ESC + "[J" DECLARE STRING CONSTANT NORMAL_VIDEO = ESC + "[m" DECLARE WORD ALL_UPPERCASE ! TRUE IF WORD IS ALL UPPERCASE DECLARE WORD CORRECTED_WORD_INDEX ! INDEX INTO CORRECTED_WORDS() DECLARE WORD DICT_CHANNEL ! DICTIONARY CHANNEL NUMBER DECLARE WORD DONE_CHECKING_WORD ! TRUE IF DONE CHECKING WORD DECLARE STRING ERROR_LINE ! ERROR LINE DESCRIPTION DECLARE WORD FIRST_CAPITAL ! TRUE IF FIRST LETTER CAPITAL DECLARE STRING FIRST_WORD ! FIRST WORD TO BE PRINTED DECLARE WORD FOUND_MATCH ! TRUE IF FOUND MATCHING WORD DECLARE STRING LAST_WORD ! LAST WORD TO BE PRINTED DECLARE LONG LIB_STATUS ! SYSTEM SERVICE EXIT STATUS DECLARE WORD LOWEST_QUICK_WORD_INDEX ! INDEX OF LOWEST QUICK WORD DECLARE WORD LOWEST_QUICK_WORD_MATCH ! COUNT OF LOWEST QUICK MATCHES DECLARE WORD LOWEST_RECENT_WORD_INDEX ! INDEX OF LOWEST RECENT WORD DECLARE WORD LOWEST_RECENT_WORD_MATCH ! COUNT OF LOWEST RECENT MATCHES DECLARE STRING NUMERIC_EDIT ! EDIT VARIABLE FOR NUMERIC FUNC DECLARE WORD NUMERIC_TEMP ! TEMPORARY FOR NUMERIC FUNCTION DECLARE STRING PRIVATE_DICTIONARY ! OPENED PRIVATE DICTIONARY NAME DECLARE WORD READ_NEXT_DICT_RECORD ! TRUE TO READ NEXT DICT RECORD DECLARE LONG RECORD_COUNTER ! COUNT OF PRINTED WORDS DECLARE WORD TEMP ! TEMPORARY WORD VARIABLE DECLARE LONG TEMP_LONG ! TEMPORARY LONG VARIABLE DECLARE LONG TEMP_LONG2 ! TEMPORARY LONG VARIABLE DECLARE STRING TEMP_STRING ! TEMPORARY STRING VARIABLE DECLARE WORD WORD_LENGTH ! LENGTH OF WORD TO BE CHECKED DECLARE WORD WORD_STATUS ! -1=WORD CORRECTLY SPELLED ! 0=WORD INCORRECTLY SPELLED ! 1=UNKNOWN SPELLING DECLARE STRING WORD_TO_CHECK ! UPPERCASED WORD TO BE CHECKED DECLARE STRING WORD_WITH_APOSTROPHE ! EXTRACTED WORD (INCL ANY ') ! ----- THIS MAP CONTAINS VARIABLES THAT NEED TO BE RETAINED ----- ! ----- WITHIN THE LOCAL PROCESS ADDRESS SPACE, AND NOT GLOBAL ----- ! ----- WITHIN THE SHAREABLE IMAGE, SO THE LINK OPTIONS FILE ----- ! ----- MUST DECLARE THIS MAP NAME AS BEING LCL ----- MAP (MYMAP) & LONG MAX_CHOICES, ! NUMBER OF MEM WORDS & WORD CORRECTED_WORD_TOT, ! CORRECTED WORDS NUMB & WORD OKAY_WORDS_CNTR, ! COUNT OF OKAY WORDS & WORD QUICK_WORD_INDEX, ! QUICK_WORD_STATUS INDX& WORD RECENT_WORD_INDEX, ! RECENT_WORDS() INDEX & WORD QUICK_WORD_COUNTER, ! NUMBER OF QUICK WORDS & ! ----- QUICK_WORD_STATUS( ,0) = COUNT OF MATCHES ----- & ! ----- QUICK_WORD_STATUS( ,1) = -1:CORRECTLY SPELLED & ! ----- 0:INCORRECTLY SPELLED & WORD QUICK_WORD_STATUS(20%, 1%),! QUICK-MATCHED STATUS & WORD RECENT_WORD_COUNTER, ! RECENT WORDS IN MEM & ! ----- RECENT_WORD_STATUS( ,0) = COUNT OF MATCHES & ! ----- RECENT_WORD_STATUS( ,1) = 1:NOT YET VERIFIED, & ! ----- -1:CORRECTLY SPELLED, & ! ----- 0:INCORRECTLY SPELLED & WORD RECENT_WORD_STATUS(30%, 1%),! RECENTLY-FOUND STATUS& ! ----- USER-CORRECTED WORDS ----- & STRING CORRECTED_WORDS(500%, 1%) = 32%, & STRING DICT_WORDS(50%) = 32%, ! DICT SEARCH WORDS & STRING INCORE_WORDS = 442%, ! LIST OF INCORE WORDS & STRING OKAY_WORDS(200%) = 32%, ! WORDS THAT ARE OKAY & STRING QUICK_WORDS(20%) = 32%, ! QUICK-MATCHED WORDS & STRING RECENT_WORDS(30%) = 32% ! RECENTLY-FOUND WORDS MAP (SPL) STRING DICTIONARY_RECORD = 32%! DICTIONARY FILE MAP MAP (SPL) BYTE DICTIONARY_BYTES(31%) ! DICTIONARY FILE MAP ! ----- LOCAL FUNCTION TO CHECK FOR NUMERIC DATA ----- ! ----- (RETURNS TRUE IF PASSED STRING CONTAINS ONLY NUMERIC DATA) ----- DEF WORD NUMERIC(STRING VALUE_TO_TEST) ! ----- REMOVE ANY SPACES ----- NUMERIC_EDIT = EDIT$(VALUE_TO_TEST, 136%) IF LEN(NUMERIC_EDIT) > 0% THEN NUMERIC = TRUE FOR NUMERIC_TEMP = 1% TO LEN(NUMERIC_EDIT) NUMERIC = FALSE IF POS("0123456789", & MID(NUMERIC_EDIT, NUMERIC_TEMP, & 1%), 1%) = 0% NEXT NUMERIC_TEMP ELSE NUMERIC = FALSE END IF END DEF ! ----- LOCAL FUNCTION TO SEARCH THE DICTIONARY FOR MATCHING WORDS ----- DEF LONG SEARCH_THE_DICTIONARY SEARCH_THE_DICTIONARY = 1% ! ASSUME NO WORD CORRECTION WHILE TRUE PRINT NORMAL_VIDEO; ERASE_TO_END_OF_SCREEN PRINT PRINT "Enter starting characters to begin" + & " searching the dictionary with:" PRINT " (Press to start with the" + & " first word)" PRINT " (Or enter E if done searching dictionary) "; WHEN ERROR IN LINPUT FIRST_WORD USE FIRST_WORD = "~%(" CONTINUE END WHEN EXIT DEF IF FIRST_WORD = "~%(" ! ----- UPPERCASE AND DISCARD GARBAGE ----- FIRST_WORD = EDIT$(FIRST_WORD, 38%) FIRST_WORD = " " IF LEN(FIRST_WORD) = 0% FIRST_WORD = LEFT(FIRST_WORD, 32%) EXIT DEF IF FIRST_WORD = "E" PRINT PRINT "Enter ending characters to stop" + & " searching the dictionary at:" PRINT " (Or press to end with" + & " the last word) "; WHEN ERROR IN LINPUT LAST_WORD USE LAST_WORD = "~%(" CONTINUE END WHEN EXIT DEF IF LAST_WORD = "~%(" ! ----- UPPERCASE AND DISCARD GARBAGE ----- LAST_WORD = EDIT$(LAST_WORD, 38%) LAST_WORD = " " IF LEN(LAST_WORD) = 0% RECORD_COUNTER = 0% ! INIT COUNT OF WORDS ! ----- ACCESS BOTH DICTIONARIES ----- FOR DICT_CHANNEL = 3% TO 4% ! ----- SET FLAG SO AS TO SEQUENTIALLY ----- ! ----- READ THE DICTIONARY ----- READ_NEXT_DICT_RECORD = TRUE ITERATE IF RECORD_COUNTER >= 50% ! ----- LOCATE FIRST WORD TO BE DISPLAYED ----- WHEN ERROR IN FIND #DICT_CHANNEL, KEY #0% GE & FIRST_WORD USE IF ERR = BUCKET_LOCKED THEN SLEEP 1% RETRY END IF EXIT HANDLER IF ERR <> & REC_NOT_FOUND AND ERR & <> END_OF_FILE ! ----- SET FLAG SO AS TO SKIP ----- ! ----- READING DICTIONARY ----- READ_NEXT_DICT_RECORD = FALSE CONTINUE END WHEN ! ----- READ NEXT DICTIONARY RECORD ----- WHILE READ_NEXT_DICT_RECORD AND & RECORD_COUNTER < 50% WHEN ERROR IN ! ----- GET NEXT ----- ! ----- DICTIONARY RECORD ----- GET #DICT_CHANNEL USE IF ERR = BUCKET_LOCKED THEN SLEEP 1% RETRY END IF EXIT HANDLER IF ERR <> & END_OF_FILE ! ----- SET FLAG SO AS TO ----- ! ----- EXIT LOOP ----- READ_NEXT_DICT_RECORD = FALSE CONTINUE END WHEN ITERATE IF NOT READ_NEXT_DICT_RECORD ! ----- SKIP IF BLANK RECORD ----- ITERATE IF DICTIONARY_RECORD = " " IF LAST_WORD <> " " AND & DICTIONARY_RECORD > LAST_WORD THEN ! ----- SET FLAG SO AS TO ----- ! ----- EXIT LOOP ----- READ_NEXT_DICT_RECORD = FALSE ITERATE END IF RECORD_COUNTER = RECORD_COUNTER + 1% ! ----- SEE IF LOWERCASE ----- ! ----- CONVERSION REQD ----- IF ALL_UPPERCASE THEN TEMP = 99% ELSE TEMP = -1% END IF WHILE TEMP < & LEN(TRM$(DICTIONARY_RECORD)) & - 1% TEMP = TEMP + 1% ! ----- SEE IF FIRST ----- ! ----- LETTER SHOULD BE ----- ! ----- CAPITALIZED ----- ITERATE IF FIRST_CAPITAL& AND TEMP = 0% ! ----- LOWERCASE LETTER ----- SELECT DICTIONARY_BYTES(TEMP) CASE 65% TO 90% DICTIONARY_BYTES& (TEMP) =& DICTIONARY_BYTES& (TEMP) + 32% END SELECT NEXT ! ----- STORE WORD WITH CASE ----- ! ----- CHANGED (POSSIBLY) ----- DICT_WORDS(RECORD_COUNTER) = & TRM$(DICTIONARY_RECORD) NEXT NEXT DICT_CHANNEL IF RECORD_COUNTER = 0% THEN FIRST_WORD = "first" IF FIRST_WORD = "" LAST_WORD = "last" IF LAST_WORD = "" PRINT PRINT "*** No words found between " + & FIRST_WORD + " and " + LAST_WORD PRINT ITERATE END IF ! ----- DISPLAY ALL OF THE MATCHING WORDS ----- TEMP_LONG = RECORD_COUNTER TEMP = 0% WHILE TEMP < RECORD_COUNTER TEMP = TEMP + 1% IF TEMP < 10% THEN PRINT " " + NUM1$(TEMP) + ") " & + DICT_WORDS(TEMP) ELSE PRINT NUM1$(TEMP) + ") " + & DICT_WORDS(TEMP) END IF NEXT FOUND_MATCH = TRUE WHILE FOUND_MATCH FOUND_MATCH = FALSE ! ----- SEE IF THE WORD CAN BE ----- ! ----- AUTO-CORRECTED FROM LIST ----- PRINT "Press to continue," + & " OR enter the number of the" + & " correct word" WHEN ERROR IN LINPUT TEMP_STRING USE TEMP_STRING = "~%(" CONTINUE END WHEN EXIT DEF IF TEMP_STRING = "~%(" ! ----- UPPERCASE AND DISCARD GARBAGE ----- TEMP_STRING = EDIT$(TEMP_STRING, 38%) ITERATE IF TEMP_STRING = "" FOUND_MATCH = TRUE ITERATE IF LEN(TEMP_STRING) < 1% OR & LEN(TEMP_STRING) > 5% ITERATE IF NOT NUMERIC(TEMP_STRING) TEMP_LONG2 = INTEGER(TEMP_STRING, LONG) ITERATE IF TEMP_LONG2 < 1% OR & TEMP_LONG2 > TEMP_LONG FOUND_MATCH = FALSE ! ----- SET FLAG FOR WORD CORRECTION ----- SEARCH_THE_DICTIONARY = 2% ! ----- RETURN THE CORRECTED WORD ----- ! ----- (AND EXIT WITH AUTO-CORRECT ----- ! ----- STATUS) ----- CORRECTED_WORD = "2" + DICT_WORDS(TEMP_LONG2) EXIT DEF NEXT NEXT END DEF ! ----- DISPLAYS POSSIBLE SPELLINGS FOR A MISSPELLED WORD ----- ! ----- (WORD_WITH_APOSTROPHE) (RETURNS THE NUMBER OF POSSIBLE ----- ! ----- WORD CHOICES) ----- DEF LONG DISPLAY_POSSIBLE_SPELLINGS DISPLAY_POSSIBLE_SPELLINGS = 0% ! ASSUME NO WORD CHOICES RECORD_COUNTER = 0% ! INIT COUNT OF WORDS PRINT PRINT NORMAL_VIDEO WORD_LENGTH = LEN(WORD_TO_CHECK) + 1% WHILE WORD_LENGTH > 0% WORD_LENGTH = WORD_LENGTH - 1% FIRST_WORD = LEFT(WORD_TO_CHECK, WORD_LENGTH) + "A" LAST_WORD = LEFT(WORD_TO_CHECK, WORD_LENGTH) + "Z" ! ----- ACCESS BOTH DICTIONARIES ----- FOR DICT_CHANNEL = 3% TO 4% ! ----- SET FLAG SO AS TO SEQUENTIALLY ----- ! ----- READ THE DICTIONARY ----- READ_NEXT_DICT_RECORD = TRUE ITERATE IF RECORD_COUNTER >= 10% ! ----- LOCATE FIRST WORD TO BE DISPLAYED ----- WHEN ERROR IN FIND #DICT_CHANNEL, KEY #0% GE & FIRST_WORD USE IF ERR = BUCKET_LOCKED THEN SLEEP 1% RETRY END IF EXIT HANDLER IF ERR <> & REC_NOT_FOUND AND ERR & <> END_OF_FILE ! ----- SET FLAG SO AS TO SKIP ----- ! ----- READING DICTIONARY ----- READ_NEXT_DICT_RECORD = FALSE CONTINUE END WHEN ! ----- READ NEXT DICTIONARY RECORD ----- WHILE READ_NEXT_DICT_RECORD AND & RECORD_COUNTER < 10% WHEN ERROR IN ! ----- GET NEXT ----- ! ----- DICTIONARY RECORD ----- GET #DICT_CHANNEL USE IF ERR = BUCKET_LOCKED THEN SLEEP 1% RETRY END IF EXIT HANDLER IF ERR <> & END_OF_FILE ! ----- SET FLAG SO AS TO ----- ! ----- EXIT LOOP ----- READ_NEXT_DICT_RECORD = FALSE CONTINUE END WHEN ITERATE IF NOT READ_NEXT_DICT_RECORD ! ----- SKIP IF BLANK RECORD ----- ITERATE IF DICTIONARY_RECORD = " " IF LAST_WORD <> " " AND & DICTIONARY_RECORD > LAST_WORD THEN ! ----- SET FLAG SO AS TO ----- ! ----- EXIT LOOP ----- READ_NEXT_DICT_RECORD = FALSE ITERATE END IF ! ----- LIMIT SEARCH TO ONE LETTER ----- ! ----- LONGER THAN BAD WORD ----- ITERATE IF LEN(TRM$( & DICTIONARY_RECORD)) > & LEN(WORD_TO_CHECK) + 1% RECORD_COUNTER = RECORD_COUNTER + 1% ! ----- SEE IF LOWERCASE ----- ! ----- CONVERSION REQD ----- IF ALL_UPPERCASE THEN TEMP = 99% ELSE TEMP = -1% END IF WHILE TEMP < & LEN(TRM$(DICTIONARY_RECORD)) & - 1% TEMP = TEMP + 1% ! ----- SEE IF FIRST ----- ! ----- LETTER SHOULD BE ----- ! ----- CAPITALIZED ----- ITERATE IF FIRST_CAPITAL& AND TEMP = 0% ! ----- LOWERCASE LETTER ----- SELECT DICTIONARY_BYTES(TEMP) CASE 65% TO 90% DICTIONARY_BYTES& (TEMP) =& DICTIONARY_BYTES& (TEMP) + 32% END SELECT NEXT ! ----- STORE WORD WITH CASE ----- ! ----- CHANGED (POSSIBLY) ----- ! ----- APPEND "'S" IF IT WAS IN ----- ! ----- THE ORIGINAL WORD ----- IF WORD_WITH_APOSTROPHE = & WORD_TO_CHECK THEN DICT_WORDS( & RECORD_COUNTER) & = TRM$( & DICTIONARY_RECORD) ELSE DICT_WORDS( & RECORD_COUNTER) & = TRM$( & DICTIONARY_RECORD) + & "'s" END IF ! ----- SKIP IF WE FOUND SAME WORD ----- ! ----- THAT WAS PREVIOUSLY FOUND ----- TEMP = 0% TEMP_LONG2 = 0% WHILE TEMP < RECORD_COUNTER - 1% TEMP = TEMP + 1% IF DICT_WORDS(TEMP) = & DICT_WORDS( & RECORD_COUNTER) THEN TEMP = RECORD_COUNTER TEMP_LONG2 = 1% END IF NEXT IF TEMP_LONG2 = 1% THEN RECORD_COUNTER = & RECORD_COUNTER - 1% END IF NEXT NEXT DICT_CHANNEL NEXT EXIT DEF IF RECORD_COUNTER = 0% ! DONE IF NO WORDS FOUND ! ----- RETURN THE NUMBER OF WORD CHOICES ----- DISPLAY_POSSIBLE_SPELLINGS = RECORD_COUNTER ! ----- DISPLAY ALL OF THE WORDS FOUND ----- TEMP = 0% TEMP_LONG = 0% WHILE TEMP < RECORD_COUNTER TEMP = TEMP + 1% TEMP_LONG = TEMP_LONG + 1% IF TEMP_LONG = 1% THEN PRINT ERASE_TO_END_OF_LINE; ELSE PRINT TAB(40%); END IF IF TEMP < 10% THEN PRINT " " + NUM1$(TEMP) + ") " + & DICT_WORDS(TEMP); ELSE PRINT NUM1$(TEMP) + ") " + & DICT_WORDS(TEMP); END IF IF TEMP_LONG = 2% THEN PRINT TEMP_LONG = 0% END IF NEXT PRINT ERASE_TO_END_OF_LINE; IF TEMP_LONG = 1% END DEF ! ----- PROCESS DEPENDING ON THE PASSED FUNCTION CODE ----- ERROR_LINE = "PROCESS SPELL_FUNCTION " + NUM1$(SPELL_FUNCTION) SELECT SPELL_FUNCTION CASE 2%, 3%, 4%, 5%, 7% ! ENTRIES WITH PASSED WORD %IF %DEBUG = 1% %THEN PRINT #5%, "------------------------------" PRINT #5%, ERROR_LINE %END %IF ! ----- STORE LOCAL UPPERCASED WORD TO BE CHECKED ----- WORD_TO_CHECK = EDIT$(SPELL_WORD, 32%) %IF %DEBUG = 1% %THEN PRINT #5%, " CHECK WORD: " + WORD_TO_CHECK %END %IF IF LEN(WORD_TO_CHECK) > 32% THEN PRINT NORMAL_VIDEO; BRL_SPELL = 8% ! EXIT WITH "WORD TOO LONG" STAT EXIT FUNCTION END IF IF LEN(WORD_TO_CHECK) < 1% THEN BRL_SPELL = 1% ! EXIT WITH SUCCESS STATUS EXIT FUNCTION END IF END SELECT ! ----- PROCESS DEPENDING ON THE PASSED FUNCTION CODE ----- SELECT SPELL_FUNCTION CASE 1% ! INIT SPELL AND OPEN DICTS ERROR_LINE = "START SPELL" ! INIT ERROR LINE DESCRIPTION ! ----- STORE THE MOST COMMON WORDS IN AN INCORE STRING ----- INCORE_WORDS = CR+LF+"THE"+CR+LF+"TO"+CR+LF+"IS"+CR+LF+ & "IN"+CR+LF+"OF"+CR+LF+"AND"+CR+LF+"AN"+CR+LF+ & "FOR"+CR+LF+"BE"+CR+LF+"BY"+CR+LF+"OR"+CR+LF+ & "ON"+CR+LF+"THIS"+CR+LF+"IT"+CR+LF+ & "WITH"+CR+LF+"LINE"+CR+LF+"NOW"+CR+LF+ & "NOT"+CR+LF+"YOURS"+CR+LF+"ARE"+CR+LF+ & "ABOUT"+CR+LF+"ACT"+CR+LF+"AFTER"+CR+LF+ & "ALL"+CR+LF+"AT"+CR+LF+"ADD"+CR+LF+ & "ANY"+CR+LF+"AS"+CR+LF+"BUT"+CR+LF+"BY"+CR+LF+ & "CAN"+CR+LF+"COME"+CR+LF+"DID"+CR+LF+ & "DO"+CR+LF+"DONE"+CR+LF+"EACH"+CR+LF+ & "FIRST"+CR+LF+"FROM"+CR+LF+"HAD"+CR+LF+ & "HAS"+CR+LF+"HAVE"+CR+LF+"HE"+CR+LF+ & "HER"+CR+LF+"IF"+CR+LF+"INTO"+CR+LF+ & "LIKE"+CR+LF+"MAN"+CR+LF+"MANY"+CR+LF+ & "MAY"+CR+LF+"MORE"+CR+LF+"ONE"+CR+LF+ & "OUR"+CR+LF+"PAGE"+CR+LF+"SAID"+CR+LF+ & "SET"+CR+LF+"SHE"+CR+LF+"SHOULD"+CR+LF+ & "SOME"+CR+LF+"THAT"+CR+LF+"THEM"+CR+LF+ & "THERE"+CR+LF+"THEY"+CR+LF+"TWO"+CR+LF+ & "US"+CR+LF+"VERY"+CR+LF+"WALK"+CR+LF+ & "WAS"+CR+LF+"WE"+CR+LF+"WERE"+CR+LF+ & "WHAT"+CR+LF+"WHEN"+CR+LF+"WHERE"+CR+LF+ & "WHICH"+CR+LF+"WHILE"+CR+LF+"WHO"+CR+LF+ & "WILL"+CR+LF+"WOULD"+CR+LF+"WITH"+CR+LF+ & "YES"+CR+LF+"YOU"+CR+LF+"YOUR"+CR+LF+ & "A"+CR+LF+"I"+CR+LF ! STORE COMMON WORDS ! ----- OPEN DICTIONARIES ----- ERROR_LINE = "OPEN_DICTIONARIES" ! ----- OPEN GENERAL DICTIONARY ----- OPEN "SPELL_DIR:SPELL.DAT" FOR INPUT AS FILE #3%, & INDEXED FIXED, ACCESS READ, & ALLOW READ, & PRIMARY DICTIONARY_RECORD, & MAP SPL ! ----- OPEN PRIVATE DICTIONARY ----- ! ----- ASSUME DEFAULT PRIVATE DICTIONARY ----- PRIVATE_DICTIONARY = "SPELL.DIC" FOUND_MATCH = TRUE WHILE FOUND_MATCH ERROR_LINE = "OPEN " + PRIVATE_DICTIONARY WHEN ERROR IN OPEN PRIVATE_DICTIONARY & FOR INPUT AS FILE #4%, & INDEXED FIXED, & ACCESS READ, ALLOW MODIFY, & PRIMARY DICTIONARY_RECORD, & MAP SPL ! OPEN PRIVATE DICTIONARY CLOSE #4% ! CLOSE PRIVATE DICTIONARY FOUND_MATCH = FALSE USE SELECT ERR CASE NO_SUCH_FILE SELECT PRIVATE_DICTIONARY CASE "SPELL.DIC" ! ----- TRY SYS$LOGIN ----- ! ----- PRIVATE DICT IF NO ----- ! ----- DEFAULT PRIVATE ----- ! ----- DICT ----- PRIVATE_DICTIONARY = & "SYS$LOGIN:SPELL.DIC" CASE "SYS$LOGIN:SPELL.DIC" ! ----- CREATE NEW PRIVATE ----- ! ----- DICT IF NO PRIVATE ----- ! ----- DICT FOUND ----- PRINT NORMAL_VIDEO; PRINT PRINT "Creating" + & " SPELL.DIC as" & + " your" + & " private dictionary" FOUND_MATCH = FALSE PRIVATE_DICTIONARY = "SPELL.DIC" END SELECT CONTINUE CASE FILE_ATTRS_NOT_MATCHED, & RECORD_ATTRS_NOT_MATCHED ! ----- INVALID [default]SPELL.DIC ----- PRINT NORMAL_VIDEO; PRINT PRINT "ERROR - Invalid " + & PRIVATE_DICTIONARY + & " data file" + BEL PRINT CONTINUE ERROR_EXIT CASE ELSE EXIT HANDLER END SELECT END WHEN NEXT PRIVATE_DICTIONARY = "SPELL.DIC" IF PRIVATE_DICTIONARY = "" ERROR_LINE = "RE-OPEN " + PRIVATE_DICTIONARY OPEN PRIVATE_DICTIONARY AS FILE #4%, & INDEXED FIXED, & ACCESS MODIFY, ALLOW MODIFY, & PRIMARY DICTIONARY_RECORD, & MAP SPL ! OPEN PRIVATE DICTIONARY CORRECTED_WORD_TOT = 0% ! INIT COUNT OF CORRECTED WORDS OKAY_WORDS_CNTR = 0% ! INIT COUNT OF OKAY WORDS QUICK_WORD_COUNTER = 0% ! INIT NUMBER OF QUICK WORDS MAT QUICK_WORD_STATUS = ZER ! INIT ARRAY MAT QUICK_WORDS = NUL$ ! INIT ARRAY RECENT_WORD_COUNTER = 0% ! INIT NUMBER OF RECENT WORDS MAT RECENT_WORD_STATUS = ZER ! INIT ARRAY MAT RECENT_WORDS = NUL$ ! INIT ARRAY %IF %DEBUG = 1% %THEN PRINT "----- Creating EVE_DEBUG.LIS EVE Debug File..." OPEN "EVE_DEBUG.LIS" FOR OUTPUT AS FILE #5%, SEQUENTIAL %END %IF BRL_SPELL = 1% ! EXIT WITH SUCCESS STATUS CASE 2% ! SEARCH DICTS FOR A WORD ERROR_LINE = "START 2" ! INIT ERROR LINE DESCRIPTION ! ----- SKIP ONE-LETTER WORDS ----- IF LEN(WORD_TO_CHECK) = 1% THEN BRL_SPELL = 1% ! EXIT WITH SUCCESS STATUS EXIT FUNCTION END IF WORD_STATUS = 1% ! ASSUME UNKNOWN WORD STATUS QUICK_WORD_INDEX = 0% ! SET QUICK WORD ARRAY INDEX ! ----- REMOVE ANY LEADING SINGLE APOSTROPHE ----- IF LEFT(WORD_TO_CHECK, 1%) = "'" THEN WORD_TO_CHECK = RIGHT(WORD_TO_CHECK, 2%) END IF ! ----- REMOVE ANY TRAILING SINGLE APOSTROPHE ----- IF RIGHT(WORD_TO_CHECK, LEN(WORD_TO_CHECK)) = "'" THEN WORD_TO_CHECK = LEFT(WORD_TO_CHECK, & LEN(WORD_TO_CHECK) - 1%) END IF ! ----- REMOVE ANY TRAILING "'S" ----- WORD_WITH_APOSTROPHE = WORD_TO_CHECK IF RIGHT(WORD_TO_CHECK, LEN(WORD_TO_CHECK) - & 1%) = "'S" THEN WORD_TO_CHECK = LEFT(WORD_TO_CHECK, & LEN(WORD_TO_CHECK) - 2%) END IF ! ----- CHECK THE INCORE LIST OF WORDS (THE INCORE ----- ! ----- ARRAY CONTAINS THE MOST COMMON WORDS) ----- IF POS(INCORE_WORDS, CR+LF + WORD_TO_CHECK + CR+LF, 1%) > 0% THEN BRL_SPELL = 1% ! EXIT WITH SUCCESS STATUS EXIT FUNCTION END IF DONE_CHECKING_WORD = FALSE ! SO LOOP WILL EXECUTE WHILE NOT DONE_CHECKING_WORD ! ----- CHECK FOR MATCHING WORD IN QUICK WORD ----- ! ----- ARRAY (CONTAINS THE LAST TWENTY WORDS ----- ! ----- THAT HAVE BEEN READ IN AND WHICH ARE NOT ----- ! ----- STORED IN THE INCORE ARRAY) ----- ! ----- INIT LOWEST COUNT ----- LOWEST_QUICK_WORD_MATCH = 32767% LOWEST_QUICK_WORD_INDEX = 1% QUICK_WORD_INDEX = 0% WHILE QUICK_WORD_INDEX < QUICK_WORD_COUNTER AND & NOT DONE_CHECKING_WORD QUICK_WORD_INDEX = QUICK_WORD_INDEX + 1% %IF %DEBUG = 1% %THEN PRINT #5%, " CHECK QUICK WORD" & + NUM1$( & QUICK_WORD_INDEX) + & ": " + TRM$( & QUICK_WORDS(QUICK_WORD_INDEX)) %END %IF ! ----- SEE IF THIS IS A PREVIOUSLY-KNOWN ----- ! ----- QUICK WORD ----- IF WORD_TO_CHECK = & TRM$(QUICK_WORDS(QUICK_WORD_INDEX)) THEN ! ----- RECALL PREVIOUS WORD ----- ! ----- STATUS ----- WORD_STATUS = QUICK_WORD_STATUS(& QUICK_WORD_INDEX, 1%) %IF %DEBUG = 1% %THEN PRINT #5%, " WORD_" & + "STATUS=" + & NUM1$(WORD_STATUS) %END %IF ! ----- INCREMENT NUMBER OF WORD ----- ! ----- MATCHES ----- QUICK_WORD_STATUS( & QUICK_WORD_INDEX, 0%) = & QUICK_WORD_STATUS( & QUICK_WORD_INDEX, 0%) + 10% DONE_CHECKING_WORD = TRUE ELSE ! ----- THIS IS NOT A MATCHING ----- ! ----- QUICK WORD ----- ! ----- DECREMENT COUNTER IF NO ----- ! ----- MATCH ----- QUICK_WORD_STATUS( & QUICK_WORD_INDEX, 0%) = & QUICK_WORD_STATUS( & QUICK_WORD_INDEX, 0%) - 1% ! ----- SKIP IF WE DID NOT FOUND A ----- ! ----- LOWER COUNT RATE ----- ITERATE IF QUICK_WORD_STATUS( & QUICK_WORD_INDEX, 0%) & >= LOWEST_QUICK_WORD_MATCH ! ----- STORE NUMBER OF LOWEST ----- ! ----- MATCHES ----- LOWEST_QUICK_WORD_MATCH = & QUICK_WORD_STATUS( & QUICK_WORD_INDEX, 0%) ! ----- STORE INDEX OF ELEMENT ----- ! ----- WITH LOWEST MATCHES ----- LOWEST_QUICK_WORD_INDEX = & QUICK_WORD_INDEX END IF NEXT ! ----- DONE IF WORD WAS FOUND IN QUICK_WORD ARRAY ----- ITERATE IF DONE_CHECKING_WORD IF QUICK_WORD_COUNTER < 20% THEN ! ----- INCR SIZE OF LIST ----- QUICK_WORD_COUNTER = QUICK_WORD_COUNTER + 1% ! ----- STORE ARRAY INDEX TO STORE THIS ----- ! ----- WORD ----- QUICK_WORD_INDEX = QUICK_WORD_COUNTER ELSE ! ----- STORE ARRAY INDEX TO BE REUSED ----- QUICK_WORD_INDEX = LOWEST_QUICK_WORD_INDEX END IF %IF %DEBUG = 1% %THEN PRINT #5%, " ADD TO QUICK WORD" & + NUM1$(QUICK_WORD_INDEX) + & ": " + WORD_TO_CHECK %END %IF ! ----- STORE THIS WORD IN THE QUICK WORD ARRAY ----- QUICK_WORDS(QUICK_WORD_INDEX) = WORD_TO_CHECK ! ----- STORE INITIAL COUNT FOR THIS WORD ----- QUICK_WORD_STATUS(QUICK_WORD_INDEX, 0%) = 10% ! ----- STORE INITIAL SPELLING STATUS FOR THIS ----- ! ----- WORD AS BEING INCORRECTLY SPELLED ----- QUICK_WORD_STATUS(QUICK_WORD_INDEX, 1%) = 0% ! ----- SEARCH THE LIST OF OKAY WORDS (WHICH ARE ----- ! ----- THE WORDS THAT ARE NEW WORDS THAT HAVE ----- ! ----- BEEN SELECTED BY THE USER AS BEING ----- ! ----- CORRECT) ----- TEMP = 0% %IF %DEBUG = 1% %THEN PRINT #5%, " SEARCH OKAY WORDS:" + & " WORD_STATUS=" + NUM1$(WORD_STATUS) %END %IF WHILE TEMP < OKAY_WORDS_CNTR AND WORD_STATUS <> -1% TEMP = TEMP + 1% %IF %DEBUG = 1% %THEN PRINT #5%, " CHECK OKAY WORD" & + NUM1$(OKAY_WORDS_CNTR) + ": " & + TRM$(OKAY_WORDS(TEMP)) %END %IF IF TRM$(OKAY_WORDS(TEMP)) = WORD_TO_CHECK THEN %IF %DEBUG = 1% %THEN PRINT #5%, & " MATCHING OKAY WORD" %END %IF WORD_STATUS = -1% END IF NEXT IF WORD_STATUS = -1% THEN DONE_CHECKING_WORD = TRUE ITERATE END IF ! ----- CHECK THE LAST THIRTY MOST FREQUENT ----- ! ----- WORDS FOR A MATCH ----- FOUND_MATCH = FALSE RECENT_WORD_INDEX = 0% WHILE RECENT_WORD_INDEX < RECENT_WORD_COUNTER & AND NOT FOUND_MATCH RECENT_WORD_INDEX = RECENT_WORD_INDEX + 1% %IF %DEBUG = 1% %THEN PRINT #5%, " CHECK RECENT WORD"& + NUM1$( & RECENT_WORD_INDEX) + & ": " + TRM$( & RECENT_WORDS(RECENT_WORD_INDEX)) %END %IF IF WORD_TO_CHECK = & TRM$(RECENT_WORDS(RECENT_WORD_INDEX)) THEN ! ----- A RECENT WORD MATCH HAS ----- ! ----- BEEN FOUND ----- FOUND_MATCH = TRUE ! ----- INCREMENT NUMBER OF ----- ! ----- MATCHES ----- RECENT_WORD_STATUS( & RECENT_WORD_INDEX, 0%) & = RECENT_WORD_STATUS( & RECENT_WORD_INDEX, 0%) + 1% ! ----- CHECK STATUS OF THIS WORD ----- SELECT RECENT_WORD_STATUS( & RECENT_WORD_INDEX, 1%) CASE -1% WORD_STATUS = -1% DONE_CHECKING_WORD = TRUE CASE 0% WORD_STATUS = 0% DONE_CHECKING_WORD = TRUE END SELECT %IF %DEBUG = 1% %THEN PRINT #5%, " MATCH" +& " - WORD_" + & "STATUS=" + & NUM1$(WORD_STATUS) %END %IF END IF NEXT ! ----- DONE IF WORD WAS FOUND IN RECENT_WORDS ----- ! ----- ARRAY ----- ITERATE IF DONE_CHECKING_WORD IF NOT FOUND_MATCH THEN ! ----- NO MATCHING RECENT WORD HAS BEEN ----- ! ----- FOUND ----- IF RECENT_WORD_COUNTER < 30% THEN ! ----- ADD THIS WORD TO THE END ----- ! ----- OF THE ARRAY ----- RECENT_WORD_COUNTER = & RECENT_WORD_COUNTER + 1% ! ----- STORE ARRAY INDEX TO STORE ----- ! ----- THIS RECENT WORD ----- RECENT_WORD_INDEX = RECENT_WORD_COUNTER ELSE ! ----- FIND LOCATION OF LEAST ----- ! ----- MATCHED WORD IN ARRAY ----- LOWEST_RECENT_WORD_MATCH = 32767% FOR RECENT_WORD_INDEX = 1% TO & RECENT_WORD_COUNTER ITERATE IF & RECENT_WORD_STATUS( & RECENT_WORD_INDEX, & 0%) >= & LOWEST_RECENT_WORD_MATCH LOWEST_RECENT_WORD_MATCH& = RECENT_WORD_STATUS & (RECENT_WORD_INDEX, 0%) LOWEST_RECENT_WORD_INDEX& = RECENT_WORD_INDEX NEXT RECENT_WORD_INDEX RECENT_WORD_INDEX = & LOWEST_RECENT_WORD_INDEX END IF %IF %DEBUG = 1% %THEN PRINT #5%, " ADD TO RECENT" + & " WORD" + NUM1$( & RECENT_WORD_INDEX) + & ": " + WORD_TO_CHECK %END %IF ! ----- STORE THIS WORD IN THE LOCATION ----- ! ----- OF THE LEAST MATCHED WORD ----- RECENT_WORDS(RECENT_WORD_INDEX) = & WORD_TO_CHECK RECENT_WORD_STATUS(RECENT_WORD_INDEX, & 0%) = 1%! INIT MATCH COUNTER ! ----- STORE 1 IN THE STATUS FIELD TO ----- ! ----- INDICATE THAT THIS WORD HAS NOT ----- ! ----- YET BEEN CHECKED IN THE DICTIONARY ----- RECENT_WORD_STATUS(RECENT_WORD_INDEX, 1%) = 1% END IF ! ----- CHECK GENERAL DICTIONARY FOR THIS WORD ----- ! ----- (UNLESS WORD IS TOO LONG) ----- %IF %DEBUG = 1% %THEN PRINT #5%, " CHECK DICTIONARY" %END %IF IF LEN(WORD_TO_CHECK) <= 32% THEN ERROR_LINE = "CHECK DICT" WHEN ERROR IN GET #3%, KEY #0% GE WORD_TO_CHECK IF WORD_TO_CHECK = & DICTIONARY_RECORD THEN WORD_STATUS = -1% END IF USE IF ERR = BUCKET_LOCKED THEN SLEEP 1% RETRY END IF EXIT HANDLER IF ERR <> & END_OF_FILE AND ERR <> & REC_NOT_FOUND CONTINUE END WHEN IF WORD_STATUS <> -1% THEN ! ----- CHECK PRIVATE DICTIONARY ----- ! ----- IF NOT IN GENERAL ----- ! ----- DICTIONARY ----- ERROR_LINE = "CHECK PRIVATE DICT" WHEN ERROR IN GET #4%, KEY #0% GE & WORD_TO_CHECK IF WORD_TO_CHECK = & DICTIONARY_RECORD THEN WORD_STATUS = -1% END IF USE IF ERR = BUCKET_LOCKED THEN SLEEP 1% RETRY END IF EXIT HANDLER IF ERR <> & END_OF_FILE AND & ERR <> REC_NOT_FOUND CONTINUE END WHEN END IF END IF ! ----- IF THIS RECENT WORD HAS AN UNKNOWN ----- ! ----- SPELLING STATUS, STORE THE STATUS OF THIS ----- ! ----- RECENT WORD AFTER CHECKING THE DICTIONARY ----- ! ----- FILES ----- IF RECENT_WORD_STATUS(RECENT_WORD_INDEX, 1%) = 1% THEN %IF %DEBUG = 1% %THEN PRINT #5%, & " STORE STATUS OF RECENT WORD" %END %IF RECENT_WORD_STATUS(RECENT_WORD_INDEX, 1%) = -1% END IF ! ----- SET FLAG SO AS TO EXIT LOOP ----- DONE_CHECKING_WORD = TRUE ERROR_LINE = "DONE CHECKING WORD" NEXT ! ----- DONE WITH ALL SEARCHING FOR THIS WORD ----- ! ----- SEE IF WORD IS CORRECTLY SPELLED ----- ERROR_LINE = "SEE IF CORR" IF WORD_STATUS = -1% THEN %IF %DEBUG = 1% %THEN PRINT #5%, " ** WORD IS CORRECTLY SPELLED **" %END %IF ! ----- STORE THE CORRECT SPELLING STATUS OF ----- ! ----- THIS QUICK WORD ----- QUICK_WORD_STATUS(QUICK_WORD_INDEX, 1%) = -1% BRL_SPELL = 1% ! EXIT WITH SUCCESS STATUS EXIT FUNCTION END IF ! ----- CHECK TO SEE IF THIS MISPELLED WORD HAS BEEN ----- ! ----- PREVIOUSLY CORRECTED BY THE USER ----- %IF %DEBUG = 1% %THEN PRINT #5%, " @@@@@ WORD IS INCORRECTLY SPELLED @@@@@" %END %IF FOUND_MATCH = FALSE CORRECTED_WORD_INDEX = 0% WHILE CORRECTED_WORD_INDEX < CORRECTED_WORD_TOT CORRECTED_WORD_INDEX = CORRECTED_WORD_INDEX + 1% ! ----- IF WORD WAS PREVIOUSLY CORRECTED: ----- IF TRM$(CORRECTED_WORDS(CORRECTED_WORD_INDEX, & 0%)) = WORD_WITH_APOSTROPHE THEN FOUND_MATCH = TRUE END IF NEXT IF FOUND_MATCH THEN ! ----- STORE THE UNKNOWN SPELLING STATUS OF THIS ----- ! ----- QUICK WORD SO THAT WE WILL KEEP CORRECTING ----- ! ----- IT ----- QUICK_WORD_STATUS(QUICK_WORD_INDEX, 1%) = 1% ! ----- AUTOMATICALLY CORRECT IT ----- ! ----- (AND EXIT WITH AUTO-CORRECT STATUS) ----- BRL_SPELL = 2% ! EXIT WITH AUTO-CORRECT STATUS CORRECTED_WORD = "2" + TRM$(CORRECTED_WORDS( & CORRECTED_WORD_INDEX, 1%)) EXIT FUNCTION END IF ! ----- CHECK IF BAD WORD IS ALL CAPITALS, ALL LOWERCASE, ----- ! ----- ONLY FIRST CAPITALIZED, OR MIXED ----- ALL_UPPERCASE = TRUE FIRST_CAPITAL = FALSE ! ----- SCAN ENTIRE BAD WORD (ORIGINAL-CASE) ----- FOR TEMP = 1% TO LEN(SPELL_WORD) SELECT MID(SPELL_WORD, TEMP, 1%) CASE "A" TO "Z" IF TEMP = 1% THEN FIRST_CAPITAL = TRUE ELSE FIRST_CAPITAL = FALSE END IF CASE "a" TO "z" ALL_UPPERCASE = FALSE END SELECT NEXT TEMP MAX_CHOICES = DISPLAY_POSSIBLE_SPELLINGS BRL_SPELL = 0% ! EXIT WITH ERROR STATUS CASE 3% ! LEAVE AND STOP ASKING ! ----- ADD THIS WORD TO THE LIST OF THE OKAY WORDS ----- IF OKAY_WORDS_CNTR < 200% THEN OKAY_WORDS_CNTR = OKAY_WORDS_CNTR + 1% OKAY_WORDS(OKAY_WORDS_CNTR) = WORD_TO_CHECK %IF %DEBUG = 1% %THEN PRINT #5%, " STORE " + WORD_TO_CHECK & + " IN OKAY_WORDS(" + & NUM1$(OKAY_WORDS_CNTR) + ")" %END %IF END IF ! ----- STORE THE "CORRECT" STATUS OF THIS QUICK WORD ----- %IF %DEBUG = 1% %THEN PRINT #5%, " UPDATE STATUS OF QUICK WORD " + & NUM1$(QUICK_WORD_INDEX) + " TO 'CORRECT'" %END %IF QUICK_WORD_STATUS(QUICK_WORD_INDEX, 1%) = -1% BRL_SPELL = 1% ! EXIT WITH SUCCESS STATUS CASE 4% ! LEAVE, STOP ASKING, ADD PRIV ! ----- ADD THIS WORD TO THE LIST OF THE OKAY WORDS ----- IF OKAY_WORDS_CNTR < 200% THEN OKAY_WORDS_CNTR = OKAY_WORDS_CNTR + 1% OKAY_WORDS(OKAY_WORDS_CNTR) = WORD_TO_CHECK %IF %DEBUG = 1% %THEN PRINT #5%, " STORE " + WORD_TO_CHECK & + " IN OKAY_WORDS(" + & NUM1$(OKAY_WORDS_CNTR) + ")" %END %IF END IF ! ----- STORE THE "CORRECT" STATUS OF THIS QUICK WORD ----- %IF %DEBUG = 1% %THEN PRINT #5%, " UPDATE STATUS OF QUICK WORD " + & NUM1$(QUICK_WORD_INDEX) + " TO 'CORRECT'" %END %IF QUICK_WORD_STATUS(QUICK_WORD_INDEX, 1%) = -1% ! ----- STORE WORD IN PRIVATE DICTIONARY ----- IF LEN(WORD_TO_CHECK) < 33% THEN ! ----- MOVE THE WORD TO THE MAP ----- DICTIONARY_RECORD = WORD_TO_CHECK ! ----- STORE RECENT WORD STATUS AS BEING ----- ! ----- CORRECTLY SPELLED ----- %IF %DEBUG = 1% %THEN PRINT #5%, " UPDATE STATUS OF RECENT" & + " WORD " + & NUM1$(RECENT_WORD_INDEX) + & " TO 'CORRECT'" %END %IF RECENT_WORD_STATUS(RECENT_WORD_INDEX, 1%) = -1% PUT #4% ! STORE WORD IN PRIVATE DICT END IF BRL_SPELL = 1% ! EXIT WITH SUCCESS STATUS CASE 5% ! SEARCH RANGE OF SPELLINGS BRL_SPELL = SEARCH_THE_DICTIONARY CASE 6% ! RETURN A WORD FROM MAX_CHOICES ! ----- SEE IF VALID NUMERIC WORD CHOICE ----- IF NOT NUMERIC(SPELL_WORD) THEN BRL_SPELL = 7% ! EXIT WITH ERROR STATUS CORRECTED_WORD = "0" ! EXIT WITH ERROR STATUS EXIT FUNCTION END IF IF LEN(SPELL_WORD) > 4% THEN BRL_SPELL = 4% ! EXIT WITH ERROR STATUS CORRECTED_WORD = "0" ! EXIT WITH ERROR STATUS EXIT FUNCTION END IF IF MAX_CHOICES = 0% THEN BRL_SPELL = 5% ! EXIT WITH ERROR STATUS CORRECTED_WORD = "0" ! EXIT WITH ERROR STATUS EXIT FUNCTION END IF TEMP = INTEGER(SPELL_WORD, WORD)! GET MAX_CHOICES INDEX IF TEMP < 1% OR TEMP > MAX_CHOICES THEN BRL_SPELL = 6% ! EXIT WITH ERROR STATUS CORRECTED_WORD = "0" ! EXIT WITH ERROR STATUS EXIT FUNCTION END IF ! ----- RETURN THE CORRECTED WORD (EXIT WITH AUTO-CORRECT ----- ! ----- STATUS) ----- BRL_SPELL = 2% ! EXIT WITH AUTO-CORRECT STATUS CORRECTED_WORD = "2" + DICT_WORDS(TEMP) CASE 7% ! ADD TO LIST OF CORRECT WORDS ! ----- STORE UP TO 500 CORRECT WORDS ----- IF CORRECTED_WORD_TOT < 500% THEN CORRECTED_WORD_TOT = CORRECTED_WORD_TOT + 1% CORRECTED_WORDS(CORRECTED_WORD_TOT, 0%) = & WORD_WITH_APOSTROPHE CORRECTED_WORDS(CORRECTED_WORD_TOT, 1%) = WORD_TO_CHECK END IF BRL_SPELL = 1% ! EXIT WITH SUCCESS STATUS CASE ELSE ! INVALID FUNCTION PRINT NORMAL_VIDEO; PRINT "ERROR - Invalid function code: " + & NUM1$(SPELL_FUNCTION) + BEL BRL_SPELL = 3% ! EXIT WITH FATAL ERROR STATUS END SELECT EXIT FUNCTION ERROR_ROUTINE: ! ----- ERROR-HANDLING ROUTINE ----- TEMP_STRING = ERT$(ERR) CLOSE #TEMP FOR TEMP = 1% TO 12% ! CLOSE ALL OPEN FILES PRINT PRINT NORMAL_VIDEO; PRINT "UNEXPECTED ERROR " + NUM1$(ERR) + " OCCURRED" + BEL + BEL + BEL PRINT "AFTER ERROR_LINE: " + ERROR_LINE + ESC + "[K" PRINT TEMP_STRING PRINT "*** PROGRAM TERMINATED ***" BRL_SPELL = 3% ! EXIT WITH FATAL ERROR STATUS RESUME ERROR_EXIT ! STOP PROGRAM ERROR_EXIT: END FUNCTION