Weitere Informationen zum SpellChecker
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(Bevor Sie diesen Text Lesen, sollten Sie den Text "Vorüberlegungen"
gelesen haben)

Die folgenden Bemerkungen sind für die Benutzung des SpellCheckers
nicht notwendig. Es soll hier nur die Funktionsweise grob skizziert
werden um anderen Programmierern eine Erweiterung oder Verbesserung
des Programmes zu ermöglichen. Insbesondere denke ich dabei daran, daß
vielleicht mal jemand einen Editor oder eine Textverarbeitung
entwickelt und dann diesen Spellchecker in abgewandelter Form dort
einbaut.

Das Modul Lexi.def enthält folgende Konstanten:

MinWordLength=2
MaxWordLength=14
MinFracSizeS=4
MinFracSizeI=6
MinLexSize=10000
MoreWords= 1000

MinLexSize gibt die Standardgröße des Lexikons an. Beim Starten des
Programmes wird also für 10000 Worte Speicherplatz alloziert. Ist
dieser Platz voll, wird das Lexikon auf dem Device T:
zwischengespeichert und es wird ein um MoreWords größerer
Speicherplatz angefordert. Die übrigen Konstanten werden im folgenden
Text erläutert.

Datenstrukturen und Zerlegung von Worten
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Das Lexikon wird im Rechner als Array Of Word dargestellt, wobei
Word=Array[0..MaxWordLength] ist. Dieses Array wird bereits beim
Aufbau sortiert, so daß die Worte in ihm durch binäre Suche recht
schnell gefunden werden können. Die Konstante MaxWordLength habe ich
auf 14 gesetzt. Außerdem habe ich eine Konstante MinWordLength=2
eingeführt. Worte mit einer Länge < MinWordLength werden nicht ins
Lexikon aufgenommen. Ins Lexikon können also nur Worte aufgenommen
werden, die nicht länger als 14 Buchstaben sind. Worte, die länger
sind, bestehen in der Regel aus mehreren Komponenten, wie z.B.
ComputerBuchVerlag und können in ihre Komponenten zerlegt werden,
bevor sie ins Lexikon aufgenommen werden. Die Zerlegung geschieht
folgendermaßen: Ich kopiere von einem Wort die linke und die rechte
Seite, wobei diese Seite maximal MaxWordLength und mindestens
MaxFracSizeS Buchstaben haben muß. Dann wird nach der linken und
rechten Seite in Lexikon gesucht. Wird eine Seite gefunden, so wird
diese von dem ursprünglichen Wort abgespalten und mit dem restlichen
Wort in gleicher Weise fortgefahren. Wird auf diese Weise die Länge
des Wortes auf null reduziert, so ist das Wort also vollständig in
Komponenten zerlegt worden. Bleibt aber ein Rest übrig, und ist dieser
Rest größer als MaxFracSizeI so wird der Rest als eigenständiges Wort
angesehen und ins Lexikon übernommen. Beispiel: Die Worte "Computer"
und "Buch" seien im Lexikon schon vorhanden. Soll nun das Wort
Computerbuchverlag untersucht werden, so wird zuerst einmal Computer
abgespalten. Da der erste Buchstabe von "Computerbuchverlag" groß war,
muß der Rest, also buchverlag in Buchverlag umgewandelt werden. Dann
wird Buch abgespalten und es bleibt Verlag übrig. Das Wort ist im
Lexikon nicht vorhanden und wird einsortiert. Probleme könnte es
geben, wenn z.B. das Wort "alten" schon in Lexikon vorhanden ist und
nun "enthalten" untersucht werden soll. Würde man "alten" abspalten,
so bliebe enth übrig und würde als gültiges Wort ins Lexikon
übernommen. Um solchen Unsinn weitgehend zu vermeiden, habe ich die
Konstanten MinFracSizeS und MinFracSizeI eingeführt. Es werden nur
Komponenten abgespalten, die mindestens MinFracSizeS lang sind, und
außerdem muß der verbleibende Rest mindestens noch MinFracSizeI
Buchstaben enthalten, um ins Lexikon eingefügt zu werden. Umso größer
man diese beiden Konstanten macht, umso weniger Müll wird ins Lexikon
aufgenommen. Macht man sie aber zu groß, so werden viele Worte
überhaupt nicht mehr getrennt. Sinnvoll erscheint mir (für deutsche
Texte) MinFracSizeS=4 und MinFracSizeI=6. Eventuell kann man diese
Konstanten für andere Sprachen etwas ändern.

Generierung des Lexikons:
~~~~~~~~~~~~~~~~~~~~~~~~~
Die Generierung ist im Prinzip sehr einfach: Aus dem Quelltext wird
Wort für Wort von der Prozedur ReadWord gelesen, dann eventuell in
Komponenten zerlegt und ins Lexikon einsortiert. Dabei werden Worte,
die einen Punkt oder einen anderen Zeichen, das nachfolgende
Großschreibung erzwingt, ignoriert, da die Worte in ihrer natürlichen
Schreibweise ins Lexikon übernommen werden sollen.

Überprüfung von Texten
~~~~~~~~~~~~~~~~~~~~~~
Hierbei wird ebenfalls der Text wortweise gelesen, alles was kein Wort
darstellt wird ignoriert. Wird ein gelesenes Wort nicht im Lexikon
gefunden, so muß der Mensch entscheiden, ob es richtig geschrieben
ist. (Ein Wort besteht aus Buchstaben. Was ein Buchstabe ist,
entscheidet die Prozedur Letter(). Dabei werden auch sämtliche Umlaute
als Buchstaben anerkannt, und auch das Hochkomma in Worten wie "can't"
oder "I'm" wird als Buchstabe betrachtet!)

Steuerzeichen
~~~~~~~~~~~~~
Probleme kann es geben, wenn Steuerzeichen mit Worten verwechselt
werden können. Benutzt beispielsweise eine Textverarbeitung die Sequenz
"#FETT#" um im Text auf Fettschrift umzuschalten, so würde die
derzeitige Version der Prozedur ReadWord das Steuerzeichen nicht
erkennen und das Wort FETT als normales Wort zurückgeben. Für so eine
Textverarbeitung müßte man die Prozedur ReadWord also entsprechend
anpassen. Vermutlich werden aber die meisten
Textverarbeitungsprogramme Steuerzeichen durch undruckbare Zeichen
darstellen, so daß sich keine Probleme ergeben sollten. (Die
Amiga-spezifischen Steuersequenzen in ASCII-Texten, welche z.B. die
Zeichenfarbe umschalten, werden von der Prozedur ReadWord erkannt und
überlesen).


Stefan Salewski, 4.3.90


Noch etwas zu der Bearbeitung von Files von Textverarbeitungsprogrammen
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Textverarbeitungen speichern ihre Texte in der Regel nicht als
ASCII-Text ab, sondern fügen einige Steuerzeichen ein. Dabei kann es
zu Problemen kommen, wenn Steuerzeichen mitten in einem Wort stehen.
Das ist z.B. der Fall, wenn die Textverarbeitung Worte automatisch
trennt. Die Trennung besteht dann oft nicht einfach aus einem '-' und
einen EOL, wie in ASCII-Texten, sondern aus mehreren anderen Zeichen.
Wenn man nun solche Texte zur Generierung eines Lexikons benutzt, kann
es sein, daß die beiden Hälften eines getrennten Wortes als einzelne
Worte ins Lexikon aufgenommen werden! Die normale Trennung, die aus
einem '-' und einem EOL besteht, wird von der Prozedur ReadWord
erkannt und das getrennte Wort wird dann ignoriert. Das gleiche gilt
auch für Trennungen, die mit CHAR(4) beginnen. ( Ich glaube, damit
trennt BeckerText Worte)

Weitere Probleme kann es geben, wenn Sie die Zeilenlänge eines Textes
verändern. Einige Textverarbeitungen speichern ihre Texte mit
irgendwelchen Füllzeichen ab, so daß alle Zeilen gleich lang sind.
Wird die Zeilenlänge nun verändert, so wird die Textverarbeitung den
Text nicht mehr richtig einlesen. Abhilfe: Entweder speichern Sie den
Text als Ascii-File ab, bearbeiten es dann mit dem SpellChecker und
lesen es dann wieder in die Textverarbeitung ein, oder sie speichern
es irgendwo (RAM: ) in beliebiger Form zwischen, lassen es dann vom
SpellChecker durchsehen und notieren sich alle gefundenen Fehler. Dann
löschen sie diesen zwischengespeicherten Text und korrigieren die
Fehler in ihrer Textverarbeitung.

Stefan Salewski, 12.3.90