[<<Previous Entry]
[^^Up^^]
[Next Entry>>]
[Menu]
[About The Guide]
ASTRTOOL.INT
{ ---------------------------------------------------------------- }
{ String - Tools }
{ ---------------------------------------------------------------- }
{ Grundroutinen zur Zeichen- und Stringbehandlung. }
{ Grunds.tzlich kann man bei den Routinen verschiedene Gruppen }
{ unterscheiden: }
{ - Zeichenwiederholung (Chars, Spaces, Line, Lineal) }
{ - Stringumwandlung (Up-/Down-Ch, -String, -Str) }
{ - Suchfunktionen (IsInside, Replace) }
{ - Formatierungsfunktionen (Trim, RTrim, LTrim, ATrim, Format, }
{ LFormat, RFormat, ZFormat, BFormat) }
{ - Zahlenumwandlunsroutinen (LongIntToString) }
{ - Stringvergleichsfunktionen (StrComp, CompSoundex, Soundex) }
{ ---------------------------------------------------------------- }
{ Achtung: Dieses Modul verwEndet die Option einer Initialisierung }
{ der Unit, was bei der Verwendung von Overlays ber.cksichtigt }
{ werden mu. - vergleiche Dokumentation Turbo-Pascal ! }
{ ---------------------------------------------------------------- }
{ (c) Aurora featuring Markus SCHWAIGER 1991 - 1992 }
{ (c) NanoSoft featuring Nov, Nero 1992 }
{ ---------------------------------------------------------------- }
UNIT AStrTool;
INTERFACE
{ ---------------------------------------------------------------- }
{ Liefert eine Zeichenkette der L.nge Count, bestehend aus Zeichen }
{ C, zur.ck. }
{ ---------------------------------------------------------------- }
FUNCTION Chars (C : CHAR; Count : INTEGER) : STRING;
{ ---------------------------------------------------------------- }
{ Gibt einen aus Count Leerzeichen bestehEnden String zur.ck. }
{ ---------------------------------------------------------------- }
FUNCTION Spaces (Count : INTEGER) : STRING;
{ ---------------------------------------------------------------- }
{ Gibt eine Linie der L.nge Count zur.ck, d.h., eine Folge von }
{ "-" - Zeichen (#196). }
{ ---------------------------------------------------------------- }
FUNCTION LINE (Count : INTEGER) : STRING;
{ ---------------------------------------------------------------- }
{ Gibt eine "123 ... 90123 ..." - Folge der L.nge Count zur.ck; }
{ f.r Kontrollzwecke beispielsweise bei der Druckeransteuerung. }
{ ---------------------------------------------------------------- }
FUNCTION Lineal (Count : INTEGER) : STRING;
{ ---------------------------------------------------------------- }
{ Wandelt einen einzelnen Buchstaben in Kleinschreibung um, wobei }
{ auch die deutschen Umlaute ber.cksichtigt werden. }
{ Und au.erdem zeige ich bei der Gelegenheit, da. ich auch ein }
{ wenig Assembler kann ... }
{ ---------------------------------------------------------------- }
FUNCTION DownCase (C : CHAR) : CHAR;
{ ---------------------------------------------------------------- }
{ ... und das verwEnden wir dann gleich einmal f.r die Umwandlung }
{ eines ganzen Strings. Als erstes wandeln wir gleich die Quelle }
{ selbst um. }
{ ---------------------------------------------------------------- }
PROCEDURE DownString (VAR S : STRING);
{ ---------------------------------------------------------------- }
{ ... und hier lassen wir die Quelle unber.hrt und geben den umge- }
{ wandelten String als Funktionswert zur.ck. }
{ ---------------------------------------------------------------- }
FUNCTION DownStr (S : STRING) : STRING;
{ ---------------------------------------------------------------- }
{ Wandelt einen einzelnen Buchstaben in Kleinschreibung um, wobei }
{ auch die deutschen Umlaute ber.cksichtigt werden. }
{ Und au.erdem zeige ich bei der Gelegenheit, da. ich auch ein }
{ wenig Assembler kann ... }
{ Und wieso nicht Turbo (UPCASE) ? Weil das kein Deutsch versteht. }
{ ---------------------------------------------------------------- }
FUNCTION UpperCase (C : CHAR) : CHAR;
{ ---------------------------------------------------------------- }
{ ... und das gleiche Spielchen noch einmal f.r die Umwandlung in }
{ Gro.buchstaben. Als erstes wandeln wir wieder gleich die Quelle }
{ selbst um. }
{ ---------------------------------------------------------------- }
PROCEDURE UpString (VAR S : STRING);
{ ---------------------------------------------------------------- }
{ ... und hier lassen wir die Quelle unber.hrt und geben den umge- }
{ wandelten String als Funktionswert zur.ck. }
{ ---------------------------------------------------------------- }
FUNCTION UpStr (S : STRING) : STRING;
{ ---------------------------------------------------------------- }
{ Pr.ft, ob die Zeichenkette Item in Target enthalten ist; wenn }
{ IgnoreCase True ist, so wird nicht zwischen Gro.- und Klein- }
{ schreibung unterschieden. }
{ Wenn in Item Wildcards entsprechend der globalen Variable }
{ "WildCard" enthalten sind, so werden diese ber.cksichtigt. }
{ Zur.ckgegeben wird True, wenn der String gefunden wurde; False, }
{ wenn nicht. }
{ ---------------------------------------------------------------- }
FUNCTION IsInside (Item, Target : STRING; IgnoreCase : BOOLEAN) :
BOOLEAN;
{ ---------------------------------------------------------------- }
{ Ersetzt nach "Skipped" Auslassungen die folgenden "Replacements" }
{ Vorkommen von "OldPart" in "Line" durch "NewPart"; wenn "Ignore- }
{ Case" True ist, so wird Gro.- und Kleinschreibung ignoriert. }
{ ---------------------------------------------------------------- }
PROCEDURE Replace (OldPart, NewPart : STRING; VAR LINE : STRING;
IgnoreCase : BOOLEAN; Replacements, Skipped : INTEGER);
{ ---------------------------------------------------------------- }
{ Konstanten f.r die "Trim"-Funktion (siehe dort): Vom Anfang }
{ beginnen oder vom Ende ? }
{ ---------------------------------------------------------------- }
CONST
FromStart = 1;
FromEnd = 2;
{ ---------------------------------------------------------------- }
{ Entfernt alle Leerzeichen vom Ende (Mode = FromEnd) bzw. vom }
{ Anfang (Mode = FromStart). }
{ ---------------------------------------------------------------- }
FUNCTION Trim (LINE : STRING; Mode : BYTE) : STRING;
{ ---------------------------------------------------------------- }
{ Schneidet alle folgenden Leerzeichen ab. }
{ ---------------------------------------------------------------- }
FUNCTION RTrim (LINE : STRING) : STRING;
{ ---------------------------------------------------------------- }
{ Schneidet alle f.hrEnden Leerzeichen ab. }
{ ---------------------------------------------------------------- }
FUNCTION LTrim (LINE : STRING) : STRING;
{ ---------------------------------------------------------------- }
{ Schneidet alle folgenden und f.hrEnden Leerzeichen ab. }
{ ---------------------------------------------------------------- }
FUNCTION ATrim (LINE : STRING) : STRING;
{ ---------------------------------------------------------------- }
{ Entfernt f.hrEnde, folgende und "innenliegEnde" Spaces. }
{ ---------------------------------------------------------------- }
FUNCTION Pack (LINE : STRING) : STRING;
{ ---------------------------------------------------------------- }
{ Wie LFormat. }
{ ---------------------------------------------------------------- }
FUNCTION Format (LINE : STRING; Laenge : BYTE) : STRING;
{ ---------------------------------------------------------------- }
{ Linksb.ndig: Formatiert den String Line durch Anh.ngen von Leer- }
{ zeichen auf die angegebene L.nge. }
{ ---------------------------------------------------------------- }
FUNCTION LFormat (LINE : STRING; Laenge : BYTE) : STRING;
{ ---------------------------------------------------------------- }
{ Formatiert den String Str auf die L.nge len. }
{ Werden zuviele Zeichen .bergeben, wird der Rest abgeschnitten, }
{ bei zuwenigen wird der Rest mit Spaces aufgef.llt. }
{ Diese Prozedur ist der Funktion lFormat von Aurora in Bezug }
{ auf das Ergebnis gleich, nur ist IdxTrim hinsichtlich }
{ Laufzeit, Speicherbedarf pro Aufruf um einiges .berlegen. }
{ ---------------------------------------------------------------- }
PROCEDURE NSLFormat (VAR STR : STRING;Len : BYTE);
{ ---------------------------------------------------------------- }
{ Rechtsb.ndig: Formatiert den String Line durch Voranstellen von }
{ Leerzeichen auf die angegebene L.nge. }
{ ---------------------------------------------------------------- }
FUNCTION RFormat (LINE : STRING; Laenge : BYTE) : STRING;
{ ---------------------------------------------------------------- }
{ Zentriert: Formatiert den String Line durch Anh.ngen und Voran- }
{ stellen von Leerzeichen auf die angegebene L.nge. }
{ ---------------------------------------------------------------- }
FUNCTION ZFormat (LINE : STRING; Laenge : BYTE) : STRING;
{ ---------------------------------------------------------------- }
{ Blocksatz: Formatiert den String Line durch Einf.gen von Leer- }
{ zeichen auf die angegebene L.nge. }
{ ---------------------------------------------------------------- }
FUNCTION bfOrmat (LINE : STRING; Laenge : BYTE) : STRING;
{ ---------------------------------------------------------------- }
{ Wandelt den LongInt-Wert Value in einen String der L.nge Width }
{ um; wobei das Zahlensystem (von 2 wie bin.r bis 16 wie Hex) }
{ durch Base angegeben wird. }
{ ---------------------------------------------------------------- }
FUNCTION LongIntToString (Value : LONGINT; Width,
Base : INTEGER) : STRING;
This page created by ng2html v1.05, the Norton guide to HTML conversion utility.
Written by Dave Pearson