[<<Previous Entry]
[^^Up^^]
[Next Entry>>]
[Menu]
[About The Guide]
{ ---------------------------------------------------------------- }
{ Konvertiert alle Zeichen von Str in Gro.buchstaben und gibt den }
{ neuen String zur.ck. }
{ ---------------------------------------------------------------- }
FUNCTION stRUpper (VAR STR : PChar) : PChar;
{ ---------------------------------------------------------------- }
{ Konvertiert alle Zeichen von Str in Kleinbuchstaben und gibt den }
{ neuen String zur.ck. }
{ ---------------------------------------------------------------- }
FUNCTION stRLower (VAR STR : PChar) : PChar;
{ ---------------------------------------------------------------- }
{ Konertiert Str in einen Pascal-like String und gibt diesen zu- }
{ r.ck. Achtung: STRING's k.nnen maximal 255 Zeichen aufnehmen; }
{ wenn Str l.nger ist, so wird der Rest schlicht und einfach kom- }
{ mentarlos abgeschnitten. }
{ ---------------------------------------------------------------- }
FUNCTION stRPas (STR : PChar) : STRING;
{ ---------------------------------------------------------------- }
{ Alloziert eine Kopie von Str auf dem Heap. Wenn Str Nil ist oder }
{ auf einen Nullstring zeigt (erstes Byte = letztes Byte = Null), }
{ so wird kein Heap alloziert und Nil zur.ckgegeben; ebenso, wenn }
{ auf dem Heap nicht genug (zusammenh.ngender) Speicher verf.gbar }
{ ist. }
{ ---------------------------------------------------------------- }
{ Sonst wird mittels der Standard GETMEM-Prozedur auf dem Heap }
{ Speicher reserviert (und zwar StrLen (Str) + 1 Bytes), ein }
{ Duplikat von Str erzeugt, in diesen Speicherbereich kopiert und }
{ der Pointer auf den neuen String zur.ckgegeben. }
{ ---------------------------------------------------------------- }
FUNCTION stRNew (STR : PChar) : PChar;
{ ---------------------------------------------------------------- }
{ L.scht einen zuvor mittels "StrNew" allozierten String wieder }
{ aus dem Speicher. Sollte Str Nil sein, so wird nichts getan }
{ (also auch kein Runtime-Error ...). }
{ ---------------------------------------------------------------- }
PROCEDURE stRDispose (VAR STR : PChar);
{$ENDIF}
{ ---------------------------------------------------------------- }
{ Wie StrNew, nur da. der urspr.ngliche String im Pascal-Stil ist. }
{ Sollte LENGTH (Str) = 0 sein, so wird kein Speicher alloziert. }
{ ebenso, wenn auf dem Heap nicht genug (zusammenh.ngender) Spei- }
{ cher verf.gbar ist. }
{ ---------------------------------------------------------------- }
{ Sollte innerhalb des Strings rein zuf.llig ein Nullbyte vorkom- }
{ men, so wird dieses als Ende-Kennzeichen interpretiert ! }
{ ---------------------------------------------------------------- }
FUNCTION stRPasNew (STR : STRING) : PChar;
{ ---------------------------------------------------------------- }
{ Wandelt die Zeichen von Str von ASCII nach ANSI. Im zweiten }
{ Zeichensatz nicht vorhandene Zeichen werden kommentarlos ent- }
{ fernt ! }
{ ---------------------------------------------------------------- }
PROCEDURE stRASC2ANSI (VAR STR : PChar);
{ ---------------------------------------------------------------- }
{ Wandelt die Zeichen von Str von ANSI nach ASCII. Im zweiten }
{ Zeichensatz nicht vorhandene Zeichen werden kommentarlos ent- }
{ fernt ! }
{ ---------------------------------------------------------------- }
PROCEDURE stRANSI2ASC (VAR STR : PChar);
{ ---------------------------------------------------------------- }
{ Gibt das Zeichen mit der angegebenen Position innerhalb des }
{ PChars zur.ck. Sollte der String Nil sein oder die Position }
{ au.erhalb des Strings liegen, so wird ein Nullbyte zur.ckgege- }
{ ben. }
{ ---------------------------------------------------------------- }
{ Apropos: Der Beginn der Z.hlung erfolgt bei 1 ! }
{ ---------------------------------------------------------------- }
FUNCTION stRGetChar (STR : PChar; POS : WORD) : CHAR;
{ ---------------------------------------------------------------- }
{ Setzt das Zeichen mit der angegebenen Position innerhalb des }
{ PChars auf den angegebenen Code. Sollte der String Nil sein oder }
{ die Position au.erhalb des Strings liegen, so passiert nichts. }
{ ---------------------------------------------------------------- }
{ Apropos: Der Beginn der Z.hlung erfolgt bei 1 ! }
{ ---------------------------------------------------------------- }
{ Und noch etwas: Chr sollte nicht gerade unbedingt ein Nullbyte }
{ sein - das bringt nur die Speicherverwaltung durcheinander ... }
{ ---------------------------------------------------------------- }
PROCEDURE stRSetChar (VAR STR : PChar; POS : WORD; CHR : CHAR);
{ ---------------------------------------------------------------- }
{ Gibt einen Pointer auf das Zeichen mit dem Index "Pos" zur.ck. }
{ ---------------------------------------------------------------- }
{ Sehr universell verwendbar, da damit Teile von PChars "heraus- }
{ geschnitten" werden k.nnen. }
{ ---------------------------------------------------------------- }
FUNCTION GetPCPtrNum (STR : PChar; POS : WORD) : PChar;
{ ---------------------------------------------------------------- }
{ Liefert einen Pointer auf das erste Vorkommen von Str2 in Str1 }
{ zur.ck; wenn Str2 nicht in Str1 enthalten ist, so wird Nil zu- }
{ r.ckgegeben. }
{ ---------------------------------------------------------------- }
{ Gro.- und Kleinschreibung wird nicht unterschieden, da zuerst }
{ neue PChars angelegt (um die alten nicht zu ver.ndern) und in }
{ Kleinbuchstaben umgewandelt werden, bevor der Vergleich durch- }
{ gef.hrt wird. Die neuen PChars werden nat.rlich nach vollendetem }
{ Vergleich wieder aus dem Speicher entfernt. }
{ ---------------------------------------------------------------- }
{ Sollte zu wenig Speicher vorhanden sein, um die beiden neuen }
{ PChars anzulegen, so wird das normale StrPos aufgerufen und }
{ dessen Ergebnis zur.ckgegeben - aber das ist wohl eher nicht so }
{ wahrscheinlich (?) (hoffentlich). }
{ ---------------------------------------------------------------- }
FUNCTION stRSearch (stR1, stR2 : PChar) : PChar;
{ ---------------------------------------------------------------- }
{ H.ngt an Str1 den Str2 an, wobei ersterer in seiner L.nge automa-}
{ tisch angepa#t wird. ATTENTION: Str1 wird dazu aus dem Speicher }
{ geworfen, sprich mu# dynamisch alloziert sein ! }
{ Zur.ckgegeben wird dann wieder der zusammengesetzte String ! }
{ ---------------------------------------------------------------- }
FUNCTION stRAdd (VAR stR1 : PChar; stR2 : PChar) : PChar;
{ ---------------------------------------------------------------- }
{ H.ngt an Str1 den Str2 an, wobei ersterer in seiner L.nge automa-}
{ tisch angepa#t wird. ATTENTION: Str1 wird dazu aus dem Speicher }
{ geworfen, sprich mu# dynamisch alloziert sein ! }
{ Zur.ckgegeben wird dann wieder der zusammengesetzte String ! }
{ ---------------------------------------------------------------- }
{ Einziger Unterschied zu "StrAdd" ist, da# der anzuh.ngende }
{ String Pascal-like ist. }
{ ---------------------------------------------------------------- }
FUNCTION stRPasAdd (VAR stR1 : PChar; stR2 : STRING) : PChar;
This page created by ng2html v1.05, the Norton guide to HTML conversion utility.
Written by Dave Pearson