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