[<<Previous Entry] [^^Up^^] [Next Entry>>] [Menu] [About The Guide]


 { ---------------------------------------------------------------- }
 { Wandelt den Wert Value in seine Bin.rdarstellung mit einer       }
 { maximalen L.nge von Width um.                                    }
 { ---------------------------------------------------------------- }

   FUNCTION  ToBit (Value : LONGINT; Width : INTEGER) : STRING;


 { ---------------------------------------------------------------- }
 { Wandelt den Wert Value in seine Hexadezimaldarstellung mit einer }
 { maximalen L.nge von Width um.                                    }
 { ---------------------------------------------------------------- }

   FUNCTION  ToHex (Value : LONGINT; Width : INTEGER) : STRING;


 { ---------------------------------------------------------------- }
 { Wandelt den LongInt-Wert Value in einen String der L.nge Width   }
 { um.                                                              }
 { ---------------------------------------------------------------- }

   FUNCTION  LongToStr (Value : LONGINT; Width : INTEGER) : STRING;


 { ---------------------------------------------------------------- }
 { Packt den angegebenen String, d.h. alle nicht alphanumerischen   }
 { (0 .. 9, A .. Z, ., ., ., .) Zeichen werden entfernt und Klein-  }
 { in Gro.buchstaben umgewandelt.                                   }
 { ---------------------------------------------------------------- }

   FUNCTION PackStr (LINE : STRING) : STRING;


 { ---------------------------------------------------------------- }
 { Wandelt alle Zeichen in Gro.buchstaben um (auch Umlaute !),      }
 { Sonderzeichen (sprich alles, was nicht im alphanumerischen       }
 { Bereich A..Z, a..z, 0..9, ., ., ., ., ., . ist) werden entfernt  }
 { (auch Spaces !!)                                                 }
 { ---------------------------------------------------------------- }

   FUNCTION NSPack (STR : STRING) : STRING;


 {$IFNDEF Windows}

 { ---------------------------------------------------------------- }
 { Konvertiert die Umlaute im angegebenen ASCII-Char nach ANSI.     }
 { ---------------------------------------------------------------- }

   FUNCTION ANSI2ASCII (Ch : CHAR) : CHAR;


 { ---------------------------------------------------------------- }
 { Konvertiert die Umlaute im angegebenen ANSI-Char nach ASCII.     }
 { ---------------------------------------------------------------- }

   FUNCTION ASCII2ANSI (Ch : CHAR) : CHAR;

 {$ENDIF}

 { ---------------------------------------------------------------- }
 { Definiert die Wildcards f.r "IsInside" - siehe dort.             }
 { ---------------------------------------------------------------- }

   VAR
     WildCard       : STRING [2];

 { ---------------------------------------------------------------- }
 { Macht effektiv nichts, sondern gibt den .bergebenen String       }
 { kommentarlos zur.ck.                                             }
 { ---------------------------------------------------------------- }

   FUNCTION stRDummy (STR : STRING) : STRING;


 { ---------------------------------------------------------------- }
 { Ersetzt die herk.mmliche von Turbo-Pascal zu Verf.gung gestellte }
 { Funktion Concat, wobei folgende Eigenschaften verbessert wurden: }
 { Zeitverhalten ( Faktor 4 gegen.ber + ), Speicherbelastung        }
 { ---------------------------------------------------------------- }

   FUNCTION stRConcat (stR1,  stR2 : STRING) : STRING;


 { ---------------------------------------------------------------- }
 { Radikalste Schl.sselbehandlung: Bildet die Soundex-Funktion von  }
 { Clipper nach.                                                    }
 { ---------------------------------------------------------------- }

   FUNCTION SoundEx (STR : STRING) : STRING;


 { ---------------------------------------------------------------- }
 {  (c) by # NanoSoft                                Last Update :  }
 {         ##########                                1992-05-15     }
 { ---------------------------------------------------------------- }
 { Funktion vergleicht 2 Strings nach der Soundexvariante !         }
 { In STR1 und STR2 werden die zu vergleichEnden Strings .bergeben. }
 { Mit der Variable SE gibt man an, ob die Strings bereits im       }
 { Soundex-Format .bergeben wurden (SE=TRUE).                       }
 { F.r die Variable MODE sind folgende Werte zul.ssig :             }
 {  1 =  1:1 Vergleich der beiden Soundex-Strings                   }
 {  2 =  Wie 1, aber ohne Vergleich des ersten Zeichens im          }
 {       Soundex-Code                                               }
 {  3 =  beide Strings werden als gleich betrachtet, wenn zwei      }
 {       Komponenten des Codes .bereinstimmen (unabh.ngig von ihrer }
 {       Position, das erste Zeichen wird nicht verglichen)         }
 {       z.B.: N400 = D340, M110 = U611, usw.                       }
 {  4 =  Wie 3, das erste Zeichen wird jedoch mitverglichen         }
 { Ist der Funktionswert TRUE sind die .bergebenen Strings gleich ! }
 { ---------------------------------------------------------------- }

   FUNCTION coMpareSoundex (stR1,  stR2 : STRING; SE : BOOLEAN;
                                              Mode : BYTE) : BOOLEAN;


 { ---------------------------------------------------------------- }
 {  (c) by # NanoSoft                                Last Update :  }
 {         ##########                                1992-06-01     }
 { ---------------------------------------------------------------- }
 { Mittels der Funktion StrComp kann man zwei Strings vergleichen.  }
 { Das besondere an dieser Funktion ist, da. man die Sortierreihen- }
 { folge beliebig festlegen kann. Zu diesem Zweck wird der Funktion }
 { ein Pointer auf ein Array [0..255] of Byte .bergeben. In diesem  }
 { Array stehen die Wertigkeiten f.r die entsprechEnden ASCII -     }
 { Zeichen. Z.B.: arraywert[66]:= 2 bedeutet, da. 'B' die           }
 {                Wertigkeit von 2 bekommt.                         }
 { ---------------------------------------------------------------- }
 { Eingabe:                                                         }
 {    StrCompArray ......... Pointer auf array[0..255] of Byte      }
 {    string1, string2 ..... zu vergleichEnde Strings               }
 {    operator ............. '>' , '<' , '>=' , '<=' , '=' , '<>'   }
 {    numlen ............... Wenn numlen > 0 ist, so hat dies zu    }
 {      Folge, da. die ersten Nummlen Stellen von String1 und       }
 {      String2 als numerischer Wert aufgefa.t werden und als       }
 {      solcher auch verglichen werden. Z.B. -123.45 > -234.56      }
 {      Das String-Compare-Array hat bei diesem Vergleich keinen    }
 {      Einflu.. Alle nachfolgen Zeichen werden normal (mit Hilfe   }
 {      des String-Compare-Arrays) verglichen.                      }
 {      Z.B.: '  -23.45a' < '  -23.45b'                             }
 {            ' -123.456' => NumLen=9                               }
 { Ausgabe:                                                         }
 {    Ausgabe = String1 Operator String2                            }
 { ---------------------------------------------------------------- }

   FUNCTION stRComp (stRCompArray : POINTER;
            stRing1, stRing2, Operator : STRING;NumLen : BYTE) : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Ein Standard-Vergleichs-Array: Gro.- und Kleinschreibung macht   }
 { keinen Unterschied, Umlaute werden nach dem entsprechEnde Vokal  }
 { eingeordnet (a - . - b ...), . nach s (s - . - t), das Leer-     }
 { zeichen ist das erste Zeichen, dann kommen die Ziffern gefolgt   }
 { von den Buchstaben.                                              }
 { ---------------------------------------------------------------- }

   TYPE
     TCmpArr        = ARRAY [0 .. 255] OF BYTE;


   VAR
     TStdCmpArr     : TCmpArr;


   CONST
     PStdCmpArr     : POINTER = @TStdCmpArr;

This page created by ng2html v1.05, the Norton guide to HTML conversion utility. Written by Dave Pearson