[<<Previous Entry]
[^^Up^^]
[Next Entry>>]
[Menu]
[About The Guide]
ASTRINGS.INT
{ ---------------------------------------------------------------- }
{ TULL-TERMINATED-STRINGS }
{ ---------------------------------------------------------------- }
{ Dieses Modul enstand aus dem Bed.rfnis, eine zwischen Turbo- }
{ Pascal f.r Windows und Turbo-Pascal f.r DOS einheitliche Behand- }
{ lung von "langen" Strings zu erm.glichen. }
{ Das unter TPW verf.gbare Modul "STRINGS" ist f.r solche Anwen- }
{ dungen geradezu ideal geeignet - aber es liegt nur im Quelltext }
{ vor, weshalb es leider nicht m.glich ist, es einfach unter DOS }
{ noch einmal zu kompilieren, weshalb die wichtigsten Routinen - }
{ soweit f.r die Verwendung in den Memoroutinen erforderlich - }
{ hier noch einmal - mit ein paar kleineren Erg.nzungen - imple- }
{ mentiert werden mu.ten. }
{ ---------------------------------------------------------------- }
{ Das Prinzip der "PChar's" ist, da. die Strings immer auf dem }
{ Heap abgelegt werden, und zwar unter Reservierung von genau so }
{ viel Speicher, wie sie wirklich ben.tigen (plus 1 Byte f.r die }
{ Endekennzeichnung). }
{ Das Mitf.hren eines L.ngenbytes (oder hier eines "L.ngenwords") }
{ entf.llt, weil ja das Stringende durch das Nullbyte eindeutig }
{ bestimmt ist (so wird's ja auch in C gemacht; wer's nicht wei.: }
{ normale TP-String sind Arrays of Char, die im 0. Byte die L.n- }
{ genangabe mitf.hren - wodurch sie zwangsl.ufig auf 255 Zeichen }
{ begrenzt sind). }
{ Durch den so notwendigen h.heren Verwaltungsaufwand sind PChars }
{ nat.rlich merkbar langsamer als "normale" Strings, man denke nur }
{ an den Aufwand beim Einf.gen eines einzelnen Zeichens (Speicher }
{ reservieren, erste H.lfte kopieren, Zeichen einf.gen, zweite }
{ H.lfte kopieren, alten Speicher freigeben) oder beim Bestimmen }
{ der L.nge (Suchen nach Nullbyte). }
{ ---------------------------------------------------------------- }
{ Leider hat TPW f.r die Behandlung von Behandlung von PChar's }
{ via "Extended Syntax" einige Optionen eingebaut bekommen, die }
{ unter DOS nat.rlich nicht zur Verf.gung stehen. Aus diesem Grund }
{ besteht ein Teil dieser Unit aus Zugriffsmethoden, die zwar in }
{ beiden Compilerversionen "auch so" einfach durchf.hrbar w.ren, }
{ jedoch eben jeweils auf eine andere Art und Weise - hier via be- }
{ dingte Compilierung gel.st. }
{ ---------------------------------------------------------------- }
{ Es sei hier darauf hingewiesen, da. bei der Anwendung von PChar- }
{ Variablen unbedingte Vorsicht notwendig ist, sonst sind Fehler }
{ bzw. Abst.rze schon vorprogrammiert. }
{ ---------------------------------------------------------------- }
{ Ein Wort zu GETMEM, FREEMEM, NEW, DISPOSE, MEMAVAIL und Konsor- }
{ ten unter Windows: die Speicherverwaltung ist hier "etwas an- }
{ ders" als unter DOS - wenn also ab und zu wieder einmal 60 Byte }
{ fehlen, so bin nicht (!) ich schuld ! }
{ ---------------------------------------------------------------- }
{ (c) Aurora featuring Markus SCHWAIGER 1992 }
{ ---------------------------------------------------------------- }
UNIT AStrings;
INTERFACE
USES
{$IFDEF Windows}
WinProcs,
AStrTool, { Aurora's Stringbearbeitungsroutinen }
Strings; { Die Windows-Version der Strings }
{$ELSE}
OBJECTS, { Typecasting mittels WordRec }
AStrTool; { Aurora's Stringbearbeitungsroutinen }
{$ENDIF}
{ ---------------------------------------------------------------- }
{ Maximale L.nge eines PChar's: entspricht der unter DOS (und auch }
{ noch unter Windows 3.X) ach so beliebten Segmentgr..e von 64 }
{ KByte - denn nichts ist gr..er ... }
{ ---------------------------------------------------------------- }
CONST
MaxPCharLen = 65535;
{$IFNDEF Windows}
TYPE
{ ---------------------------------------------------------------- }
{ F.r's Typecasting verwendeter Typ - wird niemals als Variable }
{ verwendet, sondern nur .ber den PChar gelegt, um auf ihn wie auf }
{ ein Array zugreifen zu k.nnen. }
{ ---------------------------------------------------------------- }
{ F.r Windows nicht notwendig, da man dort ja auf PChars wie auf }
{ ein normales Array zugreifen kann - faszinierenderweise auch }
{ dann, wenn die PChars eigentlich auf dem Heap liegen und irgend- }
{ wie dereferenziert werden m..ten. }
{ ---------------------------------------------------------------- }
XChar = ARRAY [1 .. MaxPCharLen] OF CHAR;
{ ---------------------------------------------------------------- }
{ Der eigentliche PChar-Typ - ist so reine Tarnung ... }
{ ---------------------------------------------------------------- }
PChar = POINTER;
{$ENDIF}
{ ---------------------------------------------------------------- }
{ Pointer auf einen leeren String. }
{ ---------------------------------------------------------------- }
CONST
DummyStr : CHAR = #0;
DummyPChar : PChar = @DummyStr;
{ ---------------------------------------------------------------- }
{ Nicht nur f.r Strings verwendbar: Vergleicht die beiden angege- }
{ Speicherbereiche ohne R.cksicht auf Verluste (= ohne irgend- }
{ welche .berpr.fungen) bis zur L.nge Len. Wenn .bereinstimmung }
{ festgestellt wurde, so wird True zur.ckgegeben, sonst False. }
{ ---------------------------------------------------------------- }
FUNCTION Compare (VAR P1, P2; Len : WORD) : BOOLEAN;
{$IFNDEF Windows}
{ ---------------------------------------------------------------- }
{ Gibt die L.nge (= Anzahl der Zeichen ohne Nullbyte) des angege- }
{ benen Strings zur.ck. Diese entspricht gleichzeitig dem Spei- }
{ cherbedarf - 1 (Nullbyte). }
{ ---------------------------------------------------------------- }
{ Sollte Str Nil sein oder kein terminierendes Nullbyte gefunden }
{ werden (Str gr..er als MaxPCharLen), dann wird 0 zur.ckgege- }
{ ben. }
{ ---------------------------------------------------------------- }
FUNCTION stRLen (STR : PChar) : WORD;
{ ---------------------------------------------------------------- }
{ Kopiert genau Count Zeichen von Source auf / .ber Dest und gibt }
{ Dest zur.ck. Die beiden Speicherbereiche d.rfen auch .berlappend }
{ sein ! }
{ Wenn Source k.rzer ist als Dest, so wird dieser verk.rzt, im ge- }
{ genteiligen Falle entsprechend verl.ngert. }
{ ---------------------------------------------------------------- }
{ Achtung: Dest wird dazu ver.ndert, d.h., es darf kein "Pseudo- }
{ PChar" (Adresse eines normalen Strings sein), sondern mu. tat- }
{ s.chlich auf dem Heap alloziert sein. }
{ ---------------------------------------------------------------- }
FUNCTION stRMove (VAR Dest : PChar; Source : PChar;
Count : WORD) : PChar;
{ ---------------------------------------------------------------- }
{ Kopiert den (normalen Pascal-) String Source nach Dest und gibt }
{ Dest zur.ck. }
{ Sollte Dest ungleich Nil sein, so wird der damit referenzierte }
{ PChar zuerst freigegeben. }
{ ---------------------------------------------------------------- }
FUNCTION stRPCopy (VAR Dest : PChar; Source : STRING) : PChar;
{ ---------------------------------------------------------------- }
{ H.ngt eine Kopie von Source an das Ende von Dest an und gibt }
{ Dest zur.ck. }
{ ---------------------------------------------------------------- }
{ Achtung: Dest wird dazu ver.ndert, d.h., es darf kein "Pseudo- }
{ PChar" (Adresse eines normalen Strings sein), sondern mu. tat- }
{ s.chlich auf dem Heap alloziert sein. }
{ ---------------------------------------------------------------- }
FUNCTION stRCat (VAR Dest : PChar; Source : PChar) : PChar;
{ ---------------------------------------------------------------- }
{ Kopiert maximal MaxLen - StrLen (Dest) Zeichen von Source an das }
{ Ende von Dest und gibt Dest zur.ck; dadurch wird die L.nge des }
{ gesamten Strings auf MaxLen beschr.nkt. }
{ ---------------------------------------------------------------- }
{ Achtung: Dest wird dazu ver.ndert, d.h., es darf kein "Pseudo- }
{ PChar" (Adresse eines normalen Strings sein), sondern mu. tat- }
{ s.chlich auf dem Heap alloziert sein. }
{ ---------------------------------------------------------------- }
FUNCTION stRLCat (VAR Dest : PChar; Source : PChar;
MaxLen : WORD) : PChar;
{ ---------------------------------------------------------------- }
{ StrScan liefert einen Pointer auf das erste Vorkommen von Chr im }
{ String; wenn Chr gar nicht vorkommt oder der String "unendlich }
{ lang" ist (d.h., kein Nullbyte vor MaxPCharLen), so wird Nil zu- }
{ r.ckgegeben. Das terminierende Nullbyte z.hlt dabei (ausnahms- }
{ weise) zum String und kann so beispielsweise auch gesucht wer- }
{ den (ich w..te aber nicht, wozu). }
{ ---------------------------------------------------------------- }
FUNCTION stRScan (STR : PChar; CHR : CHAR) : PChar;
{ ---------------------------------------------------------------- }
{ Liefert einen Pointer auf das letzte Vorkommen von Chr im String }
{ Str; kommt Chr gar nicht vor oder ist Str = Nil, so wird Nil }
{ zur.ckgegeben. }
{ Das terminierende Nullbyte z.hlt dabei (ausnahmsweise) zum }
{ String und kann so beispielsweise auch gesucht werden. }
{ ---------------------------------------------------------------- }
FUNCTION stRRScan (STR : PChar; CHR : CHAR) : 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. }
{ ---------------------------------------------------------------- }
FUNCTION stRPos (stR1, stR2 : PChar) : PChar;
This page created by ng2html v1.05, the Norton guide to HTML conversion utility.
Written by Dave Pearson