[<<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