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