konto_check 0.2.1 → 5.2.1

data/ext/konto_check_raw/konto_check.h

@@ -1,3 +1,7 @@
+/* vim: ft=c:set si:set fileencoding=iso-8859-1
+ */
+#line 9 "konto_check_h.lx"
+
 /*
  * ##########################################################################
  * #  Dies ist konto_check, ein Programm zum Testen der Pr�fziffern         #
@@ -45,11 +49,65 @@
 
 /* 
  * ##########################################################################
- * # Die Berechnungsmethoden B6 und D1 werden zum 5.9.11 ge�ndert; mit dem  #
- * # folgenden Makro werden die neuen Berechnungsmethoden aktiviert.        #
+ * # Hier eine Info der Flessabank zur IBAN-Berechnung (abgerufen 13.6.12   #
+ * # von http://www.flessabank.de/aktuell.php?akt=149)                      #
+ * #                                                                        #
+ * # Aktuelles Bankleitzahl/BIC                                             #
+ * #                                                                        #
+ * # Im Rahmen eines umfassenden Konsolidierungsprojekts der Deutschen      #
+ * # Bundesbank und der Europ�ischen Zentralbank werden immer mehr Filialen #
+ * # der Deutschen Bundesbank geschlossen. Dabei wird auch die aktuelle     #
+ * # Bankleitzahlenlogik f�r die Deutsche Bundesbank �berarbeitet.          #
+ * #                                                                        #
+ * # Um als FLESSABANK dieser ver�nderten Situation gerecht zu werden,      #
+ * # haben wir uns entschlossen, unsere Bankleitzahlenstruktur zu           #
+ * # vereinfachen und auf die zentrale Bankleitzahl 793 301 11 umzustellen. #
+ * # Ihre Kontonummern bleiben dabei unver�ndert g�ltig!                    #
+ * #                                                                        #
+ * # Betroffen sind hiervon folgende Bankleitzahlen:                        #
+ * # 700 301 11 (Niederlassung M�nchen)                                     #
+ * # 763 301 11 (Niederlassung Erlangen)                                    #
+ * # 770 301 11 (Niederlassung Bamberg)                                     #
+ * # 783 301 11 (Niederlassung Coburg)                                      #
+ * # 840 301 11 (Niederlassung Meiningen)                                   #
+ * #                                                                        #
+ * # F�r die Bereiche Internet-Banking und girocard ist bereits heute nur   #
+ * # die Bankleitzahl 793 301 11 g�ltig. Auch Ihre IBAN (International Bank #
+ * # Account Number = Internationale Kontonummer) wird ausschlie�lich mit   #
+ * # der Bankleitzahl 793 301 11 erstellt. Wir teilen Ihnen diese zusammen  #
+ * # mit unserem BIC (Bank Identifier Code = Bankkennung) auf jedem         #
+ * # Kontoauszug mit.                                                       #
+ * #                                                                        #
+ * # Update zur Flessa-Bank (abgerufen 28.10.13): Die obigen Bankleitzahlen #
+ * # haben in der aktuellen BLZ-Datei das L�schflag gesetzt und als         #
+ * # Nachfolge-BLZ die 79330111 eingetragen. Damit er�brigt sich die        #
+ * # Korrektur f�r die Flessa-Bank.                                         #
  * ##########################################################################
  */
-#define METHODE_NEU_2011_09_05 1
+
+#define FLESSA_KORREKTUR 0
+
+/* IBAN-Regeln benutzen (g�ltig ab 3.6.2013) */
+#define USE_IBAN_RULES 1
+
+   /* �nderungen der Pr�fziffermethoden zum 9. September 2013 erzwingen
+    * (bei 0 werden sie abh�ngig vom Datum aktiviert).
+   */ 
+#define FORCE_AENDERUNGEN_2013_09 0
+
+   /* die neue Version der Regel 20 wird zum 9. Dezember in den offiziellen IBAN-Regeln ver�ffentlicht;
+    * die Bundesbank hat jedoch schon die Regelversion am 28. August ver�ffentlicht, mit der Bitte, sie
+    * m�glichst schon zum 9. September einzusetzen. Durch die neue Regelversion werden die F�lle mit dem
+    * R�ckgabewert IBAN_AMBIGUOUS_KTO komplett eliminiert.
+    */
+
+#define DB_NEUE_VERSION 1  /* bei 1: neue Version der DB-Regel benutzen */
+
+/* Debug-Version f�r iban_gen in Perl aktivieren (zur Ausgabe der benutzten
+ * Pr�fziffermethode in iban_gen()). Dies ist nur m�glich, falls das Makro
+ * DEBUG auf 1 gesetzt ist.
+ */
+#define PERL_IBAN_DBG 1
 
 /* Das Makro DEFAULT_ENCODING legt die Ausgabe-Kodierung f�r die Funktion
  * kto_check_retval2txt() und die Blocks Name, Kurzname und Ort aus der
@@ -77,9 +135,16 @@
  * # unterschiedliche Interpretationen der Berechnungsmethoden existieren.  #
  * ##########################################################################
  */
+#define BAV_ENABLE 0
+
+#if BAV_ENABLE==1
 #ifndef BAV_KOMPATIBEL
 #define BAV_KOMPATIBEL 0
 #endif
+#else
+#undef BAV_KOMPATIBEL
+#define BAV_KOMPATIBEL 0
+#endif
 
 /*
  * ##########################################################################
@@ -173,6 +238,19 @@
 #  define DLL_EXPORT_V
 #endif
 
+/*
+ * ######################################################################
+ * # AWK_ADD_MICROTIME: AWK-Funktionalit�t mit Mikrosekunden-Aufl�sung  #
+ * # Falls das folgende Makro auf 1 gesetzt wird, wird im awk-Port die  #
+ * # Funktion microtime() definiert, die - anders als systime() - mit   #
+ * # hoher Aufl�sung (Mikrosekunden) arbeitet. Parameter etc. finden    #
+ * # sich in konto_check_awk.c. Standardm��ig ist die Funktion nicht    #
+ * # aktiviert.                                                         #
+ * ######################################################################
+ */
+#define AWK_ADD_MICROTIME 1
+
+
 /*
  * ######################################################################
  * #          Defaultnamen und Suchpfad f�r die LUT-Datei               #
@@ -188,7 +266,7 @@
 #endif
 
    /* maximale L�nge f�r Default-Suchpfad und Dateiname der LUT-Datei */
-#define LUT_PATH_LEN 128
+#define LUT_PATH_LEN 512
 
 /*
  * ######################################################################
@@ -196,10 +274,10 @@
  * ######################################################################
  */
 
-#define DEFAULT_LUT_FIELDS_NUM   5
-#define DEFAULT_LUT_FIELDS       lut_set_5
+#define DEFAULT_LUT_FIELDS_NUM   9
+#define DEFAULT_LUT_FIELDS       lut_set_9
 #define DEFAULT_LUT_VERSION      3
-#define DEFAULT_SLOTS            40
+#define DEFAULT_SLOTS            60
 #define DEFAULT_INIT_LEVEL       5
 #define LAST_LUT_BLOCK           100
 
@@ -246,6 +324,10 @@
 #define LUT2_PLZ_SORT                20
 #define LUT2_PZ_SORT                 21
 #define LUT2_OWN_IBAN                22
+#define LUT2_VOLLTEXT_TXT            23
+#define LUT2_VOLLTEXT_IDX            24
+#define LUT2_IBAN_REGEL              25
+#define LUT2_IBAN_REGEL_SORT         26
 
 #define LUT2_2_BLZ                  101
 #define LUT2_2_FILIALEN             102
@@ -269,6 +351,10 @@
 #define LUT2_2_PLZ_SORT             120
 #define LUT2_2_PZ_SORT              121
 #define LUT2_2_OWN_IBAN             122
+#define LUT2_2_VOLLTEXT_TXT         123
+#define LUT2_2_VOLLTEXT_IDX         124
+#define LUT2_2_IBAN_REGEL           125
+#define LUT2_2_IBAN_REGEL_SORT      126
 
 #define LUT2_DEFAULT                501
 
@@ -285,10 +371,42 @@ extern const char *lut2_feld_namen[256];
  */
 
 #undef FALSE
+#define BIC_ONLY_GERMAN                       -145
+#define INVALID_BIC_LENGTH                    -144
+#define IBAN_CHKSUM_OK_RULE_IGNORED_BLZ       -143
+#define IBAN_CHKSUM_OK_KC_NOT_INITIALIZED     -142
+#define IBAN_CHKSUM_OK_BLZ_INVALID            -141
+#define IBAN_CHKSUM_OK_NACHFOLGE_BLZ_DEFINED  -140
+#define LUT2_NOT_ALL_IBAN_BLOCKS_LOADED       -139
+#define LUT2_NOT_YET_VALID_PARTIAL_OK         -138
+#define LUT2_NO_LONGER_VALID_PARTIAL_OK       -137
+#define LUT2_BLOCKS_MISSING                   -136
+#define FALSE_UNTERKONTO_ATTACHED             -135
+#define BLZ_BLACKLISTED                       -134
+#define BLZ_MARKED_AS_DELETED                 -133
+#define IBAN_CHKSUM_OK_SOMETHING_WRONG        -132
+#define IBAN_CHKSUM_OK_NO_IBAN_CALCULATION    -131
+#define IBAN_CHKSUM_OK_RULE_IGNORED           -130
+#define IBAN_CHKSUM_OK_UNTERKTO_MISSING       -129
+#define IBAN_INVALID_RULE                     -128
+#define IBAN_AMBIGUOUS_KTO                    -127
+#define IBAN_RULE_NOT_IMPLEMENTED             -126
+#define IBAN_RULE_UNKNOWN                     -125
+#define NO_IBAN_CALCULATION                   -124
+#define OLD_BLZ_OK_NEW_NOT                    -123
+#define LUT2_IBAN_REGEL_NOT_INITIALIZED       -122
+#define INVALID_IBAN_LENGTH                   -121
+#define LUT2_NO_ACCOUNT_GIVEN                 -120
+#define LUT2_VOLLTEXT_INVALID_CHAR            -119
+#define LUT2_VOLLTEXT_SINGLE_WORD_ONLY        -118
+#define LUT_SUCHE_INVALID_RSC                 -117
+#define LUT_SUCHE_INVALID_CMD                 -116
+#define LUT_SUCHE_INVALID_CNT                 -115
+#define LUT2_VOLLTEXT_NOT_INITIALIZED         -114
 #define NO_OWN_IBAN_CALCULATION               -113
 #define KTO_CHECK_UNSUPPORTED_COMPRESSION     -112
 #define KTO_CHECK_INVALID_COMPRESSION_LIB     -111
-#define OK_UNTERKONTO_ATTACHED                -110
+#define OK_UNTERKONTO_ATTACHED_OLD            -110
 #define KTO_CHECK_DEFAULT_BLOCK_INVALID       -109
 #define KTO_CHECK_DEFAULT_BLOCK_FULL          -108
 #define KTO_CHECK_NO_DEFAULT_BLOCK            -107
@@ -412,6 +530,19 @@ extern const char *lut2_feld_namen[256];
 #define OK_UNTERKONTO_POSSIBLE                  11
 #define OK_UNTERKONTO_GIVEN                     12
 #define OK_SLOT_CNT_MIN_USED                    13
+#define SOME_KEYS_NOT_FOUND                     14
+#define LUT2_KTO_NOT_CHECKED                    15
+#define LUT2_OK_WITHOUT_IBAN_RULES              16
+#define OK_NACHFOLGE_BLZ_USED                   17
+#define OK_KTO_REPLACED                         18
+#define OK_BLZ_REPLACED                         19
+#define OK_BLZ_KTO_REPLACED                     20
+#define OK_IBAN_WITHOUT_KC_TEST                 21
+#define OK_INVALID_FOR_IBAN                     22
+#define OK_HYPO_REQUIRES_KTO                    23
+#define OK_KTO_REPLACED_NO_PZ                   24
+#define OK_UNTERKONTO_ATTACHED                  25
+#line 321 "konto_check_h.lx"
 
 #define MAX_BLZ_CNT 30000  /* maximale Anzahl BLZ's in generate_lut() */
 
@@ -487,8 +618,8 @@ typedef struct{
  * # Dieser Parameter gibt an, wieviele Slots das Inhaltsverzeichnis einer  #
  * # LUT-Datei mindestens haben soll. F�r jeden Block in der LUT-Datei wird #
  * # ein Slot im Inhaltsverzeichnis ben�tigt; bei einer LUT-Datei mit allen #
- * # Eintr�gen (Level 9) sind das 19 Slots, falls zwei Datens�tze in der    #
- * # Datei gehalten werden sollen, 38 (inklusive Indexblocks).              #
+ * # Eintr�gen (Level 9) sind das 23 Slots, falls zwei Datens�tze in der    #
+ * # Datei gehalten werden sollen, 46 (inklusive Indexblocks).              #
  * #                                                                        #
  * # Das Slotverzeichnis ist eine relativ einfache Datenstruktur; es        #
  * # enth�lt f�r jeden Slot nur drei 4 Byte-Integers (Typ, Offset und       #
@@ -503,7 +634,7 @@ typedef struct{
  * #                                                                        #
  * ##########################################################################
  */
-#define SLOT_CNT_MIN 40
+#define SLOT_CNT_MIN 60
 
 /*
  * ##########################################################################
@@ -610,6 +741,39 @@ DLL_EXPORT int kto_check_pz(char *pz,char *kto,char *blz);
 DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals);
 #endif
 
+/* ###########################################################################
+ * # Die Funktion kto_check_regel() entspricht der Funktion                  #
+ * # kto_check_blz(). Der einzige Unterschied ist, da� vor dem Test gepr�ft  #
+ * # wird, ob f�r die  BLZ/Konto-Kombination eine IBAN-Regel angewendet      #
+ * # werden mu� (z.B. bei Spendenkonten etc.). U.U. wird die BLZ und/oder    #
+ * # Kontonummer ersetzt  und die Berechnung mit den modifizierten Werten    #
+ * # gemacht. Die Werte f�r BLZ und Kontonummer werden nicht zur�ckgegeben;  #
+ * # das kann mittels der Funktion kto_check_blz2() erfolgen.                #
+ * #                                                                         #
+ * # Die Funktion kto_check_regel_dbg() ist das Gegenst�ck zu                #
+ * # kto_check_blz_dbg(); bei dieser Funktion werden zus�tzlich noch einige  #
+ * # interne Werte zur�ckgegeben. Die beiden Variablen blz2 und kto2         #
+ * # m�ssen auf einen Speicherbereich von mindestens 9 bzw. 11 Byte zeigen;  #
+ * # in diese Speicherbereiche werden die neue BLZ bzw. Kontonummer          #
+ * # geschrieben. Praktischerweise sollten dies lokale Variablen der         #
+ * # aufrufenden Funktion sein.                                              #
+ * #                                                                         #
+ * # Parameter:                                                              #
+ * #    blz:        Bankleitzahl (immer 8-stellig)                           #
+ * #    kto:        Kontonummer                                              #
+ * #    blz2:       benutzte BLZ (evl. durch die Regeln modifiziert)         #
+ * #    kto2:       benutzte Kontonummer (evl. modifiziert)                  #
+ * #    bic:        BIC der benutzten Bank                                   #
+ * #    Regel:      benutzte IBAN-Regel                                      #
+ * #    retvals:    Struktur, in der die benutzte Pr�fziffermethode und die  #
+ * #                berechnete Pr�fziffer zur�ckgegeben werden               #
+ * #                                                                         #
+ * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * ###########################################################################
+ */
+DLL_EXPORT int kto_check_regel(char *blz,char *kto);
+DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,const char **bic,int *regel,RETVAL *retvals);
+
 /*
  * ######################################################################
  * # cleanup_kto(): Aufr�umarbeiten                                     #
@@ -689,6 +853,7 @@ DLL_EXPORT int get_lut_info_t(char **info,char *lut_name,KTO_CHK_CTX *ctx);
  * ######################################################################
  */
 DLL_EXPORT const char *get_kto_check_version(void);
+DLL_EXPORT const char *get_kto_check_version_x(int mode);
 
 /*
  * ######################################################################
@@ -791,16 +956,56 @@ DLL_EXPORT int lut_loeschung_i(int b,int zweigstelle,int *retval);
 DLL_EXPORT int lut_nachfolge_blz(char *b,int zweigstelle,int *retval);
 DLL_EXPORT int lut_nachfolge_blz_i(int b,int zweigstelle,int *retval);
 DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int set);
+DLL_EXPORT int lut_iban_regel(char *b,int zweigstelle,int *retval);
+DLL_EXPORT int lut_iban_regel_i(int b,int zweigstelle,int *retval);
+
+/*
+ * ######################################################################
+ * # Suche von Banken nach verschiedenen Kriterien                      #
+ * ######################################################################
+ */
 
-   /* Suche von BLZs */
-DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,char ***base_name,int **blz_base);
-DLL_EXPORT int lut_suche_namen(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,char ***base_name,int **blz_base);
-DLL_EXPORT int lut_suche_namen_kurz(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,char ***base_name,int **blz_base);
-DLL_EXPORT int lut_suche_ort(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,char ***base_name,int **blz_base);
-DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base);
-DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base);
-DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base);
+#define LUT_SUCHE_VOLLTEXT    1
+#define LUT_SUCHE_BIC         2
+#define LUT_SUCHE_NAMEN       3
+#define LUT_SUCHE_NAMEN_KURZ  4
+#define LUT_SUCHE_ORT         5
+#define LUT_SUCHE_BLZ         6
+#define LUT_SUCHE_PLZ         7
+#define LUT_SUCHE_PZ          8
+#define LUT_SUCHE_REGEL       9
+
+   /* Defaultwert f�r sort/uniq bei Suchfunktionen (=> nur eine Zweigstelle
+    * zur�ckgeben) (betrifft nur PHP, Perl und Ruby, bei denen der Parameter
+    * weggelassen werden kann).
+    *
+    * F�r Perl gibt es eine eigene Definition, da sort und uniq bis einschlie�lich
+    * Version 4.1 nicht unterst�tzt wurden. Mit der Standarddefinition von
+    * UNIQ_DEFAULT (2) w�rde sich eine �nderung im Verhalten ergeben,
+    * die so nicht erw�nscht ist.
+    */
+#define UNIQ_DEFAULT 2
+#define UNIQ_DEFAULT_PERL 0
+
+DLL_EXPORT int kto_check_idx2blz(int idx,int *zweigstelle,int *retval);
 DLL_EXPORT int konto_check_idx2blz(int idx,int *zweigstelle,int *retval);
+DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,char ***base_name,int **blz_base);
+DLL_EXPORT int lut_suche_namen(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,char ***base_name,int **blz_base);
+DLL_EXPORT int lut_suche_namen_kurz(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,char ***base_name,int **blz_base);
+DLL_EXPORT int lut_suche_ort(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,char ***base_name,int **blz_base);
+DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base);
+DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base);
+DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base);
+DLL_EXPORT int lut_suche_regel(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base);
+DLL_EXPORT int lut_suche_volltext(char *such_wort,int *anzahl,int *base_name_idx,char ***base_name,int *zweigstellen_anzahl,int **start_idx,int **zweigstellen_base,int **blz_base);
+DLL_EXPORT int lut_suche_multiple(char *such_worte,int uniq,char *such_cmd,UINT4 *anzahl,UINT4 **zweigstellen,UINT4 **blz);
+DLL_EXPORT int lut_suche_sort1(int anzahl,int *blz_base,int *zweigstellen_base,int *idx,int *anzahl_o,int **idx_op,int **cnt_o,int uniq);
+DLL_EXPORT int lut_suche_sort2(int anzahl,int *blz,int *zweigstellen,int *anzahl_o,int **blz_op,int **zweigstellen_op,int **cnt_o,int uniq);
+DLL_EXPORT int lut_suche_init(int uniq);
+DLL_EXPORT int lut_suche_free(int id);
+DLL_EXPORT int lut_suche_set(int such_id,int idx,int typ,int i1,int i2,char *txt);
+DLL_EXPORT int lut_suche(int such_id,char *such_cmd,UINT4 *such_cnt,UINT4 **filiale,UINT4 **blz);
+DLL_EXPORT int lut_blocks(int mode,char **lut_filename,char **lut_blocks_ok,char **lut_blocks_fehler);
 
    /* (Benutzerdefinierte) Default-Werte in der LUT-Datei lesen und schreiben */
 #define DEFAULT_CNT 50                 /* Anzahl Eintr�ge (fest) */
@@ -816,9 +1021,12 @@ DLL_EXPORT int kto_check_write_default(char *lutfile,int block_id);
 DLL_EXPORT int lut_cleanup(void);
 
    /* IBAN-Sachen */
+DLL_EXPORT int ci_check(char *ci);
 DLL_EXPORT int iban_check(char *iban,int *retval);
 DLL_EXPORT const char *iban2bic(char *iban,int *retval,char *blz,char *kto);
 DLL_EXPORT char *iban_gen(char *kto,char *blz,int *retval);
+DLL_EXPORT char *iban_bic_gen(char *blz,char *kto,const char **bicp,char *blz2,char *kto2,int *retval);
+DLL_EXPORT char *iban_bic_gen1(char *blz,char *kto,const char **bicp,int *retval);
 DLL_EXPORT int ipi_gen(char *zweck,char *dst,char *papier);
 DLL_EXPORT int ipi_check(char *zweck);
 
@@ -848,6 +1056,9 @@ const DLL_EXPORT char *pz2str(int pz,int *ret);
 DLL_EXPORT_V extern UINT4 current_date;
 #endif
 
+   /* String mit den LUT-Blocks, die nicht geladen werden konnten */
+DLL_EXPORT_V extern char *lut_blocks_missing;
+
 /*
  * ######################################################################
  * # die folgenden globalen Variablen waren in Version 1 und 2 von      #

data/ext/konto_check_raw/konto_check_raw_ruby.c

@@ -1,12 +1,14 @@
+/* encoding=utf-8
+vim: ft=c:set si:set fileencoding=utf-8
+ */
+
 /*==================================================================
  *
  * KontoCheck Module, C Ruby Extension
  *
- * Copyright (c) 2010 Provideal Systems GmbH
- *
- * Peter Horn, peter.horn@provideal.net
- *
- * many extensions by Michael Plugge, m.plugge@hs-mannheim.de
+ * Copyright (c) 2010-2012 Peter Horn <peter.horn@provideal.net>,
+ *             Jan Schwenzien <jan@schwenzien.org>
+ *             Michael Plugge <m.plugge@hs-mannheim.de>
  *
  * ------------------------------------------------------------------
  *
@@ -41,6 +43,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#line 54 "konto_check_raw_ruby.lxx"
 // Include the Ruby headers and goodies
 #include "ruby.h"
 #include <stdio.h>
@@ -68,6 +71,10 @@
 // Defining a space for information and references about the module to be stored internally
 VALUE KontoCheck = Qnil;
 
+   /* generische Suchfunktionen für alle einfachen Suchroutinen */
+static VALUE bank_suche_int(int argc,VALUE* argv,VALUE self,int (*suchfkt)(char*,int*,int**,int**,char***,int**),
+   int (*suchfkt_i)(int,int,int*,int**,int**,int**,int**));
+
 /**
  * get_params_file()
  *
@@ -164,9 +171,9 @@ static void get_params_file(int argc,VALUE* argv,char *arg1s,int *arg1i,int *arg
       *arg1s=0;
    }
    else if(TYPE(v1_rb)==RUBY_T_STRING){
-      strncpy(arg1s,RSTRING_PTR(v1_rb),FILENAME_MAX);
          /* der Ruby-String ist nicht notwendig null-terminiert; manuell erledigen */
       if((len=RSTRING_LEN(v1_rb))>FILENAME_MAX)len=FILENAME_MAX;
+      strncpy(arg1s,RSTRING_PTR(v1_rb),len);
       *(arg1s+len)=0;
    }
    else
@@ -178,13 +185,17 @@ static void get_params_file(int argc,VALUE* argv,char *arg1s,int *arg1i,int *arg
  *
  * extract two numeric params from argc/argv (for integer search functions)
  */
-static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2)
+
+#define BUFLEN_GET_PARAMS 127
+static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2,int *uniq_p)
 {
-   char buffer[16];
-   int len,cnt;
-   VALUE arg1_rb,arg2_rb,*arr_ptr;
+   char *ptr,buffer[BUFLEN_GET_PARAMS+1];
+   int len,cnt,arg2_set,uniq,sort,tmp;
+   VALUE arg1_rb,arg2_rb,arg3_rb,arg4_rb,*arr_ptr;
 
-   rb_scan_args(argc,argv,"11",&arg1_rb,&arg2_rb);
+   *arg1=*arg2=arg2_set=0;
+   uniq=sort=-1;
+   rb_scan_args(argc,argv,"13",&arg1_rb,&arg2_rb,&arg3_rb,&arg4_rb);
 
          /* Falls als erster Parameter ein Array übergeben wird, wird der erste
           * Wert werden als Minimal- und der zweite als Maximalwert genommen.
@@ -192,6 +203,8 @@ static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2)
    if(TYPE(arg1_rb)==RUBY_T_ARRAY){
       cnt=RARRAY_LEN(arg1_rb);      /* Anzahl Werte */
       arr_ptr=RARRAY_PTR(arg1_rb);  /* Pointer auf die Array-Daten */
+      arg3_rb=arg2_rb;
+      arg4_rb=arg3_rb;
       switch(cnt){
          case 0:
             arg1_rb=arg2_rb=Qnil;
@@ -208,27 +221,68 @@ static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2)
    }
 
    if(NIL_P(arg1_rb))
-      *arg1=0;
+      *arg1=-1;
    else if(TYPE(arg1_rb)==RUBY_T_STRING){
-      strncpy(buffer,RSTRING_PTR(arg1_rb),15);
          /* der Ruby-String ist nicht notwendig null-terminiert; manuell erledigen */
-      if((len=RSTRING_LEN(arg1_rb))>15)len=15;
+      if((len=RSTRING_LEN(arg1_rb))>BUFLEN_GET_PARAMS)len=BUFLEN_GET_PARAMS;
+      strncpy(buffer,RSTRING_PTR(arg1_rb),len);
       *(buffer+len)=0;
       *arg1=atoi(buffer);
+         /* Bereichsangabe wert1-wert2 */
+      for(ptr=buffer;*ptr && *ptr!='-';ptr++);
+      if(*ptr=='-'){
+         *arg2=atoi(ptr+1);
+         arg2_set=1;
+      }
    }
    else
       *arg1=NUM2INT(arg1_rb);
 
-   if(NIL_P(arg2_rb))
-      *arg2=*arg1;
-   else if(TYPE(arg2_rb)==RUBY_T_STRING){
-      strncpy(buffer,RSTRING_PTR(arg2_rb),15);
-      if((len=RSTRING_LEN(arg2_rb))>15)len=15;
-      *(buffer+len)=0;
-      *arg2=atoi(buffer);
+   if(!NIL_P(arg2_rb)){
+      if(TYPE(arg2_rb)==RUBY_T_STRING){
+         if((len=RSTRING_LEN(arg2_rb))>BUFLEN_GET_PARAMS)len=BUFLEN_GET_PARAMS;
+         strncpy(buffer,RSTRING_PTR(arg2_rb),len);
+         *(buffer+len)=0;
+         tmp=atoi(buffer);
+         if(!arg2_set)
+            *arg2=tmp;
+         else{ /* *arg2 wurde schon mit arg1 gesetzt; jetzt kommt uniq */
+            if(tmp>0)
+               uniq=2;
+            else if(tmp<=0)
+               uniq=0;
+         }
+      }
+      else{
+         if(!arg2_set)
+            *arg2=NUM2INT(arg2_rb);
+         else
+            uniq=NUM2INT(arg2_rb);
+      }
+   }
+
+   if(!NIL_P(arg3_rb)){
+      if(uniq<0){
+         if((tmp=NUM2INT(arg3_rb))>0)
+            uniq=2;
+         else if(tmp<=0)
+            uniq=0;
+      }
+      else
+         sort=NUM2INT(arg3_rb);
    }
+
+   if(!NIL_P(arg4_rb) && sort<0)sort=NUM2INT(arg4_rb); /* das kann nur noch sort sein */
+
+   if(uniq>0)
+      uniq=2;
+   else if(sort>0)
+      uniq=1;
+   else if(uniq<0 && sort<0)
+      uniq=UNIQ_DEFAULT;
    else
-      *arg2=NUM2INT(arg2_rb);
+      uniq=0;
+   if(uniq_p)*uniq_p=uniq;
 }
 
 /**
@@ -238,8 +292,8 @@ static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2)
  */
 static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,int *argi,int arg_mode)
 {
-   int len,maxlen=9;
-   VALUE arg1_rb,arg2_rb,arg3_rb;
+   int len,maxlen=9,sort=-1,uniq=-1,tmp;
+   VALUE arg1_rb,arg2_rb,arg3_rb,arg4_rb;
 
    switch(arg_mode){
       case 0:  /* ein notwendiger Parameter (für lut_filialen und lut_pz) */
@@ -258,7 +312,7 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
          rb_scan_args(argc,argv,"20",&arg1_rb,&arg2_rb);
          break;
 
-      case 3:  /* ein notwendiger Parameter (für iban_check) */
+      case 3:  /* ein notwendiger Parameter (für iban_check und ci_check) */
          rb_scan_args(argc,argv,"10",&arg1_rb);
          maxlen=128;
          break;
@@ -272,14 +326,29 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
          rb_scan_args(argc,argv,"21",&arg1_rb,&arg2_rb,&arg3_rb);
          break;
 
+      case 6:  /* ein notwendiger, zwei optionale Parameter (für bank_suche_multiple()) */
+         rb_scan_args(argc,argv,"12",&arg1_rb,&arg2_rb,&arg3_rb);
+         maxlen=1280;
+         break;
+
+      case 7:  /* ein notwendiger, bis zu drei optionale Parameter (für die meisten Suchroutinen) */
+         rb_scan_args(argc,argv,"13",&arg1_rb,&arg2_rb,&arg3_rb,&arg4_rb);
+         maxlen=128;
+         break;
+      case 8:  /* ein notwendiger Parameter (für bic_check) */
+         rb_scan_args(argc,argv,"10",&arg1_rb);
+         maxlen=11;
+         break;
+
+
       default:
          break;
    }
 
    switch(TYPE(arg1_rb)){
       case RUBY_T_STRING:
-         strncpy(arg1s,RSTRING_PTR(arg1_rb),maxlen);
          if((len=RSTRING_LEN(arg1_rb))>maxlen)len=maxlen;
+         strncpy(arg1s,RSTRING_PTR(arg1_rb),len);
          *(arg1s+len)=0;
          break;
       case RUBY_T_FLOAT:
@@ -304,8 +373,8 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
    }
    if(arg_mode==2 || arg_mode==5)switch(TYPE(arg2_rb)){  /* für konto_check() und iban_gen(): kto holen */
       case RUBY_T_STRING:
-         strncpy(arg2s,RSTRING_PTR(arg2_rb),15);
          if((len=RSTRING_LEN(arg2_rb))>15)len=15;
+         strncpy(arg2s,RSTRING_PTR(arg2_rb),len);
          *(arg2s+len)=0;
          break;
       case RUBY_T_FLOAT:
@@ -323,8 +392,8 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
       else
          switch(TYPE(arg3_rb)){
             case RUBY_T_STRING:
-               strncpy(arg3s,RSTRING_PTR(arg3_rb),15);
                if((len=RSTRING_LEN(arg3_rb))>15)len=15;
+               strncpy(arg3s,RSTRING_PTR(arg3_rb),len);
                *(arg3s+len)=0;
                break;
             case RUBY_T_FLOAT:
@@ -337,33 +406,117 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
                break;
          }
    }
+   if(arg_mode==6 || arg_mode==7){  /* für lut_suche(): uniq und such_cmd holen */
+      if(argi)*argi=-1;      /* Flag für uniq: noch nicht gesetzt */
+      if(arg2s)*arg2s=0;
+      if(!NIL_P(arg2_rb))switch(TYPE(arg2_rb)){  /* uniq ist immer Integer, such_cmd immer String */
+         case RUBY_T_STRING:
+            if(arg2s){
+               if((len=RSTRING_LEN(arg2_rb))>255)len=255;
+               strncpy(arg2s,RSTRING_PTR(arg2_rb),len);
+               *(arg2s+len)=0;
+            }
+            break;
+         case RUBY_T_FLOAT:
+         case RUBY_T_FIXNUM:
+         case RUBY_T_BIGNUM:
+            tmp=NUM2INT(arg2_rb);
+            if(tmp>=0)uniq=tmp;
+            break;
+         default:
+            rb_raise(rb_eTypeError,"Unable to convert given variable to integer or string");
+            break;
+      }
+
+      if(!NIL_P(arg3_rb))switch(TYPE(arg3_rb)){ /* Parameter uniq oder such_cmd (je nach Typ) */
+         case RUBY_T_STRING:  /* such_cmd */
+            if(arg2s){
+               if((len=RSTRING_LEN(arg3_rb))>255)len=255;
+               strncpy(arg2s,RSTRING_PTR(arg3_rb),len);
+               *(arg2s+len)=0;
+            }
+            break;
+         case RUBY_T_FLOAT:
+         case RUBY_T_FIXNUM:
+         case RUBY_T_BIGNUM:
+            tmp=NUM2INT(arg3_rb);
+            if(tmp>=0){
+               if(uniq<0)
+                  uniq=tmp;
+               else
+                  sort=tmp;
+            }
+            break;
+         default:
+            rb_raise(rb_eTypeError,"Unable to convert given variable to integer or string");
+            break;
+      }
+
+      if(!NIL_P(arg4_rb))switch(TYPE(arg4_rb)){ /* Parameter sort */
+         case RUBY_T_STRING:
+            break;   /* String-Variable ignorieren; der Parameter muß numerisch sein!!! */
+         case RUBY_T_FLOAT:
+         case RUBY_T_FIXNUM:
+         case RUBY_T_BIGNUM:
+            tmp=NUM2INT(arg4_rb);
+            if(tmp>=0){
+               if(uniq<0)
+                  uniq=tmp;
+               else
+                  sort=tmp;
+            }
+            break;
+         default:
+            rb_raise(rb_eTypeError,"Unable to convert given variable to integer or string");
+            break;
+      }
+      if(uniq>0)
+         uniq=2;
+      else if(sort>0)
+         uniq=1;
+      else if(uniq<0 && sort<0)
+         uniq=UNIQ_DEFAULT;
+      else
+         uniq=0;
+      if(argi)*argi=uniq;
+   }
 }
 
 /**
- * ===<tt>KontoCheckRaw::konto_check_pz(pz,kto)</tt>
- * =====<tt>KontoCheck::konto_check_pz(pz,kto)</tt>
+ * ===KontoCheckRaw::konto_check_pz( pz, kto [,blz])
+ * =====KontoCheck::konto_check_pz( pz, kto [,blz])
  *
  * Diese Funktion testet, ob eine gegebene Prüfziffer/Kontonummer-Kombination gültig ist.
  * 
- * Der zusätzliche Parameter blz ist nur für die Verfahren 52, 53, B6 und C0 notwendig; bei
- * diesen Verfahren geht die BLZ in die Berechnung der Prüfziffer ein. Bei allen anderen
- * Prüfzifferverfahren wird er ignoriert. Wird er bei einem dieser Verfahren nicht angegeben,
- * wird stattdessen eine Test-BLZ eingesetzt.
- * 
- * Die Funktion gibt einen skalaren Statuswert zurück, der das Ergebnis der
- * Prüfung enthält. Mögliche Rückgabewerte sind:
- *
- *     -77  (BAV_FALSE)               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
- *     -69  (MISSING_PARAMETER)       "bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
- *     -40  (LUT2_NOT_INITIALIZED)    "die Programmbibliothek wurde noch nicht initialisiert"
- *     -29  (UNDEFINED_SUBMETHOD)     "die (Unter)Methode ist nicht definiert"
- *     -12  (INVALID_KTO_LENGTH)      "ein Konto muß zwischen 1 und 10 Stellen haben"
- *      -3  (INVALID_KTO)             "das Konto ist ungültig"
- *      -2  (NOT_IMPLEMENTED)         "die Methode wurde noch nicht implementiert"
- *      -1  (NOT_DEFINED)             "die Methode ist nicht definiert"
- *       0  (FALSE)                   "falsch"
- *       1  (OK)                      "ok"
- *       2  (OK_NO_CHK)               "ok, ohne Prüfung"
+ * ====Aufruf:
+ * ret=KontoCheckRaw::konto_check_pz( pz, kto [,blz])
+ *
+ * ====Parameter:
+ * * pz: Prüfzifferverfahren das benutzt werden soll
+ * * kto: Kontonummer die getestet werden soll
+ * * blz: Dieser Parameter ist nur für die Verfahren 52, 53, B6 und C0
+ *   notwendig; bei allen anderen Prüfzifferverfahren wird er ignoriert. Bei
+ *   diesen Verfahren geht die BLZ in die Berechnung der Prüfziffer ein.
+ *   Wird der Parameter bei einem dieser Verfahren nicht angegeben, wird
+ *   stattdessen eine Test-BLZ (wie in der Beschreibung der Prüfziffermethoden
+ *   von der Deutschen Bundesbank angegeben) eingesetzt.
+ * 
+ * ====Rückgabe:
+ * Die Funktion gibt einen skalaren Statuscode zurück, der das Ergebnis der
+ * Prüfung enthält.
+ *
+ * ====Mögliche Statuscodes:
+ * * -77  (BAV_FALSE)               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
+ * * -69  (MISSING_PARAMETER)       "bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
+ * * -40  (LUT2_NOT_INITIALIZED)    "die Programmbibliothek wurde noch nicht initialisiert"
+ * * -29  (UNDEFINED_SUBMETHOD)     "die (Unter)Methode ist nicht definiert"
+ * * -12  (INVALID_KTO_LENGTH)      "ein Konto muß zwischen 1 und 10 Stellen haben"
+ * *  -3  (INVALID_KTO)             "das Konto ist ungültig"
+ * *  -2  (NOT_IMPLEMENTED)         "die Methode wurde noch nicht implementiert"
+ * *  -1  (NOT_DEFINED)             "die Methode ist nicht definiert"
+ * *   0  (FALSE)                   "falsch"
+ * *   1  (OK)                      "ok"
+ * *   2  (OK_NO_CHK)               "ok, ohne Prüfung"
  */
 static VALUE konto_check_pz(int argc,VALUE* argv,VALUE self)
 {
@@ -376,24 +529,34 @@ static VALUE konto_check_pz(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::konto_check(blz,kto)</tt>
- * =====<tt>KontoCheck::konto_check(blz,kto)</tt>
- * Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält. Die Funktion gibt einen skalaren
- * Statuswert zurück, der das Ergebnis der Prüfung enthält. Mögliche Rückgabewerte sind:
- * 
- *    -77  BAV_FALSE               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
- *    -69  MISSING_PARAMETER       "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
- *    -40  LUT2_NOT_INITIALIZED    "die Programmbibliothek wurde noch nicht initialisiert"
- *    -29  UNDEFINED_SUBMETHOD     "Die (Unter)Methode ist nicht definiert"
- *    -12  INVALID_KTO_LENGTH      "ein Konto muß zwischen 1 und 10 Stellen haben"
- *     -5  INVALID_BLZ_LENGTH      "die Bankleitzahl ist nicht achtstellig"
- *     -4  INVALID_BLZ             "die Bankleitzahl ist ungültig"
- *     -3  INVALID_KTO             "das Konto ist ungültig"
- *     -2  NOT_IMPLEMENTED         "die Methode wurde noch nicht implementiert"
- *     -1  NOT_DEFINED             "die Methode ist nicht definiert"
- *      0  FALSE                   "falsch"
- *      1  OK                      "ok"
- *      2  OK_NO_CHK               "ok, ohne Prüfung"
+ * ===KontoCheckRaw::konto_check( blz, kto)
+ * =====KontoCheck::konto_check( blz, kto)
+ * Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.
+ *
+ * ====Aufruf:
+ * ret=KontoCheckRaw::konto_check( blz, kto)
+ *
+ * ====Parameter:
+ * * blz: Die Bankleitzahl der zu testenden Bankverbindung
+ * * kto: Die Kontonummer der zu testenden Bankverbindung
+ * 
+ * ====Rückgabe:
+ * Rückgabe ist ein skalarer Statuswert, der das Ergebnis der Prüfung enthält.
+ *
+ * ====Mögliche Statuscodes:
+ * *  -77  BAV_FALSE               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
+ * *  -69  MISSING_PARAMETER       "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
+ * *  -40  LUT2_NOT_INITIALIZED    "die Programmbibliothek wurde noch nicht initialisiert"
+ * *  -29  UNDEFINED_SUBMETHOD     "Die (Unter)Methode ist nicht definiert"
+ * *  -12  INVALID_KTO_LENGTH      "ein Konto muß zwischen 1 und 10 Stellen haben"
+ * *   -5  INVALID_BLZ_LENGTH      "die Bankleitzahl ist nicht achtstellig"
+ * *   -4  INVALID_BLZ             "die Bankleitzahl ist ungültig"
+ * *   -3  INVALID_KTO             "das Konto ist ungültig"
+ * *   -2  NOT_IMPLEMENTED         "die Methode wurde noch nicht implementiert"
+ * *   -1  NOT_DEFINED             "die Methode ist nicht definiert"
+ * *    0  FALSE                   "falsch"
+ * *    1  OK                      "ok"
+ * *    2  OK_NO_CHK               "ok, ohne Prüfung"
  */
 static VALUE konto_check(int argc,VALUE* argv,VALUE self)
 {
@@ -409,79 +572,337 @@ static VALUE konto_check(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::init([<p1>[,<p2>[,<set>]]])</tt>
- * =====<tt>KontoCheck::init([<p1>[,<p2>[,<set>]]])</tt>
- * Die Variablen p1 und p2 stehen für level und lutfile (in beliebiger
- * Reihenfolge); die Zuordnung der beiden Parameter erfolgt on the fly durch
- * eine Typüberprüfung.
- *
+ * ===KontoCheckRaw::konto_check_regel( blz, kto)
+ * =====KontoCheckRaw::konto_check_regel_dbg( blz, kto)
+ * =====KontoCheck::konto_check_regel( blz, kto)
+ * =====KontoCheck::konto_check_regel?( blz, kto)
+ * Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.
+ * Vor der Prüfung werden die IBAN-Regeln angewendet; dabei wird u.U.
+ * BLZ und/oder Kontonummer ersetzt.
+ *
+ * ====Aufruf:
+ * ret=KontoCheckRaw::konto_check_regel( blz, kto)
+ *
+ * ====Parameter:
+ * * blz: Die Bankleitzahl der zu testenden Bankverbindung
+ * * kto: Die Kontonummer der zu testenden Bankverbindung
+ * 
+ * ====Rückgabe:
+ * Rückgabe ist ein skalarer Statuswert, der das Ergebnis der Prüfung enthält.
+ * Es sind auch die Rückgabewerte der Initialisierung möglich (wegen iban_init()),
+ * deshalb gibt es so viele mögliche Rückgabewerte.
+ *
+ * ====Mögliche Statuscodes:
+ * *  -135  FALSE_UNTERKONTO_ATTACHED "falsch, es wurde ein Unterkonto hinzugefügt (IBAN-Regel)"
+ * *  -133  BLZ_MARKED_AS_DELETED     "Die BLZ ist in der Bundesbank-Datei als gelöscht markiert und somit ungültig"
+ * *  -128  IBAN_INVALID_RULE         "Die BLZ passt nicht zur angegebenen IBAN-Regel"
+ * *  -127  IBAN_AMBIGUOUS_KTO        "Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten)"
+ * *  -125  IBAN_RULE_UNKNOWN         "Die IBAN-Regel ist nicht bekannt"
+ * *  -124  NO_IBAN_CALCULATION       "Für die Bankverbindung ist keine IBAN-Berechnung erlaubt"
+ * *  -112  KTO_CHECK_UNSUPPORTED_COMPRESSION "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
+ * *   -77  BAV_FALSE                 "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
+ * *   -69  MISSING_PARAMETER         "Für die aufgerufene Funktion fehlt ein notwendiger Parameter"
+ * *   -64  INIT_FATAL_ERROR          "Initialisierung fehlgeschlagen (init_wait geblockt)"
+ * *   -63  INCREMENTAL_INIT_NEEDS_INFO "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
+ * *   -62  INCREMENTAL_INIT_FROM_DIFFERENT_FILE "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
+ * *   -40  LUT2_NOT_INITIALIZED      "die Programmbibliothek wurde noch nicht initialisiert"
+ * *   -38  LUT2_PARTIAL_OK           "es wurden nicht alle Blocks geladen"
+ * *   -36  LUT2_Z_MEM_ERROR          "Memory error in den ZLIB-Routinen"
+ * *   -35  LUT2_Z_DATA_ERROR         "Datenfehler im komprimierten LUT-Block"
+ * *   -34  LUT2_BLOCK_NOT_IN_FILE    "Der Block ist nicht in der LUT-Datei enthalten"
+ * *   -33  LUT2_DECOMPRESS_ERROR     "Fehler beim Dekomprimieren eines LUT-Blocks"
+ * *   -31  LUT2_FILE_CORRUPTED       "Die LUT-Datei ist korrumpiert"
+ * *   -29  UNDEFINED_SUBMETHOD       "Die (Unter)Methode ist nicht definiert"
+ * *   -20  LUT_CRC_ERROR             "Prüfsummenfehler in der blz.lut Datei"
+ * *   -12  INVALID_KTO_LENGTH        "ein Konto muß zwischen 1 und 10 Stellen haben"
+ * *   -10  FILE_READ_ERROR           "kann Datei nicht lesen"
+ * *    -9  ERROR_MALLOC              "kann keinen Speicher allokieren"
+ * *    -7  INVALID_LUT_FILE          "die blz.lut Datei ist inkosistent/ungültig"
+ * *    -6  NO_LUT_FILE               "die blz.lut Datei wurde nicht gefunden"
+ * *    -5  INVALID_BLZ_LENGTH        "die Bankleitzahl ist nicht achtstellig"
+ * *    -4  INVALID_BLZ               "die Bankleitzahl ist ungültig"
+ * *    -3  INVALID_KTO               "das Konto ist ungültig"
+ * *    -2  NOT_IMPLEMENTED           "die Methode wurde noch nicht implementiert"
+ * *    -1  NOT_DEFINED               "die Methode ist nicht definiert"
+ * *     0  FALSE                     "falsch"
+ * *     1  OK                        "ok"
+ * *     1  OK                        "ok"
+ * *     2  OK_NO_CHK                 "ok, ohne Prüfung"
+ * *     6  LUT1_SET_LOADED           "Die Datei ist im alten LUT-Format (1.0/1.1)"
+ * *    18  OK_KTO_REPLACED           "ok, die Kontonummer wurde allerdings ersetzt"
+ * *    21  OK_IBAN_WITHOUT_KC_TEST   "ok, die Bankverbindung ist (ohne Test) als richtig anzusehen"
+ * *    25  OK_UNTERKONTO_ATTACHED    "ok, es wurde ein (weggelassenes) Unterkonto angefügt"
+ */
+static VALUE konto_check_regel(int argc,VALUE* argv,VALUE self)
+{
+   char kto[16],blz[16],error_msg[512];
+   int retval;
+
+   get_params(argc,argv,blz,kto,NULL,NULL,2);
+   if((retval=kto_check_regel(blz,kto))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
+   return INT2FIX(retval);
+}
+
+/**
+ * ===KontoCheckRaw::konto_check_regel_dbg( blz, kto)
+ * =====KontoCheckRaw::konto_check_regel( blz, kto)
+ * =====KontoCheck::konto_check_regel( blz, kto)
+ * =====KontoCheck::konto_check_regel?( blz, kto)
+ * Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.
+ * Vor der Prüfung werden die IBAN-Regeln angewendet; dabei wird u.U.
+ * BLZ und/oder Kontonummer ersetzt. Die Funktion gibt viele Interna
+ * zurück und ist daher nur in der KontoCheckRaw:: Bibliothek enthalten.
+ *
+ * ====Aufruf:
+ * ret=KontoCheckRaw::konto_check_regel_dbg( blz, kto)
+ *
+ * ====Parameter:
+ * * blz: Die Bankleitzahl der zu testenden Bankverbindung
+ * * kto: Die Kontonummer der zu testenden Bankverbindung
+ * 
+ * ====Rückgabe:
+ * Rückgabe ist ein Array mit 10 Elementen, der das Ergebnis der Prüfung sowie eine Reihe
+ * interner Werte enthält. Für den Statuscode sind auch die Rückgabewerte der Initialisierung
+ * möglich (wegen iban_init()), deshalb gibt es so viele mögliche Werte.
+ * * das erste Element enthält den Statuscode
+ * * das zweite Element enthält die benutzte BLZ (die BLZ wird durch die IBAN-Regeln u.U. ersetzt)
+ * * das dritte Element enthält die benutzte Kontonummer (wird manchmal auch ersetzt)
+ * * das vierte Element enthält den BIC der Bank
+ * * das fünfte Element enthält die benutzte IBAN-Regel
+ * * das sechste Element enthält die Regel-Version
+ * * das siebte Element enthält Prüfziffermethode als Text
+ * * das achte Element enthält die Prüfziffermethode (numerisch)
+ * * das neunte Element enthält die Prüfziffer
+ * * das zehnte Element enthält die Position der Prüfziffer
+ *
+ * ====Mögliche Statuscodes:
+ * *  -135  FALSE_UNTERKONTO_ATTACHED "falsch, es wurde ein Unterkonto hinzugefügt (IBAN-Regel)"
+ * *  -133  BLZ_MARKED_AS_DELETED     "Die BLZ ist in der Bundesbank-Datei als gelöscht markiert und somit ungültig"
+ * *  -128  IBAN_INVALID_RULE         "Die BLZ passt nicht zur angegebenen IBAN-Regel"
+ * *  -127  IBAN_AMBIGUOUS_KTO        "Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten)"
+ * *  -125  IBAN_RULE_UNKNOWN         "Die IBAN-Regel ist nicht bekannt"
+ * *  -124  NO_IBAN_CALCULATION       "Für die Bankverbindung ist keine IBAN-Berechnung erlaubt"
+ * *  -112  KTO_CHECK_UNSUPPORTED_COMPRESSION "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
+ * *   -77  BAV_FALSE                 "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
+ * *   -69  MISSING_PARAMETER         "Für die aufgerufene Funktion fehlt ein notwendiger Parameter"
+ * *   -64  INIT_FATAL_ERROR          "Initialisierung fehlgeschlagen (init_wait geblockt)"
+ * *   -63  INCREMENTAL_INIT_NEEDS_INFO "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
+ * *   -62  INCREMENTAL_INIT_FROM_DIFFERENT_FILE "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
+ * *   -40  LUT2_NOT_INITIALIZED      "die Programmbibliothek wurde noch nicht initialisiert"
+ * *   -38  LUT2_PARTIAL_OK           "es wurden nicht alle Blocks geladen"
+ * *   -36  LUT2_Z_MEM_ERROR          "Memory error in den ZLIB-Routinen"
+ * *   -35  LUT2_Z_DATA_ERROR         "Datenfehler im komprimierten LUT-Block"
+ * *   -34  LUT2_BLOCK_NOT_IN_FILE    "Der Block ist nicht in der LUT-Datei enthalten"
+ * *   -33  LUT2_DECOMPRESS_ERROR     "Fehler beim Dekomprimieren eines LUT-Blocks"
+ * *   -31  LUT2_FILE_CORRUPTED       "Die LUT-Datei ist korrumpiert"
+ * *   -29  UNDEFINED_SUBMETHOD       "Die (Unter)Methode ist nicht definiert"
+ * *   -20  LUT_CRC_ERROR             "Prüfsummenfehler in der blz.lut Datei"
+ * *   -12  INVALID_KTO_LENGTH        "ein Konto muß zwischen 1 und 10 Stellen haben"
+ * *   -10  FILE_READ_ERROR           "kann Datei nicht lesen"
+ * *    -9  ERROR_MALLOC              "kann keinen Speicher allokieren"
+ * *    -7  INVALID_LUT_FILE          "die blz.lut Datei ist inkosistent/ungültig"
+ * *    -6  NO_LUT_FILE               "die blz.lut Datei wurde nicht gefunden"
+ * *    -5  INVALID_BLZ_LENGTH        "die Bankleitzahl ist nicht achtstellig"
+ * *    -4  INVALID_BLZ               "die Bankleitzahl ist ungültig"
+ * *    -3  INVALID_KTO               "das Konto ist ungültig"
+ * *    -2  NOT_IMPLEMENTED           "die Methode wurde noch nicht implementiert"
+ * *    -1  NOT_DEFINED               "die Methode ist nicht definiert"
+ * *     0  FALSE                     "falsch"
+ * *     1  OK                        "ok"
+ * *     1  OK                        "ok"
+ * *     2  OK_NO_CHK                 "ok, ohne Prüfung"
+ * *     6  LUT1_SET_LOADED           "Die Datei ist im alten LUT-Format (1.0/1.1)"
+ * *    18  OK_KTO_REPLACED           "ok, die Kontonummer wurde allerdings ersetzt"
+ * *    21  OK_IBAN_WITHOUT_KC_TEST   "ok, die Bankverbindung ist (ohne Test) als richtig anzusehen"
+ * *    25  OK_UNTERKONTO_ATTACHED    "ok, es wurde ein (weggelassenes) Unterkonto angefügt"
+ */
+static VALUE konto_check_regel_dbg(int argc,VALUE* argv,VALUE self)
+{
+   char kto[16],blz[16],kto2[16],blz2[16],error_msg[512];
+   const char *bic2;
+   int retval,regel;
+   RETVAL rv;
+
+   get_params(argc,argv,blz,kto,NULL,NULL,2);
+   if((retval=kto_check_regel_dbg(blz,kto,blz2,kto2,&bic2,&regel,&rv))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
+   return rb_ary_new3(10,INT2FIX(retval),rb_str_new2(blz2),rb_str_new2(kto2),rb_str_new2(bic2),INT2FIX(regel/100),INT2FIX(regel%100),
+         rv.methode?rb_str_new2(rv.methode):Qnil,INT2FIX(rv.pz_methode),INT2FIX(rv.pz),INT2FIX(rv.pz_pos));
+}
+
+/**
+ * ===KontoCheckRaw::lut_blocks( mode)
+ * =====KontoCheck::lut_blocks( mode)
+ * Die Funktion gibt Auskunft, ob bei der Initialisierung alle angeforderten
+ * Blocks der LUT-Datei geladen wurden und gibt den Dateinamen der LUT-Datei,
+ * eine Liste der geladenen Blocks sowie eine Liste der Blocks die nicht
+ * geladen werden konnten, zurück.
+ *
+ * ====Aufruf:
+ * ret=KontoCheckRaw::lut_blocks( mode)
+ *
+ * ====Parameter:
+ * * mode: Ausgabeformat (1..3)
+ * 
+ * ====Rückgabe:
+ * Rückgabe ist ein Array mit vier Elementen, das den Statuscode sowie drei Strings
+ * mit dem Dateinamen sowie den Blocklisten enthält:
+ * 
+ * * das erste Element enthält den Statuscode
+ * * das zweite Element enthält den Dateinamen der verwendeten LUT-Datei
+ * * das dritte Element enthält eine Liste der geladenen LUT-Blocks
+ * * das vierte Element enthält eine Liste der LUT-Blocks, die nicht geladen werden konnten
+ *
+ * ====Mögliche Statuscodes:
+ * * -136  LUT2_BLOCKS_MISSING       "ok, bei der Initialisierung konnten allerdings ein oder mehrere Blocks nicht geladen werden"
+ * *  -40  LUT2_NOT_INITIALIZED      "die Programmbibliothek wurde noch nicht initialisiert"
+ * *   -9  ERROR_MALLOC              "kann keinen Speicher allokieren"
+ * *    1  OK                        "ok"
+ */
+static VALUE lut_blocks_rb(int argc,VALUE* argv,VALUE self)
+{
+   char *lut_filename,*lut_blocks_ok,*lut_blocks_fehler;
+   int mode,retval;
+   VALUE mode_rb,filename_rb,blocks_ok_rb,blocks_fehler_rb;
+
+   rb_scan_args(argc,argv,"01",&mode_rb);
+   if(NIL_P(mode_rb))
+      mode=1;
+   else{
+      switch(TYPE(mode_rb)){
+         case RUBY_T_FLOAT:
+         case RUBY_T_FIXNUM:
+         case RUBY_T_BIGNUM:
+            mode=NUM2INT(mode_rb);
+            break;
+         default:
+            mode=1;
+            rb_raise(rb_eTypeError,"lut_blocks() requires an int parameter");
+            break;
+      }
+   }
+
+   if((retval=lut_blocks(mode,&lut_filename,&lut_blocks_ok,&lut_blocks_fehler))==LUT2_NOT_INITIALIZED || retval==ERROR_MALLOC)
+      filename_rb=blocks_ok_rb=blocks_fehler_rb=Qnil;
+   else{
+      filename_rb=rb_str_new2(lut_filename);
+      blocks_ok_rb=rb_str_new2(lut_blocks_ok);
+      blocks_fehler_rb=rb_str_new2(lut_blocks_fehler);
+      kc_free(lut_filename);
+      kc_free(lut_blocks_ok);
+      kc_free(lut_blocks_fehler);
+   }
+   return rb_ary_new3(4,INT2FIX(retval),filename_rb,blocks_ok_rb,blocks_fehler_rb);
+}
+
+/**
+ * ===KontoCheckRaw::lut_blocks1( )
+ * =====KontoCheckRaw::lut_blocks( mode)
+ * =====KontoCheck::lut_blocks( )
+ * Diese Funktion entspricht weitgehend der Funktion lut_blocks(); sie
+ * gibt allerdings nur den Statuscode zurück, keine Strings. Sie wird
+ * für die Funktion KontoCheck::lut_blocks() benutzt.
+ * 
+ * ====Parameter:
+ * * keine
+ * 
+ * ====Rückgabe:
+ * Rückgabe ist ein Integerwert, der Aufschluß über den aktuellen Stand der Initialisierung gibt.
+ *
+ * ====Mögliche Statuscodes:
+ * * -136  LUT2_BLOCKS_MISSING       "ok, bei der Initialisierung konnten allerdings ein oder mehrere Blocks nicht geladen werden"
+ * *  -40  LUT2_NOT_INITIALIZED      "die Programmbibliothek wurde noch nicht initialisiert"
+ * *   -9  ERROR_MALLOC              "kann keinen Speicher allokieren"
+ * *    1  OK                        "ok"
+ */
+static VALUE lut_blocks1_rb(int argc,VALUE* argv,VALUE self)
+{
+   rb_scan_args(argc,argv,"0");
+   return INT2FIX(lut_blocks(0,NULL,NULL,NULL));
+}
+
+/**
+ * ===KontoCheckRaw::init( [p1 [,p2 [,set]]])
+ * =====KontoCheck::init( [p1 [,p2 [,set]]])
  * Diese Funktion initialisiert die Bibliothek und lädt die gewünschten
  * Datenblocks in den Speicher. Alle Argumente sind optional; in konto_check.h
  * werden die Defaultwerte definiert.
  *
- * Die beiden ersten Parameter sind der Dateiname und der
- * Initialisierungslevel. Der Dateiname ist immer als String anzugeben, der
- * Initialisierungslevel immer als Zahl, ansonsten wird eine TypeError
- * Exception geworfen. Auf diese Weise ist es problemlos möglich festzustellen,
- * wie die Parameter p1 und p2 den Variablen lutfile und level zuzuordnen
- * sind.
+ * ====Aufruf:
+ * * ret=KontoCheckRaw::init( [p1 [,p2 [,set]]])
+ * =====Beispielsaufrufe:
+ * * ret=KontoCheckRaw::init
+ * * ret=KontoCheckRaw::init( 5)
+ * * ret=KontoCheckRaw::init( "/etc/blz.lut")
+ * * ret=KontoCheckRaw::init( 3,"/etc/blz.lut")
+ * * ret=KontoCheckRaw::init( "/etc/blz.lut",9,2)
+
+ * ====Parameter:
+ * * Die Variablen p1 und p2 stehen für den Initialisierungslevel und den
+ *   Dateinamen der LUT-Datei (in beliebiger Reihenfolge); die Zuordnung der
+ *   beiden Parameter erfolgt on the fly durch eine Typüberprüfung. Der Dateiname
+ *   ist immer als String anzugeben, der Initialisierungslevel immer als Zahl,
+ *   ansonsten gibt es eine TypeError Exception. Auf diese Weise ist es
+ *   eindeutig möglich festzustellen, wie die Parameter p1 und p2 den Variablen
+ *   lutfile und level zuzuordnen sind.
+ * * Der Initialisierungslevel ist eine Zahl zwischen 0 und 9, die die zu ladenden Blocks angibt. Die folgenden Werte sind definiert:
+ *
+ *    0. BLZ,PZ
+ *    1. BLZ,PZ,NAME_KURZ
+ *    2. BLZ,PZ,NAME_KURZ,BIC
+ *    3. BLZ,PZ,NAME,PLZ,ORT
+ *    4. BLZ,PZ,NAME,PLZ,ORT,BIC
+ *    5. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC
+ *    6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ
+ *    7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG
+ *    8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,
+ *       LOESCHUNG
+ *    9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,
+ *       LOESCHUNG,PAN,NR
+ * * Der Parameter set bezeichnet den zu ladenden Datensatz (1 oder 2) der LUT-Datei.
+ *   Falls der Parameter set nicht angegeben oder 0 ist, wird versucht, das aktuell
+ *   gültige Set aus dem Systemdatum und dem Gültigkeitszeitraum der in der
+ *   LUT-Datei gespeicherten Sets zu bestimmen.
  *
  * Für die LUT-Datei ist als Defaultwert sowohl für den Pfad als auch den
  * Dateinamen eine Liste möglich, die sequenziell abgearbeitet wird; diese wird
  * in konto_check.h spezifiziert (Compilerzeit-Konstante der C-Bibliothek). Die
  * folgenden Werte sind in der aktuellen konto_check.h definiert:
  *
- *    DEFAULT_LUT_NAME blz.lut, blz.lut2f, blz.lut2
- *    DEFAULT_LUT_PATH ., /usr/local/etc/, /etc/, /usr/local/bin/, /opt/konto_check/ (für nicht-Windows-Systeme)
- *    DEFAULT_LUT_PATH ., C:, C:\\Programme\\konto_check  (für Windows-Systeme)
+ * *  DEFAULT_LUT_NAME blz.lut; blz.lut2f; blz.lut2
+ * *  DEFAULT_LUT_PATH ., /usr/local/etc/; /etc/; /usr/local/bin/; /opt/konto_check/ <i>(für nicht-Windows-Systeme)</i>
+ * *  DEFAULT_LUT_PATH .; C:; C:\\Programme\\konto_check  <i>(für Windows-Systeme)</i>
  *
  * Der Defaultwert für level ist ebenfalls in konto_check.h definiert; in der
  * aktuellen Version ist er 5. Bei diesem Level werden die Blocks BLZ,
  * Prüfziffer, Name, Kurzname, PLZ, Ort und BIC geladen.
  *
- * Falls der Parameter set nicht angegeben ist, wird versucht, das aktuell
- * gültige Set aus dem Systemdatum und dem Gültigkeitszeitraum der in der
- * LUT-Datei gespeicherten Sets zu bestimmen.
- * 
- * Hier noch einmal ein Überblick über die Parameter:
- *
- * * lutfile: die LUT-Datei, mit der initialisiert werden soll
- * * level: (0-9) Welche Daten geladen werden sollen (PZ steht in der folgenden Tabelle für Prüfziffer, NAME_NAME_KURZ ist ein Block, der sowohl den Namen als auch den Kurznamen der Bank enthält; dieser läßt sich besser komprimieren als wenn beide Blocks getrennt sind):
- *    0. BLZ,PZ
- *    1. BLZ,PZ,NAME_KURZ
- *    2. BLZ,PZ,NAME_KURZ,BIC
- *    3. BLZ,PZ,NAME,PLZ,ORT
- *    4. BLZ,PZ,NAME,PLZ,ORT,BIC
- *    5. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC
- *    6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ
- *    7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG
- *    8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG
- *    9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG,PAN,NR
- * * set (1 oder 2): Datensatz
- * 
- * Mögliche Rückgabewerte:
- * 
- *    -112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
- *     -64  (INIT_FATAL_ERROR)        "Initialisierung fehlgeschlagen (init_wait geblockt)"
- *     -63  (INCREMENTAL_INIT_NEEDS_INFO)            "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
- *     -62  (INCREMENTAL_INIT_FROM_DIFFERENT_FILE)   "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
- *     -38  (LUT2_PARTIAL_OK)         "es wurden nicht alle Blocks geladen"
- *     -36  (LUT2_Z_MEM_ERROR)        "Memory error in den ZLIB-Routinen"
- *     -35  (LUT2_Z_DATA_ERROR)       "Datenfehler im komprimierten LUT-Block"
- *     -34  (LUT2_BLOCK_NOT_IN_FILE)  "Der Block ist nicht in der LUT-Datei enthalten"
- *     -33  (LUT2_DECOMPRESS_ERROR)   "Fehler beim Dekomprimieren eines LUT-Blocks"
- *     -31  (LUT2_FILE_CORRUPTED)     "Die LUT-Datei ist korrumpiert"
- *     -20  (LUT_CRC_ERROR)           "Prüfsummenfehler in der blz.lut Datei"
- *     -10  (FILE_READ_ERROR)         "kann Datei nicht lesen"
- *      -9  (ERROR_MALLOC)            "kann keinen Speicher allokieren"
- *      -7  (INVALID_LUT_FILE)        "die blz.lut Datei ist inkosistent/ungültig"
- *      -6  (NO_LUT_FILE)             "die blz.lut Datei wurde nicht gefunden"
- * 
- *       1  (OK)                      "ok"
- *       6  (LUT1_SET_LOADED)         "Die Datei ist im alten LUT-Format (1.0/1.1)"
- *
- * Anmerkung: Falls der Statuscode LUT2_PARTIAL_OK ist, waren bei der
- * Initialisierung nicht alle Blocks in der LUT-Datei enthalten.
+ * ====Rückgabe:
+ * Es wird ein skalarer Statuscode zurückgegeben, der Auskunft über die Initialisierung bzw.
+ * aufgetretene Fehler gibt.
+ *
+ * ====Mögliche Statuscodes:
+ * * -112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
+ * *  -64  (INIT_FATAL_ERROR)        "Initialisierung fehlgeschlagen (init_wait geblockt)"
+ * *  -63  (INCREMENTAL_INIT_NEEDS_INFO) "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
+ * *  -62  (INCREMENTAL_INIT_FROM_DIFFERENT_FILE)   "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
+ * *  -38  (LUT2_PARTIAL_OK)         "es wurden nicht alle Blocks geladen"
+ * *  -36  (LUT2_Z_MEM_ERROR)        "Memory error in den ZLIB-Routinen"
+ * *  -35  (LUT2_Z_DATA_ERROR)       "Datenfehler im komprimierten LUT-Block"
+ * *  -34  (LUT2_BLOCK_NOT_IN_FILE)  "Der Block ist nicht in der LUT-Datei enthalten"
+ * *  -33  (LUT2_DECOMPRESS_ERROR)   "Fehler beim Dekomprimieren eines LUT-Blocks"
+ * *  -31  (LUT2_FILE_CORRUPTED)     "Die LUT-Datei ist korrumpiert"
+ * *  -20  (LUT_CRC_ERROR)           "Prüfsummenfehler in der blz.lut Datei"
+ * *  -10  (FILE_READ_ERROR)         "kann Datei nicht lesen"
+ * *   -9  (ERROR_MALLOC)            "kann keinen Speicher allokieren"
+ * *   -7  (INVALID_LUT_FILE)        "die blz.lut Datei ist inkosistent/ungültig"
+ * *   -6  (NO_LUT_FILE)             "die blz.lut Datei wurde nicht gefunden"
+ * *    1  (OK)                      "ok"
+ * *    6  (LUT1_SET_LOADED)         "Die Datei ist im alten LUT-Format (1.0/1.1)"
+ *
+ * ====Anmerkung:
+ * Falls der Statuscode LUT2_PARTIAL_OK ist, waren bei der Initialisierung
+ * nicht alle Blocks in der LUT-Datei enthalten; in vielen Situationen ist dies
+ * mehr eine Warnung, nicht ein Fehler.
  */
 static VALUE init(int argc,VALUE* argv,VALUE self)
 {
@@ -502,26 +923,32 @@ static VALUE init(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::current_lutfile_name()</tt>
- * =====<tt>KontoCheck::current_lutfile_name()</tt>
- * =====<tt>KontoCheck::current_lutfile_set()</tt>
- * =====<tt>KontoCheck::current_init_level()</tt>
+ * ===KontoCheckRaw::current_lutfile_name()
+ * =====KontoCheck::current_lutfile_name()
+ * =====KontoCheck::current_lutfile_set()
+ * =====KontoCheck::current_init_level()
  *
  * Diese Funktion bestimmt den Dateinamen der zur Initialisierung benutzen
  * LUT-Datei, das benutzte Set und den Initialisierungslevel der aktuellen
- * Initialisierung. Rückgabewert ist ein Array mit vier Elementen: das erste
- * ist der Dateiname der LUT-Datei, das zweite  das benutzte Set (0, falls
- * nicht initialisiert wurde, sonst 1 oder 2), das dritte der
- * Initialisierungslevel und das vierte der Statuscode.
- * 
- * Mögliche Statuscodes:
+ * Initialisierung.
+ *
+ * ====Aufruf:
+ * retval=KontoCheckRaw::current_lutfile_name
+ *
+ * ====Rückgabe:
+ * Rückgabewert ist ein Array mit vier Elementen: das erste ist der Dateiname
+ * der LUT-Datei, das zweite  das benutzte Set (0, falls nicht initialisiert
+ * wurde, sonst 1 oder 2), das dritte der Initialisierungslevel und das vierte
+ * der Statuscode.
+ *
  * 
- *     -40  (LUT2_NOT_INITIALIZED)       "die Programmbibliothek wurde noch nicht initialisiert"
- *       1  (OK)                         "ok"
+ * ====Mögliche Statuscodes:
+ * *    -40  (LUT2_NOT_INITIALIZED)       "die Programmbibliothek wurde noch nicht initialisiert"
+ * *      1  (OK)                         "ok"
  */
 static VALUE current_lutfile_name_rb(VALUE self)
 {
-   char *lut_filename;
+   const char *lut_filename;
    int set,level,retval;
    VALUE lut_filename_rb;
 
@@ -533,8 +960,8 @@ static VALUE current_lutfile_name_rb(VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::free()</tt>
- * =====<tt>KontoCheck::free()</tt>
+ * ===KontoCheckRaw::free()
+ * =====KontoCheck::free()
  *
  * Diese Funktion gibt allen allokierten Speicher wieder frei. Der Rückgabewert ist immer true.
  */
@@ -545,11 +972,15 @@ static VALUE free_rb(VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::generate_lutfile(inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])</tt>
- * =====<tt>KontoCheck::generate_lutfile(inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])</tt>
+ * ===KontoCheckRaw::generate_lutfile( inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])
+ * =====KontoCheck::generate_lutfile( inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])
  *
  * Diese Funktion generiert eine neue LUT-Datei aus der BLZ-Datei der Deutschen Bundesbank. Die folgenden
  * Parameter werden unterstützt:
+ * ====Aufruf:
+ *
+ * ====Parameter:
+ *
  * * inputfile: Eingabedatei (Textdatei) der Bundesbank
  * * outputfile: Name der Ausgabedatei
  * * user_info: Info-String der in die LUT-Datei geschrieben wird (frei wählbar; wird in den Info-Block aufgenommen)
@@ -562,28 +993,32 @@ static VALUE free_rb(VALUE self)
  *    4. BLZ,PZ,NAME,PLZ,ORT,BIC
  *    5. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC
  *    6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ
- *    7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG
- *    8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG
- *    9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG,PAN,NR
+ *    7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,
+ *       AENDERUNG
+ *    8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,
+ *       AENDERUNG,LOESCHUNG
+ *    9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,
+ *       AENDERUNG,LOESCHUNG,PAN,NR
  * * filialen: (0 oder 1) Flag, ob nur die Daten der Hauptstellen (0) oder auch die der Filialen aufgenommen werden sollen
  * * set (0, 1 oder 2): Datensatz-Nummer. Jede LUT-Datei kann zwei Datensätze enthalten. Falls bei der Initialisierung nicht ein bestimmter Datensatz ausgewählt wird, wird derjenige genommen, der (laut Gültigkeitsstring) aktuell gültig ist.
  * * iban_file: Datei der Banken, die einer Selbstberechnung des IBAN nicht zugestimmt haben. Näheres dazu (inklusive Weblink) findet sich bei der Funktion KontoCheckRaw::iban_gen(blz,kto).
  * 
- * Mögliche Rückgabewerte:
- * 
- *    -112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
- *     -57  (LUT2_GUELTIGKEIT_SWAPPED)   "Im Gültigkeitsdatum sind Anfangs- und Enddatum vertauscht"
- *     -56  (LUT2_INVALID_GUELTIGKEIT)   "Das angegebene Gültigkeitsdatum ist ungültig (Soll: JJJJMMTT-JJJJMMTT)"
- *     -32  (LUT2_COMPRESS_ERROR)        "Fehler beim Komprimieren eines LUT-Blocks"
- *     -31  (LUT2_FILE_CORRUPTED)        "Die LUT-Datei ist korrumpiert"
- *     -30  (LUT2_NO_SLOT_FREE)          "Im Inhaltsverzeichnis der LUT-Datei ist kein Slot mehr frei"
- *     -15  (INVALID_BLZ_FILE)           "Fehler in der blz.txt Datei (falsche Zeilenlänge)"
- *     -11  (FILE_WRITE_ERROR)           "kann Datei nicht schreiben"
- *     -10  (FILE_READ_ERROR)            "kann Datei nicht lesen"
- *      -9  (ERROR_MALLOC)               "kann keinen Speicher allokieren"
- *      -7  (INVALID_LUT_FILE)           "die blz.lut Datei ist inkosistent/ungültig"
- *       1  (OK)                         "ok"
- *       7  (LUT1_FILE_GENERATED)        "ok; es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert"
+ * ====Rückgabe:
+ *
+ * ====Mögliche Statuscodes:
+ * *  -112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
+ * *   -57  (LUT2_GUELTIGKEIT_SWAPPED)   "Im Gültigkeitsdatum sind Anfangs- und Enddatum vertauscht"
+ * *   -56  (LUT2_INVALID_GUELTIGKEIT)   "Das angegebene Gültigkeitsdatum ist ungültig (Soll: JJJJMMTT-JJJJMMTT)"
+ * *   -32  (LUT2_COMPRESS_ERROR)        "Fehler beim Komprimieren eines LUT-Blocks"
+ * *   -31  (LUT2_FILE_CORRUPTED)        "Die LUT-Datei ist korrumpiert"
+ * *   -30  (LUT2_NO_SLOT_FREE)          "Im Inhaltsverzeichnis der LUT-Datei ist kein Slot mehr frei"
+ * *   -15  (INVALID_BLZ_FILE)           "Fehler in der blz.txt Datei (falsche Zeilenlänge)"
+ * *   -11  (FILE_WRITE_ERROR)           "kann Datei nicht schreiben"
+ * *   -10  (FILE_READ_ERROR)            "kann Datei nicht lesen"
+ * *    -9  (ERROR_MALLOC)               "kann keinen Speicher allokieren"
+ * *    -7  (INVALID_LUT_FILE)           "die blz.lut Datei ist inkosistent/ungültig"
+ * *     1  (OK)                         "ok"
+ * *     7  (LUT1_FILE_GENERATED)        "ok; es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert"
  */
 static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
 {
@@ -597,16 +1032,16 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
          &user_info_rb,&gueltigkeit_rb,&felder_rb,&filialen_rb,&set_rb,&iban_file_rb);
 
    if(TYPE(input_name_rb)==RUBY_T_STRING){
-      strncpy(input_name,RSTRING_PTR(input_name_rb),FILENAME_MAX);
       if((len=RSTRING_LEN(input_name_rb))>FILENAME_MAX)len=FILENAME_MAX;
+      strncpy(input_name,RSTRING_PTR(input_name_rb),len);
       *(input_name+len)=0;
    }
    else
       rb_raise(rb_eTypeError,"Unable to convert given input filename.");
 
    if(TYPE(output_name_rb)==RUBY_T_STRING){
-      strncpy(output_name,RSTRING_PTR(output_name_rb),FILENAME_MAX);
       if((len=RSTRING_LEN(output_name_rb))>FILENAME_MAX)len=FILENAME_MAX;
+      strncpy(output_name,RSTRING_PTR(output_name_rb),len);
       *(output_name+len)=0;
    }
    else
@@ -616,8 +1051,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
       *user_info=0;
    }
    else if(TYPE(user_info_rb)==RUBY_T_STRING){
-      strncpy(user_info,RSTRING_PTR(user_info_rb),255);
       if((len=RSTRING_LEN(user_info_rb))>255)len=255;
+      strncpy(user_info,RSTRING_PTR(user_info_rb),len);
       *(user_info+len)=0;
    }
    else
@@ -627,8 +1062,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
       *gueltigkeit=0;
    }
    else if(TYPE(gueltigkeit_rb)==RUBY_T_STRING){
-      strncpy(gueltigkeit,RSTRING_PTR(gueltigkeit_rb),19);
       if((len=RSTRING_LEN(gueltigkeit_rb))>19)len=19;
+      strncpy(gueltigkeit,RSTRING_PTR(gueltigkeit_rb),len);
       *(gueltigkeit+len)=0;
    }
    else
@@ -637,8 +1072,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
    if(NIL_P(felder_rb))
       felder=DEFAULT_LUT_FIELDS_NUM;
    else if(TYPE(felder_rb)==RUBY_T_STRING){
-      strncpy(buffer,RSTRING_PTR(felder_rb),15);
       if((len=RSTRING_LEN(felder_rb))>15)len=15;
+      strncpy(buffer,RSTRING_PTR(felder_rb),len);
       *(buffer+len)=0;
       felder=atoi(buffer);
    }
@@ -648,8 +1083,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
    if(NIL_P(filialen_rb))
       filialen=0;
    else if(TYPE(filialen_rb)==RUBY_T_STRING){
-      strncpy(buffer,RSTRING_PTR(filialen_rb),15);
       if((len=RSTRING_LEN(felder_rb))>15)len=15;
+      strncpy(buffer,RSTRING_PTR(filialen_rb),len);
       *(buffer+len)=0;
       filialen=atoi(buffer);
    }
@@ -659,8 +1094,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
    if(NIL_P(set_rb))
       set=0;
    else if(TYPE(set_rb)==RUBY_T_STRING){
-      strncpy(buffer,RSTRING_PTR(set_rb),15);
       if((len=RSTRING_LEN(set_rb))>15)len=15;
+      strncpy(buffer,RSTRING_PTR(set_rb),len);
       *(buffer+len)=0;
       set=atoi(buffer);
    }
@@ -671,8 +1106,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
       *iban_file=0;
    }
    else if(TYPE(iban_file_rb)==RUBY_T_STRING){
-      strncpy(iban_file,RSTRING_PTR(iban_file_rb),FILENAME_MAX);
       if((len=RSTRING_LEN(iban_file_rb))>FILENAME_MAX)len=FILENAME_MAX;
+      strncpy(iban_file,RSTRING_PTR(iban_file_rb),len);
       *(iban_file+len)=0;
    }
    else
@@ -686,7 +1121,7 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
 
 static int enc_mode(int argc,VALUE *argv)
 {
-   int mode,t;
+   int mode;
    VALUE mode_rb=Qnil;
 
    rb_scan_args(argc,argv,"01",&mode_rb);
@@ -723,10 +1158,10 @@ static int enc_mode(int argc,VALUE *argv)
 }
 
 /**
- * ===<tt>KontoCheckRaw::encoding([mode])</tt>
- * =====<tt>KontoCheck::encoding([mode])</tt>
- * =====<tt>KontoCheckRaw::encoding_str([mode])</tt>
- * =====<tt>KontoCheckRaw::keep_raw_data(mode)</tt>
+ * ===KontoCheckRaw::encoding( [mode])
+ * =====KontoCheck::encoding( [mode])
+ * =====KontoCheckRaw::encoding_str( [mode])
+ * =====KontoCheckRaw::keep_raw_data( mode)
  *
  * Diese Funktion legt den benutzten Zeichensatz für Fehlermeldungen durch die
  * Funktion KontoCheckRaw::retval2txt() und einige Felder der LUT-Datei (Name,
@@ -740,47 +1175,54 @@ static int enc_mode(int argc,VALUE *argv)
  * gesetzt ist, sollte die Funktion *vor* der Initialisierung aufgerufen werden,
  * da in dem Fall die Daten der LUT-Datei nur bei der Initialisierung konvertiert
  * werden. Mit der Funktion KontoCheckRaw::keep_raw_data() kann das Flag gesetzt
- * oder gelöscht werden.
- *
- * Für den Parameter mode werden die folgenden Werte akzeptiert (die Strings
- * sind nicht case sensitiv; Mi oder mI oder MI ist z.B. auch möglich. Wird der
- * Parameter nicht angegeben, wird die aktuelle Kodierung ausgegeben):
- *
- *    0:            aktuelle Kodierung ausgeben
- *    1,  'i', 'I': ISO-8859-1
- *    2,  'u', 'U': UTF-8
- *    3,  'h', 'H': HTML
- *    4,  'd', 'D': DOS CP 850
- *    51, 'mi':     ISO-8859-1, Makro für Fehlermeldungen
- *    52, 'mu':     UTF-8, Makro für Fehlermeldungen
- *    53, 'mh':     HTML, Makro für Fehlermeldungen
- *    54, 'md':     DOS CP 850, Makro für Fehlermeldungen
- *
+ * gelöscht und abgefragt werden.
+ *
+ * ====Aufruf:
+ * KontoCheckRaw::encoding( [mode])
+ *
+ * ====Parameter:
+ * * mode: die gewünschte Kodierung.
+ *   Falls der Parameter nicht angegeben wird, wird die aktuelle Kodierung
+ *   zurückgegeben. Ansonsten werden für den Parameter mode die folgenden Werte
+ *   akzeptiert (die Strings sind nicht case sensitiv; Mi oder mI oder MI ist
+ *   z.B. auch möglich.
+ *
+ * *   0:            aktuelle Kodierung ausgeben
+ * *   1,  'i', 'I': ISO-8859-1
+ * *   2,  'u', 'U': UTF-8
+ * *   3,  'h', 'H': HTML
+ * *   4,  'd', 'D': DOS CP 850
+ * *   51, 'mi':     ISO-8859-1, Makro für Fehlermeldungen
+ * *   52, 'mu':     UTF-8, Makro für Fehlermeldungen
+ * *   53, 'mh':     HTML, Makro für Fehlermeldungen
+ * *   54, 'md':     DOS CP 850, Makro für Fehlermeldungen
+ *
+ * ====Rückgabe:
  * Rückgabewert ist die aktuelle Kodierung als Integer (falls zwei Kodierungen
  * angegeben sind, ist die erste die der Statusmeldungen, die zweite die der
  * LUT-Blocks):
  * 
- *     0:  "noch nicht spezifiziert" (vor der Initialisierung)
- *     1:  "ISO-8859-1";
- *     2:  "UTF-8";
- *     3:  "HTML entities";
- *     4:  "DOS CP 850";
- *     12: "ISO-8859-1/UTF-8";
- *     13: "ISO-8859-1/HTML";
- *     14: "ISO-8859-1/DOS CP 850";
- *     21: "UTF-8/ISO-8859-1";
- *     23: "UTF-8/HTML";
- *     24: "UTF-8/DOS CP-850";
- *     31: "HTML entities/ISO-8859-1";
- *     32: "HTML entities/UTF-8";
- *     34: "HTML entities/DOS CP-850";
- *     41: "DOS CP-850/ISO-8859-1";
- *     42: "DOS CP-850/UTF-8";
- *     43: "DOS CP-850/HTML";
- *     51: "Makro/ISO-8859-1";
- *     52: "Makro/UTF-8";
- *     53: "Makro/HTML";
- *     54: "Makro/DOS CP 850";
+ * *   0:  "noch nicht spezifiziert" (vor der Initialisierung)
+ * *   1:  "ISO-8859-1";
+ * *   2:  "UTF-8";
+ * *   3:  "HTML entities";
+ * *   4:  "DOS CP 850";
+ * *   12: "ISO-8859-1/UTF-8";
+ * *   13: "ISO-8859-1/HTML";
+ * *   14: "ISO-8859-1/DOS CP 850";
+ * *   21: "UTF-8/ISO-8859-1";
+ * *   23: "UTF-8/HTML";
+ * *   24: "UTF-8/DOS CP-850";
+ * *   31: "HTML entities/ISO-8859-1";
+ * *   32: "HTML entities/UTF-8";
+ * *   34: "HTML entities/DOS CP-850";
+ * *   41: "DOS CP-850/ISO-8859-1";
+ * *   42: "DOS CP-850/UTF-8";
+ * *   43: "DOS CP-850/HTML";
+ * *   51: "Makro/ISO-8859-1";
+ * *   52: "Makro/UTF-8";
+ * *   53: "Makro/HTML";
+ * *   54: "Makro/DOS CP 850";
  */
 static VALUE encoding_rb(int argc,VALUE* argv,VALUE self)
 {
@@ -788,38 +1230,45 @@ static VALUE encoding_rb(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::encoding_str(mode)</tt>
- * =====<tt>KontoCheck::encoding_str(mode)</tt>
- * =====<tt>KontoCheckRaw::encoding(mode)</tt>
- * =====<tt>KontoCheckRaw::keep_raw_data(mode)</tt>
+ * ===KontoCheckRaw::encoding_str( mode)
+ * =====KontoCheck::encoding_str( mode)
+ * =====KontoCheckRaw::encoding( mode)
+ * =====KontoCheckRaw::keep_raw_data( mode)
  *
  * Diese Funktion entspricht der Funktion KontoCheck::encoding(). Allerdings
  * ist der Rückgabewert nicht numerisch, sondern ein String, der die aktuelle
- * Kodierung angibt. Die folgenden Rückgabewerte sind möglich (falls zwei
- * Kodierungen angegeben sind, ist die erste die der Statusmeldungen, die
- * zweite die der LUT-Blocks):
+ * Kodierung angibt.
+ *
+ * ====Aufruf:
+ * KontoCheckRaw::encoding_str( [mode])
+ *
+ * ====Parameter:
+ * wie bei KontoCheckRaw::encoding()
  *      
- *     "noch nicht spezifiziert" (vor der Initialisierung)
- *     "ISO-8859-1";
- *     "UTF-8";
- *     "HTML entities";
- *     "DOS CP 850";
- *     "ISO-8859-1/UTF-8";
- *     "ISO-8859-1/HTML";
- *     "ISO-8859-1/DOS CP 850";
- *     "UTF-8/ISO-8859-1";
- *     "UTF-8/HTML";
- *     "UTF-8/DOS CP-850";
- *     "HTML entities/ISO-8859-1";
- *     "HTML entities/UTF-8";
- *     "HTML entities/DOS CP-850";
- *     "DOS CP-850/ISO-8859-1";
- *     "DOS CP-850/UTF-8";
- *     "DOS CP-850/HTML";
- *     "Makro/ISO-8859-1";
- *     "Makro/UTF-8";
- *     "Makro/HTML";
- *     "Makro/DOS CP 850";
+ * ====Rückgabe:
+ * Rückgabewert ist die aktuelle Kodierung als String:
+ *
+ * *   "noch nicht spezifiziert" (vor der Initialisierung)
+ * *   "ISO-8859-1";
+ * *   "UTF-8";
+ * *   "HTML entities";
+ * *   "DOS CP 850";
+ * *   "ISO-8859-1/UTF-8";
+ * *   "ISO-8859-1/HTML";
+ * *   "ISO-8859-1/DOS CP 850";
+ * *   "UTF-8/ISO-8859-1";
+ * *   "UTF-8/HTML";
+ * *   "UTF-8/DOS CP-850";
+ * *   "HTML entities/ISO-8859-1";
+ * *   "HTML entities/UTF-8";
+ * *   "HTML entities/DOS CP-850";
+ * *   "DOS CP-850/ISO-8859-1";
+ * *   "DOS CP-850/UTF-8";
+ * *   "DOS CP-850/HTML";
+ * *   "Makro/ISO-8859-1";
+ * *   "Makro/UTF-8";
+ * *   "Makro/HTML";
+ * *   "Makro/DOS CP 850";
  */
 static VALUE encoding_str_rb(int argc,VALUE* argv,VALUE self)
 {
@@ -827,9 +1276,9 @@ static VALUE encoding_str_rb(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::keep_raw_data(mode)</tt>
- * =====<tt>KontoCheckRaw::encoding(mode)</tt>
- * =====<tt>KontoCheck::encoding(mode)</tt>
+ * ===KontoCheckRaw::keep_raw_data( mode)
+ * =====KontoCheckRaw::encoding( mode)
+ * =====KontoCheck::encoding( mode)
  *
  * Diese Funktion setzt bzw. liest das Flag keep_raw_data in der C-Bibliothek.
  * Falls es gesetzt ist, werden werden die Rohdaten der Blocks Name, Kurzname
@@ -839,13 +1288,18 @@ static VALUE encoding_str_rb(int argc,VALUE* argv,VALUE self)
  * wieder freigegeben würden.
  *
  * Da diese Funktion etwas exotisch ist, ist sie nur in der KontoCheckRaw
- * Bibliothek enthalten, nicht in KontoCheck..
+ * Bibliothek enthalten, nicht in KontoCheck.
  * 
- * Parameter:
- *    -1: Flag keep_raw_data ausschalten
- *     1: Flag keep_raw_data einschalten
- *     0: Flag lesen
+ * ====Aufruf:
+ * retval=KontoCheck::encoding( mode)
  *
+ * ====Parameter:
+ * Das Verhalten der Funktion wird durch den Parameter mode gesteuert:
+ * *   -1: Flag keep_raw_data ausschalten
+ * *    1: Flag keep_raw_data einschalten
+ * *    0/nil: Flag lesen 
+ *
+ * ====Mögliche Rückgabewerte
  * Der Rückgabewert ist true oder false.
  */
 static VALUE keep_raw_data_rb(VALUE self, VALUE mode_rb)
@@ -864,13 +1318,22 @@ static VALUE keep_raw_data_rb(VALUE self, VALUE mode_rb)
 }
 
 /**
- * ===<tt>KontoCheckRaw::retval2txt(retval)</tt>
- * =====<tt>KontoCheck::retval2txt(retval)</tt>
+ * ===KontoCheckRaw::retval2txt( retval)
+ * =====KontoCheck::retval2txt( retval)
  *
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
  * Der benutzte Zeichensatz wird über die Funktion KontoCheckRaw::encoding()
  * festgelegt. Falls diese Funktion nicht aufgerufen wurde, wird der Wert des
  * Makros DEFAULT_ENCODING aus konto_check.h benutzt.
+ *
+ * ====Aufruf:
+ * retval_str=KontoCheckRaw::retval2txt( retval)
+ *
+ * ====Parameter:
+ * * retval: der zu konvertierende numerische Rückgabewert
+ *
+ * ====Rückgabe:
+ * String, der dem Rückgabewert entspricht
  */
 static VALUE retval2txt_rb(VALUE self, VALUE retval)
 {
@@ -878,11 +1341,20 @@ static VALUE retval2txt_rb(VALUE self, VALUE retval)
 }
 
 /**
- * ===<tt>KontoCheckRaw::retval2iso(retval)</tt>
- * =====<tt>KontoCheck::retval2iso(retval)</tt>
+ * ===KontoCheckRaw::retval2iso( retval)
+ * =====KontoCheck::retval2iso( retval)
  *
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
  * Der benutzte Zeichensatz ist ISO 8859-1. 
+ *
+ * ====Aufruf:
+ * retval_str=KontoCheckRaw::retval2iso( retval)
+ *
+ * ====Parameter:
+ * * retval: der zu konvertierende numerische Rückgabewert
+ *
+ * ====Rückgabe:
+ * String, der dem Rückgabewert entspricht
  */
 static VALUE retval2iso_rb(VALUE self, VALUE retval)
 {
@@ -890,11 +1362,20 @@ static VALUE retval2iso_rb(VALUE self, VALUE retval)
 }
 
 /**
- * ===<tt>KontoCheckRaw::retval2txt_short(retval)</tt>
- * =====<tt>KontoCheck::retval2txt_short(retval)</tt>
+ * ===KontoCheckRaw::retval2txt_short( retval)
+ * =====KontoCheck::retval2txt_short( retval)
  *
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen kurzen
  * String. Die Ausgabe ist der Makroname, wie er in C benutzt wird.
+ *
+ * ====Aufruf:
+ * retval_str=KontoCheckRaw::retval2txt_short( retval)
+ *
+ * ====Parameter:
+ * * retval: der zu konvertierende numerische Rückgabewert
+ *
+ * ====Rückgabe:
+ * String, der dem Rückgabewert entspricht
  */
 static VALUE retval2txt_short_rb(VALUE self, VALUE retval)
 {
@@ -902,11 +1383,20 @@ static VALUE retval2txt_short_rb(VALUE self, VALUE retval)
 }
 
 /**
- * ===<tt>KontoCheckRaw::retval2dos(<retval>)</tt>
- * =====<tt>KontoCheck::retval2dos(<retval>)</tt>
+ * ===KontoCheckRaw::retval2dos( retval)
+ * =====KontoCheck::retval2dos( retval)
  * 
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
  * Der benutzte Zeichensatz ist cp850 (DOS).
+ *
+ * ====Aufruf:
+ * retval_str=KontoCheckRaw::retval2dos( retval)
+ *
+ * ====Parameter:
+ * * retval: der zu konvertierende numerische Rückgabewert
+ *
+ * ====Rückgabe:
+ * String, der dem Rückgabewert entspricht
  */
 static VALUE retval2dos_rb(VALUE self, VALUE retval)
 {
@@ -914,11 +1404,20 @@ static VALUE retval2dos_rb(VALUE self, VALUE retval)
 }
 
 /**
- * ===<tt>KontoCheckRaw::retval2html(<retval>)</tt>
- * =====<tt>KontoCheck::retval2html(<retval>)</tt>
+ * ===KontoCheckRaw::retval2html( retval)
+ * =====KontoCheck::retval2html( retval)
  *
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
  * Für Umlaute werden HTML-Entities benutzt.
+ *
+ * ====Aufruf:
+ * retval_str=KontoCheckRaw::retval2html( retval)
+ *
+ * ====Parameter:
+ * * retval: der zu konvertierende numerische Rückgabewert
+ *
+ * ====Rückgabe:
+ * String, der dem Rückgabewert entspricht
  */
 static VALUE retval2html_rb(VALUE self, VALUE retval)
 {
@@ -926,11 +1425,20 @@ static VALUE retval2html_rb(VALUE self, VALUE retval)
 }
 
 /**
- * ===<tt>KontoCheckRaw::retval2utf8(<retval>)</tt>
- * =====<tt>KontoCheck::retval2utf8(<retval>)</tt>
+ * ===KontoCheckRaw::retval2utf8( retval)
+ * =====KontoCheck::retval2utf8( retval)
  *
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
  * Der benutzte Zeichensatz ist UTF-8.
+ *
+ * ====Aufruf:
+ * retval_str=KontoCheckRaw::retval2utf8( retval)
+ *
+ * ====Parameter:
+ * * retval: der zu konvertierende numerische Rückgabewert
+ *
+ * ====Rückgabe:
+ * String, der dem Rückgabewert entspricht
  */
 static VALUE retval2utf8_rb(VALUE self, VALUE retval)
 {
@@ -938,28 +1446,35 @@ static VALUE retval2utf8_rb(VALUE self, VALUE retval)
 }
 
 /**
- * ===<tt>KontoCheckRaw::dump_lutfile(lutfile)</tt>
- * =====<tt>KontoCheck::dump_lutfile(lutfile)</tt>
+ * ===KontoCheckRaw::dump_lutfile( lutfile)
+ * =====KontoCheck::dump_lutfile( lutfile)
  *
  * Diese Funktion liefert detaillierte Informationen über alle Blocks, die in
  * der LUT-Datei gespeichert sind, sowie noch einige Internas der LUT-Datei.
+ *
+ * ====Aufruf:
+ * retval=KontoCheckRaw::dump_lutfile( lutfile)
+ *
+ * ====Parameter:
+ * * lutfile: Name der LUT-Datei.
+ *
+ * ====Rückgabe:
  * Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein
  * String mit den Infos, im zweiten ein Statuscode. Im Fehlerfall wird für den
  * Infostring nil zurückgegeben.
  *
- * Mögliche Werte für den Statuscode sind:
- *
- *    -112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
- *     -70  (LUT1_FILE_USED)             "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
- *     -36  (LUT2_Z_MEM_ERROR)           "Memory error in den ZLIB-Routinen"
- *     -35  (LUT2_Z_DATA_ERROR)          "Datenfehler im komprimierten LUT-Block"
- *     -33  (LUT2_DECOMPRESS_ERROR)      "Fehler beim Dekomprimieren eines LUT-Blocks"
- *     -31  (LUT2_FILE_CORRUPTED)        "Die LUT-Datei ist korrumpiert"
- *     -20  (LUT_CRC_ERROR)              "Prüfsummenfehler in der blz.lut Datei"
- *     -10  (FILE_READ_ERROR)            "kann Datei nicht lesen"
- *      -9  (ERROR_MALLOC)               "kann keinen Speicher allokieren"
- *      -7  (INVALID_LUT_FILE)           "die blz.lut Datei ist inkosistent/ungültig"
- *       1  (OK)                         "ok"
+ * ====Mögliche Statuscodes:
+ * *  -112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
+ * *   -70  (LUT1_FILE_USED)             "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
+ * *   -36  (LUT2_Z_MEM_ERROR)           "Memory error in den ZLIB-Routinen"
+ * *   -35  (LUT2_Z_DATA_ERROR)          "Datenfehler im komprimierten LUT-Block"
+ * *   -33  (LUT2_DECOMPRESS_ERROR)      "Fehler beim Dekomprimieren eines LUT-Blocks"
+ * *   -31  (LUT2_FILE_CORRUPTED)        "Die LUT-Datei ist korrumpiert"
+ * *   -20  (LUT_CRC_ERROR)              "Prüfsummenfehler in der blz.lut Datei"
+ * *   -10  (FILE_READ_ERROR)            "kann Datei nicht lesen"
+ * *    -9  (ERROR_MALLOC)               "kann keinen Speicher allokieren"
+ * *    -7  (INVALID_LUT_FILE)           "die blz.lut Datei ist inkosistent/ungültig"
+ * *     1  (OK)                         "ok"
  */
 static VALUE dump_lutfile_rb(int argc,VALUE* argv,VALUE self)
 {
@@ -978,47 +1493,52 @@ static VALUE dump_lutfile_rb(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::lut_info([lutfile])</tt>
- * =====<tt>KontoCheck::lut_info()</tt>
- * =====<tt>KontoCheck::lut_info1(lutfile)</tt>
- * =====<tt>KontoCheck::lut_info2(lutfile)</tt>
+ * ===KontoCheckRaw::lut_info( [lutfile])
+ * =====KontoCheck::lut_info()
+ * =====KontoCheck::lut_info1( lutfile)
+ * =====KontoCheck::lut_info2( lutfile)
  *
  * Diese Funktion liefert Informationen über die Datensätze sowie die beiden
- * Infoblocks einer LUT-Datei. Falls sie ohne Parameter aufgerufen wird,
- * werden Infos über die geladenen Blocks zurückgegeben.
+ * Infoblocks einer LUT-Date oder die in den Speicher geladenen Blocks.
+ * 
+ * ====Aufruf:
+ * ret=KontoCheckRaw::lut_info( [lutfile])
  * 
+ * ====Parameter:
+ * * lutfile: Name der LUT-Datei, falls angegeben. Falls der Parameter weggelassen wird, werden Infnos über die geladenen Blocks zurückgegeben.
+ *
+ * ====Rückgabe:
+ *
  * Der Rückgabewert ist ein Array mit 5 Elementen:
  *
- *    0. retval:  Statuscode
- *    1. valid1:  Gültigkeitscode für den ersten Block
- *    2. valid2:  Gültigkeitscode für den zweiten Block
- *    3. info1:   erster Infoblock, oder nil, falls der Block nicht existiert
- *    4. info2:   zweiter Infoblock, oder nil, falls der Block nicht existiert
- * 
- * Mögliche Statuscodes für valid1 and valid2 sind:
- *
- *    -105  (LUT2_NO_LONGER_VALID_BETTER)   "Beide Datensätze sind nicht mehr gültig; dieser ist  aber jünger als der andere"
- *     -59  (LUT2_NOT_YET_VALID)            "Der Datenblock ist noch nicht gültig"
- *     -58  (LUT2_NO_LONGER_VALID)          "Der Datenblock ist nicht mehr gültig"
- *     -34  (LUT2_BLOCK_NOT_IN_FILE)        "Die LUT-Datei enthält den Infoblock nicht"
- *       4  (LUT2_VALID)                    "Der Datenblock ist aktuell gültig"
- *       5  (LUT2_NO_VALID_DATE)            "Der Datenblock enthält kein Gültigkeitsdatum"
- *
- * Mögliche Werte für den Statuscode retval:
- *
- *    -112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
- *     -10  (FILE_READ_ERROR)        "kann Datei nicht lesen"
- *     -70  (LUT1_FILE_USED)         "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
- *     -40  (LUT2_NOT_INITIALIZED)   "die Programmbibliothek wurde noch nicht initialisiert"
- *     -37  (LUT2_Z_BUF_ERROR)       "Buffer error in den ZLIB Routinen"
- *     -36  (LUT2_Z_MEM_ERROR)       "Memory error in den ZLIB-Routinen"
- *     -35  (LUT2_Z_DATA_ERROR)      "Datenfehler im komprimierten LUT-Block"
- *     -34  (LUT2_BLOCK_NOT_IN_FILE) "Der Block ist nicht in der LUT-Datei enthalten"
- *     -31  (LUT2_FILE_CORRUPTED)    "Die LUT-Datei ist korrumpiert"
- *     -20  (LUT_CRC_ERROR)          "Prüfsummenfehler in der blz.lut Datei"
- *      -9  (ERROR_MALLOC)           "kann keinen Speicher allokieren"
- *      -7  (INVALID_LUT_FILE)       "die blz.lut Datei ist inkosistent/ungültig"
- *       1  (OK)                     "ok"
+ * * das erste Element (retval) enthält den Statuscode für die Funktion insgesamt
+ * * das zweite Element (valid1) enthält den Gültigkeitscode für den ersten Block
+ * * das dritte Element (valid2) enthält den Gültigkeitscode für den zweiten Block
+ * * das vierte Element (info1) enthält den erster Infoblock, oder nil, falls der Block nicht existiert
+ * * das fünfte Element (info2) enthält den zweiter Infoblock, oder nil, falls der Block nicht existiert
+ * 
+ * ====Mögliche Statuscodes für valid1 and valid2:
+ * *  -105  (LUT2_NO_LONGER_VALID_BETTER)   "Beide Datensätze sind nicht mehr gültig; dieser ist  aber jünger als der andere"
+ * *   -59  (LUT2_NOT_YET_VALID)            "Der Datenblock ist noch nicht gültig"
+ * *   -58  (LUT2_NO_LONGER_VALID)          "Der Datenblock ist nicht mehr gültig"
+ * *   -34  (LUT2_BLOCK_NOT_IN_FILE)        "Die LUT-Datei enthält den Infoblock nicht"
+ * *     4  (LUT2_VALID)                    "Der Datenblock ist aktuell gültig"
+ * *     5  (LUT2_NO_VALID_DATE)            "Der Datenblock enthält kein Gültigkeitsdatum"
+ *
+ * ====Mögliche Werte für den Statuscode retval:
+ * *  -112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
+ * *   -10  (FILE_READ_ERROR)        "kann Datei nicht lesen"
+ * *   -70  (LUT1_FILE_USED)         "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
+ * *   -40  (LUT2_NOT_INITIALIZED)   "die Programmbibliothek wurde noch nicht initialisiert"
+ * *   -37  (LUT2_Z_BUF_ERROR)       "Buffer error in den ZLIB Routinen"
+ * *   -36  (LUT2_Z_MEM_ERROR)       "Memory error in den ZLIB-Routinen"
+ * *   -35  (LUT2_Z_DATA_ERROR)      "Datenfehler im komprimierten LUT-Block"
+ * *   -34  (LUT2_BLOCK_NOT_IN_FILE) "Der Block ist nicht in der LUT-Datei enthalten"
+ * *   -31  (LUT2_FILE_CORRUPTED)    "Die LUT-Datei ist korrumpiert"
+ * *   -20  (LUT_CRC_ERROR)          "Prüfsummenfehler in der blz.lut Datei"
+ * *    -9  (ERROR_MALLOC)           "kann keinen Speicher allokieren"
+ * *    -7  (INVALID_LUT_FILE)       "die blz.lut Datei ist inkosistent/ungültig"
+ * *     1  (OK)                     "ok"
  */
 static VALUE lut_info_rb(int argc,VALUE* argv,VALUE self)
 {
@@ -1043,18 +1563,18 @@ static VALUE lut_info_rb(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::load_bank_data(<datafile>)</tt>
- * =====<tt>KontoCheck::load_bank_data(<datafile>)</tt>
+ * ===KontoCheckRaw::load_bank_data( datafile)
+ * =====KontoCheck::load_bank_data( datafile)
  *
  * Diese Funktion war die alte Initialisierungsroutine für konto_check; es ist
  * nun durch die Funktionen KontoCheck::init() und KontoCheck::generate_lutfile()
  * ersetzt. Zur Initialisierung  benutzte sie die Textdatei der Deutschen
- * Bundesbank und generiertge daraus eine LUT-Datei, die dann von der
+ * Bundesbank und generierte daraus eine LUT-Datei, die dann von der
  * Initialisierungsroutine der C-Bibliothek benutzt wurde.
  * 
- * Die init() Funktion ist wesentlich schneller (7..20 mal so schnell ohne
+ * Die init() Funktion ist wesentlich schneller (7...20 mal so schnell ohne
  * Generierung der Indexblocks; mit Indexblocks macht es noch wesentlich mehr
- * aus) und hat eine Reihe weiterer Vorteile. So ist es z.B. möglich, zwwei
+ * aus) und hat eine Reihe weiterer Vorteile. So ist es z.B. möglich, zwei
  * Datensätze mit unterschiedlichem Gültigkeitszeitraum in einer Datei zu
  * halten und den jeweils gültigen Satz automatisch (nach der Systemzeit)
  * auswählen zu lassen. Die einzelnen Datenblocks (Bankleitzahlen,
@@ -1064,10 +1584,20 @@ static VALUE lut_info_rb(int argc,VALUE* argv,VALUE self)
  * Format, so daß einzelne Blocks nicht unabhängig von anderen geladen werden
  * können.
  * 
- * Die Funktion load_bank_data() wird nur noch als ein schibbolet benutzt, um
+ * Die Funktion load_bank_data() wird nur noch als ein Schibbolet benutzt, um
  * zu testen, ob jemand das alte Interface benutzt. Bei der Routine
  * KontoCheck::konto_check() wurde die Reihenfolge der Parameter getauscht, so
  * daß man in dem Falle den alten Code umstellen muß.
+ *
+ * ====Aufruf:
+ * retval=KontoCheckRaw::load_bank_data( datafile)
+ *
+ * ====Parameter:
+ * * der alte Parameter datafile ist die BLZ-Datei der Deutschen Bundesbank; er wird ignoriert.
+ *
+ * ====Rückgabe:
+ * es erfolgt keine Rückgabe, sondern es wird nur eine runtime Exception generiert, daß
+ * scheinbar das alte Interface benutzt wurde, dieses aber nicht mehr unterstützt wird.
  */
 
 static VALUE load_bank_data(VALUE self, VALUE path_rb)
@@ -1078,8 +1608,8 @@ static VALUE load_bank_data(VALUE self, VALUE path_rb)
 }
 
 /**
- * ===<tt>KontoCheckRaw::iban2bic(iban)</tt>
- * =====<tt>KontoCheck::iban2bic(iban)</tt>
+ * ===KontoCheckRaw::iban2bic( iban)
+ * =====KontoCheck::iban2bic( iban)
  * 
  * Diese Funktion bestimmt zu einer (deutschen!) IBAN den zugehörigen BIC (Bank
  * Identifier Code). Der BIC wird für eine EU-Standard-Überweisung im
@@ -1087,19 +1617,25 @@ static VALUE load_bank_data(VALUE self, VALUE path_rb)
  * Banken ist er in der BLZ-Datei enthalten. Nähere Infos gibt es z.B. unter
  * http://www.bic-code.de/
  *
+ * ====Aufruf:
+ * ret=KontoCheckRaw::iban2bic( iban)
+ *
+ * ====Parameter:
+ * * iban: die IBAN, zu der der entsprechende BIC bestimmt werden soll.
+ *
+ * ====Rückgabe:
  * Der Rückgabewert ist ein Array mit vier Elementen: im ersten steht der BIC,
  * im zweiten ein Statuscode, im dritten die BLZ und im vierten die Kontonummer
  * (die beiden letzteren werden aus der IBAN extrahiert). Im Fehlerfall wird
  * für BIC, BLZ und Kontonummer nil zurückgegeben. 
  * 
- * Mögliche Statuscodes:
- * 
- *     -68  (IBAN2BIC_ONLY_GERMAN)       "Die Funktion iban2bic() arbeitet nur mit deutschen Bankleitzahlen"
- *     -46  (LUT2_BIC_NOT_INITIALIZED)   "Das Feld BIC wurde nicht initialisiert"
- *     -40  (LUT2_NOT_INITIALIZED)       "die Programmbibliothek wurde noch nicht initialisiert"
- *      -5  (INVALID_BLZ_LENGTH)         "die Bankleitzahl ist nicht achtstellig"
- *      -4  (INVALID_BLZ)                "die Bankleitzahl ist ungültig"
- *       1  (OK)                         "ok"
+ * ====Mögliche Statuscodes:
+ * *   -68  (IBAN2BIC_ONLY_GERMAN)       "Die Funktion iban2bic() arbeitet nur mit deutschen Bankleitzahlen"
+ * *   -46  (LUT2_BIC_NOT_INITIALIZED)   "Das Feld BIC wurde nicht initialisiert"
+ * *   -40  (LUT2_NOT_INITIALIZED)       "die Programmbibliothek wurde noch nicht initialisiert"
+ * *    -5  (INVALID_BLZ_LENGTH)         "die Bankleitzahl ist nicht achtstellig"
+ * *    -4  (INVALID_BLZ)                "die Bankleitzahl ist ungültig"
+ * *     1  (OK)                         "ok"
  */
 static VALUE iban2bic_rb(int argc,VALUE* argv,VALUE self)
 {
@@ -1115,118 +1651,203 @@ static VALUE iban2bic_rb(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::iban_gen(blz,kto)</tt>
- * =====<tt>KontoCheck::iban_gen(kto,blz)</tt>
- * Diese Funktion generiert aus (deutscher) BLZ und Konto einen IBAN. Hierbei
- * ist zu beachten, daß nicht alle Banken der Selbstberechnung zugestimmt
- * haben. Es gibt von den Sparkassen eine Liste dieser Institute; sie ist auch
- * in der LUT-Datei mit der ID 22 (1. Eigene IBAN) enthalten. Bei diesen Banken
- * wird - falls der Block in der LUT-Datei enthalten ist - keine Berechnung
- * durchgeführt, sondern die Status-Variable auf NO_OWN_IBAN_CALCULATION
- * gesetzt. 
- *
- * Alle Banken der Liste erzeugen eine Statusmeldung mit dem Wert
- * OK_UNTERKONTO_ATTACHED, OK_UNTERKONTO_POSSIBLE oder OK_UNTERKONTO_GIVEN.
- * Falls einer dieser Stauswerte zurückgegeben wird, ist somit immer Vorsicht
- * geboten; der generierte IBAN sollte direkt bei dem zugehörigen Institut
- * überprüft werden.
- * 
- * Hier ein Auszug aus der Anleitung des SEPA Account Converters:
- * 
- * Der SEPA Account Converter ist so eingestellt, dass nur Kontoverbindungen in
- * IBAN und BIC umgerechnet werden, bei denen das ausgebende Kreditinstitut der
- * Umrechnung zugestimmt hat. Kreditinstitute, welche einer Umrechnung nicht
- * zugestimmt haben und welche zum Teil spezielle, dem SEPA Account Converter
- * nicht bekannte Umrechnungsmethoden verwenden, sind in der Datei "CONFIG.INI"
- * hinterlegt. Durch Löschen der Datei "CONFIG.INI" aus dem Programmverzeichnis
- * haben Sie die Möglichkeit, eine Umrechnung für alle Konten durchzuführen.
- * Bitte beachten Sie dabei, dass die so erhaltenen IBAN und BIC fehlerhaft
- * sein können und deshalb mit ihren Kunden zu überprüfen sind.
- * 
- * Weblinks:
- * 
- *      https://www.sparkasse-rhein-neckar-nord.de/pdf/content/sepa/kurzanleitung.pdf
- *      https://www.sparkasse-rhein-neckar-nord.de/firmenkunden/internationales_geschaeft/sepa/vorteile/index.php
- *      https://www.sparkasse-rhein-neckar-nord.de/firmenkunden/internationales_geschaeft/sepa/vorteile/sepa_account_converter.msi
+ * ===KontoCheckRaw::iban_gen( blz,kto)
+ * =====KontoCheck::iban_gen( kto,blz)
+ * Diese Funktion generiert aus (deutscher) BLZ und Konto einen IBAN, sowie den
+ * zugehörigen BIC.
+ *
+ * Nachdem im Mai 2013 die IBAN-Regeln zur Berechnung von IBAN und BIC aus
+ * Kontonummer und BLZ veröffentlicht wurden, gibt es endlich ein verbindliches
+ * Verfahren zur Bestimmung der IBAN. Die definierten IBAN-Regeln wurden in der
+ * C-Datei eingearbeitet und werden automatisch ausgewertet, falls der Block mit
+ * den IBAN-Regeln in der LUT-Datei enthalten ist. Andere LUT-Dateien sollten
+ * für die IBAN-Berechnung möglichst nicht verwendet werden, da die Anzahl der
+ * BLZs mit Sonderregelungen doch sehr groß ist.
  *
  * Es ist möglich, sowohl die Prüfung auf Stimmigkeit der Kontonummer als auch
- * auf Zulässigkeit der Selbstberechnung zu deaktivieren. Falls die IBAN trotz
- * fehlender Zustimmung der Bank berechnet werden, ist vor die BLZ ein @ zu
+ * die "schwarze Liste" (ausgeschlossene BLZs) zu deaktivieren. Falls die IBAN
+ * ohne Test der Blacklist berechnet werden soll, ist vor die BLZ ein @ zu
  * setzen; falls auch bei falscher Bankverbindung ein IBAN berechnet werden
  * soll, ist vor die BLZ ein + zu setzen. Um beide Prüfungen zu deaktiviern,
  * kann @+ (oder +@) vor die BLZ gesetzt werden. Die so erhaltenen IBANs sind
- * dann i.A. allerdings wohl nicht gültig.
- * 
- * Mögliche Statuscodes sind:
- *    -110  OK_UNTERKONTO_ATTACHED    "wahrscheinlich OK; es wurde allerdings ein (weggelassenes) Unterkonto angefügt"
- *     -77  (BAV_FALSE)               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
- *     -74  (NO_GERMAN_BIC)           "Ein Konto kann kann nur für deutsche Banken geprüft werden"
- *     -69  (MISSING_PARAMETER)       "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
- *     -40  (LUT2_NOT_INITIALIZED)    "die Programmbibliothek wurde noch nicht initialisiert"
- *     -29  (UNDEFINED_SUBMETHOD)     "Die (Unter)Methode ist nicht definiert"
- *     -12  (INVALID_KTO_LENGTH)      "ein Konto muß zwischen 1 und 10 Stellen haben"
- *      -5  (INVALID_BLZ_LENGTH)      "die Bankleitzahl ist nicht achtstellig"
- *      -4  (INVALID_BLZ)             "Die (Unter)Methode ist nicht definiert"
- *      -3  (INVALID_KTO)             "das Konto ist ungültig"
- *      -2  (NOT_IMPLEMENTED)         "die Methode wurde noch nicht implementiert"
- *      -1  (NOT_DEFINED)             "die Methode ist nicht definiert"
- *       0  (FALSE)                   "falsch"
- *       1  (OK)                      "ok"
- *       2  (OK_NO_CHK)               "ok, ohne Prüfung"
- *      11  (OK_UNTERKONTO_POSSIBLE)  "wahrscheinlich ok; die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten"
- *      12  (OK_UNTERKONTO_GIVEN)     "wahrscheinlich ok; die Kontonummer enthält eine Unterkontonummer"
+ * dann u.U. allerdings wohl nicht gültig.
+ * 
+ * ====Aufruf:
+ * ret=KontoCheckRaw::iban_gen( blz,kto)
+ *
+ * ====Parameter:
+ * * blz: die BLZ, zu der die IBAN generiert werden soll
+ * * kto: Kontonummer
+ *
+ * ====Rückgabe:
+ * Rückgabe ist ein Array mit sieben Elementen:
+ * * das erste Element enthält die generierten IBAN in komprimierter Form
+ * * das zweite Element enthält die generierte IBAN in Papierform (mit eingestreuten Blanks)
+ * * das dritte Element enthält den Statuscode der Funktion
+ * * das vierte Element enthält den BIC (dieser unterscheidet sich u.U. von demjenigen der BLZ-Datei!!). Dieses und die folgenden Elemente waren ursprünglich nicht in der Funktion enthalten und wurde erst nach Einführung der IBAN-Regeln (Juni 2013) hinzugefügt.
+ * * das fünfte Element enthält die verwendete BLZ
+ * * das sechste Element enthält die verwendete Kontonummer
+ * * das siebte Element enthält die verwendete IBAN-Regel
+ *
+ * ====Mögliche Statuscodes:
+ * *  -128  (IBAN_INVALID_RULE)       "Die BLZ passt nicht zur angegebenen IBAN-Regel"
+ * *  -127  (IBAN_AMBIGUOUS_KTO)      "Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten)"
+ * *  -125  (IBAN_RULE_UNKNOWN)       "Die IBAN-Regel ist nicht bekannt"
+ * *  -124  (NO_IBAN_CALCULATION)     "Für die Bankverbindung ist keine IBAN-Berechnung erlaubt"
+ * *  -123  (OLD_BLZ_OK_NEW_NOT)      "Die Bankverbindung ist mit der alten BLZ stimmig, mit der Nachfolge-BLZ nicht"
+ * *  -122  (LUT2_IBAN_REGEL_NOT_INITIALIZED) "Das Feld IBAN-Regel wurde nicht initialisiert"
+ * *  -120  (LUT2_NO_ACCOUNT_GIVEN)   "Keine Bankverbindung/IBAN angegeben"
+ * *  -113  (NO_OWN_IBAN_CALCULATION) "das Institut erlaubt keine eigene IBAN-Berechnung"
+ * *   -77  (BAV_FALSE)               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
+ * *   -74  (NO_GERMAN_BIC)           "Ein Konto kann kann nur für deutsche Banken geprüft werden"
+ * *   -69  (MISSING_PARAMETER)       "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
+ * *   -40  (LUT2_NOT_INITIALIZED)    "die Programmbibliothek wurde noch nicht initialisiert"
+ * *   -29  (UNDEFINED_SUBMETHOD)     "Die (Unter)Methode ist nicht definiert"
+ * *   -12  (INVALID_KTO_LENGTH)      "ein Konto muß zwischen 1 und 10 Stellen haben"
+ * *    -5  (INVALID_BLZ_LENGTH)      "die Bankleitzahl ist nicht achtstellig"
+ * *    -4  (INVALID_BLZ)             "Die Bankleitzahl ist nicht definiert"
+ * *    -3  (INVALID_KTO)             "das Konto ist ungültig"
+ * *    -2  (NOT_IMPLEMENTED)         "die Methode wurde noch nicht implementiert"
+ * *    -1  (NOT_DEFINED)             "die (Unter)Methode ist nicht definiert"
+ * *     0  (FALSE)                   "falsch"
+ * *     1  (OK)                      "ok"
+ * *     2  (OK_NO_CHK)               "ok, ohne Prüfung"
+ * *    11  (OK_UNTERKONTO_POSSIBLE)  "wahrscheinlich ok; die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten"
+ * *    12  (OK_UNTERKONTO_GIVEN)     "wahrscheinlich ok; die Kontonummer enthält eine Unterkontonummer"
+ * *    18  (OK_KTO_REPLACED)         "ok; die Kontonummer wurde allerdings ersetzt"
+ * *    19  (OK_BLZ_REPLACED)         "ok; die Bankleitzahl wurde allerdings ersetzt"
+ * *    20  (OK_BLZ_KTO_REPLACED)     "ok; die Bankleitzahl und Kontonummer wurde allerdings ersetzt"
+ * *    21  (OK_IBAN_WITHOUT_KC_TEST) "ok; die Bankverbindung ist (ohne Test) als richtig anzusehen"
+ * *    22  (OK_INVALID_FOR_IBAN)     "ok; für IBAN ist (durch eine Regel) allerdings ein anderer BIC definiert"
+ * *    24  (OK_KTO_REPLACED_NO_PZ)   "ok; die Kontonummer wurde ersetzt, die neue Kontonummer hat keine Prüfziffer"
+ * *    25  (OK_UNTERKONTO_ATTACHED)  "ok; es wurde ein (weggelassenes) Unterkonto angefügt"
  */
 static VALUE iban_gen_rb(int argc,VALUE* argv,VALUE self)
 {
-   char iban[128],*papier,*ptr,*dptr,blz[20],kto[20];
-   int retval;
-   VALUE iban_rb,papier_rb;
+   char iban[128],*papier,*ptr,*dptr,blz[20],kto[20],blz2[20],kto2[20];
+   const char *bic;
+   int retval,regel;
+   VALUE iban_rb,papier_rb,bic_rb,blz2_rb,kto2_rb;
 
    get_params(argc,argv,blz,kto,NULL,NULL,2);
-   papier=iban_gen(blz,kto,&retval);
-   if(retval==OK || retval==OK_UNTERKONTO_ATTACHED || retval==OK_UNTERKONTO_POSSIBLE || retval==OK_UNTERKONTO_GIVEN){
+   papier=iban_bic_gen(blz,kto,&bic,blz2,kto2,&retval);
+   regel=-1;
+   if(retval>0){
       for(ptr=papier,dptr=iban;*ptr;ptr++)if(*ptr!=' ')*dptr++=*ptr;
       *dptr=0;
       iban_rb=rb_str_new2(iban);
       papier_rb=rb_str_new2(papier);
+      bic_rb=rb_str_new2(bic);
+      blz2_rb=rb_str_new2(blz2);
+      kto2_rb=rb_str_new2(kto2);
       kc_free(papier);  /* die C-Funktion allokiert Speicher, der muß wieder freigegeben werden */
+      regel=lut_iban_regel(blz,0,NULL)/100;
    }
    else
-      iban_rb=papier_rb=Qnil;
-   return rb_ary_new3(3,iban_rb,papier_rb,INT2FIX(retval));
+      iban_rb=papier_rb=blz2_rb=kto2_rb=bic_rb=Qnil;
+   return rb_ary_new3(7,iban_rb,papier_rb,INT2FIX(retval),bic_rb,blz2_rb,kto2_rb,INT2FIX(regel));
+}
+
+/**
+ * ===KontoCheckRaw::ci_check( ci)
+ * =====KontoCheck::ci_check( ci)
+ * Diese Funktion testet eine Gläubiger-Identifikationsnummer (Credit Identifier, ci)
+ *
+ * ====Aufruf:
+ * ret=KontoCheckRaw::ci_check( ci)
+ *
+ * ====Parameter:
+ * * ci: der CI, der getestet werden soll
+ *
+ * ====Mögliche Rückgabewerte für den Test:
+ * *     0  (FALSE)                   "falsch"
+ * *     1  (OK)                      "ok"
+ *
+ */
+static VALUE ci_check_rb(int argc,VALUE* argv,VALUE self)
+{
+   char ci[128];
+
+   get_params(argc,argv,ci,NULL,NULL,NULL,3);
+   return INT2FIX(ci_check(ci));
+}
+
+/**
+ * ===KontoCheckRaw::bic_check( bic)
+ * =====KontoCheck::bic_check( bic)
+ * Diese Funktion testet einen BIC (nur für deutsche Bankverbindungen). Die
+ * Rückgabe ist ein Array mit zwei Elementen: im ersten (retval) wird das
+ * Testergebnis für die zurückgegeben, im zweiten die Änzahl Banken, die diesen
+ * BIC benutzen (interessant bei 8stelligen BICs)
+ *
+ * ====Aufruf:
+ * ret=KontoCheckRaw::bic_check( bic)
+ *
+ * ====Parameter:
+ * * bic: der bic, der getestet werden soll
+ *
+ * ====Rückgabe:
+ * Rückgabe ist ein Array mit zwei Elementen:
+ * * das erste Element enthält den Statuscode
+ * * das zweite Element enthält die Anzahl Banken, die diesen BIC benutzen
+ *
+ * ====Mögliche Rückgabewerte:
+ * *  -145  (BIC_ONLY_GERMAN)         "Es werden nur deutsche BICs unterstützt";
+ * *  -144  (INVALID_BIC_LENGTH)      "Die Länge des BIC muß genau 8 oder 11 Zeichen sein"
+ * *     0  (FALSE)                   "falsch"
+ * *     1  (OK)                      "ok"
+ */
+static VALUE bic_check_rb(int argc,VALUE* argv,VALUE self)
+{
+   char bic[12];
+   int retval,cnt;
+
+   get_params(argc,argv,bic,NULL,NULL,NULL,8);
+   retval=bic_check(bic,&cnt);
+   return rb_ary_new3(2,INT2FIX(retval),INT2FIX(cnt));
 }
 
 /**
- * ===<tt>KontoCheckRaw::iban_check(blz)</tt>
- * =====<tt>KontoCheck::iban_check(iban)</tt>
+ * ===KontoCheckRaw::iban_check( iban)
+ * =====KontoCheck::iban_check( iban)
  * Diese Funktion testet eine IBAN; bei deutschen Bankverbindungen wird
  * zusätzlich noch die Plausibilität der Bankverbindung getestet und im
  * Statuswert zurückgegeben. Die Rückgabe ist ein Array mit zwei Elementen: im
  * ersten (retval) wird das Testergebnis für die IBAN zurückgegeben, im zweiten
  * (bei deutschen Bankverbindungen) das Testergebnis des Kontotests.
  *
- * Mögliche Rückgabewerte für den IBAN-Test:
- *
- *     -67  (IBAN_OK_KTO_NOT)         "Die Prüfziffer der IBAN stimmt, die der Kontonummer nicht"
- *     -66  (KTO_OK_IBAN_NOT)         "Die Prüfziffer der Kontonummer stimmt, die der IBAN nicht"
- *       0  (FALSE)                   "falsch"
- *       1  (OK)                      "ok"
- *
- * Mögliche Rückgabewerte für den Kontotest:
- *     -77  (BAV_FALSE)               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
- *     -74  (NO_GERMAN_BIC)           "Ein Konto kann kann nur für deutsche Banken geprüft werden"
- *     -69  (MISSING_PARAMETER)       "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
- *     -40  (LUT2_NOT_INITIALIZED)    "die Programmbibliothek wurde noch nicht initialisiert"
- *     -29  (UNDEFINED_SUBMETHOD)     "Die (Unter)Methode ist nicht definiert"
- *     -12  (INVALID_KTO_LENGTH)      "ein Konto muß zwischen 1 und 10 Stellen haben"
- *      -5  (INVALID_BLZ_LENGTH)      "die Bankleitzahl ist nicht achtstellig"
- *      -4  (INVALID_BLZ)             "Die (Unter)Methode ist nicht definiert"
- *      -3  (INVALID_KTO)             "das Konto ist ungültig"
- *      -2  (NOT_IMPLEMENTED)         "die Methode wurde noch nicht implementiert"
- *      -1  (NOT_DEFINED)             "die Methode ist nicht definiert"
- *       0  (FALSE)                   "falsch"
- *       1  (OK)                      "ok"
- *       2  (OK_NO_CHK)               "ok, ohne Prüfung"
+ * ====Aufruf:
+ * ret=KontoCheckRaw::iban_check( iban)
+ *
+ * ====Parameter:
+ * * iban: die IBAN, die getestet werden soll
+ *
+ * ====Rückgabe:
+ * Rückgabe ist ein Array mit zwei Elementen:
+ * * das erste Element enthält den Statuscode für den IBAN-Test
+ * * das zweite Element enthält den Statuscode für den Test der Bankverbindung (nur für deutsche Kontoverbindungen)
+ *
+ * ====Mögliche Rückgabewerte für den IBAN-Test:
+ * *   -67  (IBAN_OK_KTO_NOT)         "Die Prüfziffer der IBAN stimmt, die der Kontonummer nicht"
+ * *   -66  (KTO_OK_IBAN_NOT)         "Die Prüfziffer der Kontonummer stimmt, die der IBAN nicht"
+ * *     0  (FALSE)                   "falsch"
+ * *     1  (OK)                      "ok"
+ *
+ * ====Mögliche Rückgabewerte für den Kontotest:
+ * *   -77  (BAV_FALSE)               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
+ * *   -74  (NO_GERMAN_BIC)           "Ein Konto kann kann nur für deutsche Banken geprüft werden"
+ * *   -69  (MISSING_PARAMETER)       "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
+ * *   -40  (LUT2_NOT_INITIALIZED)    "die Programmbibliothek wurde noch nicht initialisiert"
+ * *   -29  (UNDEFINED_SUBMETHOD)     "Die (Unter)Methode ist nicht definiert"
+ * *   -12  (INVALID_KTO_LENGTH)      "ein Konto muß zwischen 1 und 10 Stellen haben"
+ * *    -5  (INVALID_BLZ_LENGTH)      "die Bankleitzahl ist nicht achtstellig"
+ * *    -4  (INVALID_BLZ)             "Die (Unter)Methode ist nicht definiert"
+ * *    -3  (INVALID_KTO)             "das Konto ist ungültig"
+ * *    -2  (NOT_IMPLEMENTED)         "die Methode wurde noch nicht implementiert"
+ * *    -1  (NOT_DEFINED)             "die Methode ist nicht definiert"
+ * *     0  (FALSE)                   "falsch"
+ * *     1  (OK)                      "ok"
+ * *     2  (OK_NO_CHK)               "ok, ohne Prüfung"
  */
 static VALUE iban_check_rb(int argc,VALUE* argv,VALUE self)
 {
@@ -1239,24 +1860,38 @@ static VALUE iban_check_rb(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::ipi_gen(<zweck>)</tt>
- * =====<tt>KontoCheck::ipi_gen(<zweck>)</tt>
- *
- * Diese Funktion generiert einen "Strukturierten Verwendungszweck" für SEPA-Überweisungen.
- * Der Rückgabewert ist der Strukturierte Verwendungszweck als String oder nil, falls ein Fehler
- * aufgetreten ist.
- * 
- * Der String für den Strukturierten Verwendungszweck darf maximal 18 Byte lang sein und nur
- * alphanumerische Zeichen enthalten (also auch keine Umlaute).
- *
- * Der Rückgabewert ist ein Array mit drei Elementen: im ersten steht der Strukturierte Verwendungszweck,
- * im zweiten ein Statuscode und im dritten die Papierform (mit eingestreuten Blanks).
- * 
- * Mögliche Statuscodes:
- *
- *     -71  (IPI_INVALID_LENGTH)         "Die Länge des IPI-Verwendungszwecks darf maximal 18 Byte sein"
- *     -72  (IPI_INVALID_CHARACTER)      "Im strukturierten Verwendungszweck dürfen nur alphanumerische Zeichen vorkommen"
- *       1  (OK)                         "ok"
+ * ===KontoCheckRaw::ipi_gen( zweck)
+ * =====KontoCheck::ipi_gen( zweck)
+ *
+ * Diese Funktion generiert einen "Strukturierten Verwendungszweck" für
+ * SEPA-Überweisungen. Der Rückgabewert ist der Strukturierte Verwendungszweck
+ * als String oder nil, falls ein Fehler aufgetreten ist.
+ *
+ * _ACHTUNG_ Die Reihenfolge der Parameter dieser Funktion hat sich in Version
+ * 0.2.2 geändert; der Statuscode wird nun als letzter Arraywert zurückgegeben,
+ * die Papierform als zweiter Wert (wie bei iban_gen(). Es ist nicht schön,so
+ * allerdings insgesamt konsistenter (ich habe auch eine Abneigung gegen
+ * Änderungen des Interfaces, aber an dieser Stelle schien es geboten zu sein).
+ * 
+ * ====Aufruf:
+ * ret=KontoCheckRaw::ipi_gen( zweck)
+ *
+ * ====Parameter:
+ * * zweck: String für den ein Strukturierter Verwendungszweck generiert werden soll.
+ *   Der String für den Strukturierten Verwendungszweck darf maximal 18 Byte lang
+ *   sein und nur alphanumerische Zeichen enthalten (also auch keine Umlaute).
+ *
+ *
+ * ====Rückgabe:
+ * Der Rückgabewert ist ein Array mit drei Elementen:
+ * * im ersten steht der Strukturierte Verwendungszweck,
+ * * im zweiten die Papierform (mit eingestreuten Blanks).
+ * * im dritten ein Statuscode 
+ * 
+ * ====Mögliche Statuscodes:
+ * *   -71  (IPI_INVALID_LENGTH)         "Die Länge des IPI-Verwendungszwecks darf maximal 18 Byte sein"
+ * *   -72  (IPI_INVALID_CHARACTER)      "Im strukturierten Verwendungszweck dürfen nur alphanumerische Zeichen vorkommen"
+ * *     1  (OK)                         "ok"
  */
 static VALUE ipi_gen_rb(int argc,VALUE* argv,VALUE self)
 {
@@ -1266,22 +1901,32 @@ static VALUE ipi_gen_rb(int argc,VALUE* argv,VALUE self)
    get_params(argc,argv,zweck,NULL,NULL,NULL,4);
    retval=ipi_gen(zweck,dst,papier);
    if(retval==OK)
-      return rb_ary_new3(3,rb_str_new2(dst),INT2FIX(retval),rb_str_new2(papier));
+      return rb_ary_new3(3,rb_str_new2(dst),rb_str_new2(papier),INT2FIX(retval));
    else
-      return rb_ary_new3(3,Qnil,INT2FIX(retval),Qnil);
+      return rb_ary_new3(3,Qnil,Qnil,INT2FIX(retval));
 }
 
 /**
- * ===<tt>KontoCheckRaw::ipi_check(<zweck>)</tt>
- * =====<tt>KontoCheck::ipi_check(<zweck>)</tt>
+ * ===KontoCheckRaw::ipi_check( zweck)
+ * =====KontoCheck::ipi_check( zweck)
  * 
  * Die Funktion testet, ob ein Strukturierter Verwendungszweck gültig ist
- * (Anzahl Zeichen, Prüfziffer). Die Rückgabe ist ein Statuscode, der die
- * folgenden Werte annehmen kann:
+ * (Anzahl Zeichen, Prüfziffer).
+ *
+ * ====Aufruf:
+ * ret=KontoCheckRaw::ipi_check( zweck)
+ *
+ * ====Parameter:
+ * * zweck: der Strukturierte Verwendungszweck, der getestet werden soll
+ *
+ * ====Rückgabe:
+ * Zurückgegeben wird ein skalarer Statuscode.
  * 
- *     -73  (IPI_CHECK_INVALID_LENGTH)   "Der zu validierende strukturierete Verwendungszweck muß genau 20 Zeichen enthalten"
- *       0  (FALSE)                      "falsch"
- *       1  (OK)                         "ok"
+ *
+ * ====Mögliche Statuscodes:
+ * *   -73  (IPI_CHECK_INVALID_LENGTH)   "Der zu validierende strukturierete Verwendungszweck muß genau 20 Zeichen enthalten"
+ * *     0  (FALSE)                      "falsch"
+ * *     1  (OK)                         "ok"
  */
 static VALUE ipi_check_rb(int argc,VALUE* argv,VALUE self)
 {
@@ -1292,9 +1937,9 @@ static VALUE ipi_check_rb(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ====<tt>KontoCheckRaw::bank_valid(blz [,filiale])</tt>
- * ====== <tt>KontoCheck::bank_valid(blz [,filiale])</tt>
- * ====== <tt>KontoCheck::bank_valid?(blz [,filiale])</tt>
+ * ====KontoCheckRaw::bank_valid( blz [,filiale])
+ * ====== KontoCheck::bank_valid( blz [,filiale])
+ * ====== KontoCheck::bank_valid?( blz [,filiale])
  * Diese Funktion testet, ob eine gegebene BLZ gültig ist. Der Rückgabewert ist ein
  * Statuscode mit den unten angegebenen Werten. Falls das Argument filiale auch
  * angegeben ist, wird zusätzlich noch getestet, ob eine Filiale mit dem gegebenen
@@ -1320,8 +1965,8 @@ static VALUE bank_valid(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_filialen(blz)</tt>
- * =====<tt>KontoCheck::bank_filialen(blz)</tt>
+ * ===KontoCheckRaw::bank_filialen( blz)
+ * =====KontoCheck::bank_filialen( blz)
  * 
  * Diese Funktion liefert die Anzahl Filialen einer Bank (inklusive Hauptstelle).
  * Die LUT-Datei muß dazu natürlich mit den Filialdaten generiert sein, sonst
@@ -1350,8 +1995,8 @@ static VALUE bank_filialen(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_alles(blz[,filiale])</tt>
- * =====<tt>KontoCheck::bank_alles(blz[,filiale])</tt>
+ * ===KontoCheckRaw::bank_alles( blz [,filiale])
+ * =====KontoCheck::bank_alles( blz [,filiale])
  * 
  * Dies ist eine Mammutfunktion, die alle vorhandenen Informationen über eine
  * Bank zurückliefert. Das Ergebnis ist ein Array mit den folgenden Komponenten:
@@ -1422,8 +2067,8 @@ static VALUE bank_alles(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_name(blz[,filiale])</tt>
- * =====<tt>KontoCheck::bank_name(blz[,filiale])</tt>
+ * ===KontoCheckRaw::bank_name( blz [,filiale])
+ * =====KontoCheck::bank_name( blz [,filiale])
  * 
  * Diese Funktion liefert den Namen einer Bank. Der Rückgabewert ist ein
  * Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im
@@ -1451,8 +2096,8 @@ static VALUE bank_name(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_name_kurz(blz [,filiale])</tt>
- * =====<tt>KontoCheck::bank_name_kurz(blz [,filiale])</tt>
+ * ===KontoCheckRaw::bank_name_kurz( blz [,filiale])
+ * =====KontoCheck::bank_name_kurz( blz [,filiale])
  * 
  * Diese Funktion liefert den Kurznamen einer Bank. Der Rückgabewert ist ein
  * Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im
@@ -1480,8 +2125,8 @@ static VALUE bank_name_kurz(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_ort(blz[,filiale])</tt>
- * =====<tt>KontoCheck::bank_ort(blz[,filiale])</tt>
+ * ===KontoCheckRaw::bank_ort( blz [,filiale])
+ * =====KontoCheck::bank_ort( blz [,filiale])
  *
  * Diese Funktion liefert den Ort einer Bank. Falls der Parameter filiale nicht
  * angegeben ist, wird der Sitz der Hauptstelle ausgegeben. Der Rückgabewert
@@ -1511,8 +2156,8 @@ static VALUE bank_ort(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_plz(blz [,filiale])</tt>
- * =====<tt>KontoCheck::bank_plz(blz [,filiale])</tt>
+ * ===KontoCheckRaw::bank_plz( blz [,filiale])
+ * =====KontoCheck::bank_plz( blz [,filiale])
  * 
  * Diese Funktion liefert die Postleitzahl einer Bank. Falls der Parameter
  * filiale nicht angegeben ist, wird die PLZ der Hauptstelle ausgegeben. Der
@@ -1540,8 +2185,8 @@ static VALUE bank_plz(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_pz(blz)</tt>
- * =====<tt>KontoCheck::bank_pz(blz)</tt>
+ * ===KontoCheckRaw::bank_pz( blz)
+ * =====KontoCheck::bank_pz( blz)
  * 
  * Diese Funktion liefert die Prüfziffer einer Bank. Die Funktion unterstützt
  * keine Filialen; zu jeder BLZ kann es in der LUT-Datei nur eine
@@ -1570,8 +2215,8 @@ static VALUE bank_pz(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_bic(blz[,filiale])</tt>
- * =====<tt>KontoCheck::bank_bic(blz[,filiale])</tt>
+ * ===KontoCheckRaw::bank_bic( blz [,filiale])
+ * =====KontoCheck::bank_bic( blz [,filiale])
  * 
  * Diese Funktion liefert den BIC (Bank Identifier Code) einer Bank. Der
  * Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String
@@ -1600,8 +2245,8 @@ static VALUE bank_bic(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_aenderung(blz [,filiale])</tt>
- * =====<tt>KontoCheck::bank_aenderung(blz [,filiale])</tt>
+ * ===KontoCheckRaw::bank_aenderung( blz [,filiale])
+ * =====KontoCheck::bank_aenderung( blz [,filiale])
  * 
  * Diese Funktion liefert das  'Änderung' Flag einer Bank (als string).
  * Mögliche Werte sind: A (Addition), M (Modified), U (Unchanged), D
@@ -1631,8 +2276,8 @@ static VALUE bank_aenderung(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheck::bank_loeschung(blz [,filiale])</tt>
- * =====<tt>KontoCheckRaw::bank_loeschung(blz [,filiale])</tt>
+ * ===KontoCheckRaw::bank_loeschung( blz [,filiale])
+ * =====KontoCheck::bank_loeschung( blz [,filiale])
  * 
  * Diese Funktion liefert das Lösch-Flag für eine Bank zurück (als Integer;
  * mögliche Werte sind 0 und 1). Der Rückgabewert ist ein Array mit zwei
@@ -1660,8 +2305,8 @@ static VALUE bank_loeschung(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_nachfolge_blz(blz [,filiale])</tt>
- * =====<tt>KontoCheck::bank_nachfolge_blz(blz [,filiale])</tt>
+ * ===KontoCheckRaw::bank_nachfolge_blz( blz [,filiale])
+ * =====KontoCheck::bank_nachfolge_blz( blz [,filiale])
  * 
  * Diese Funktion liefert die Nachfolge-BLZ für eine Bank, die gelöscht werden
  * soll (bei der das 'Löschung' Flag 1 ist). Der Rückgabewert ist ein Array mit
@@ -1689,10 +2334,8 @@ static VALUE bank_nachfolge_blz(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_pan(blz[,filiale])</tt>
- *
- * ===<tt>KontoCheckRaw::bank_pan(blz [,filiale])</tt>
- * =====<tt>KontoCheck::bank_pan(blz [,filiale])</tt>
+ * ===KontoCheckRaw::bank_pan( blz [,filiale])
+ * =====KontoCheck::bank_pan( blz [,filiale])
  * 
  * Diese Funktion liefert den PAN (Primary Account Number) einer Bank. Der
  * Rückgabewert ist ein Array mit zwei Elementen: im ersten steht der PAN, im
@@ -1719,8 +2362,8 @@ static VALUE bank_pan(int argc,VALUE* argv,VALUE self)
 }
 
 /**
- * ===<tt>KontoCheck::bank_nr(blz [,filiale])</tt>
- * =====<tt>KontoCheckRaw::bank_nr(blz[,filiale])</tt>
+ * ===KontoCheckRaw::bank_nr( blz [,filiale])
+ * =====KontoCheck::bank_nr( blz [,filiale])
  * 
  * Diese Funktion liefert die laufende Nummer einer Bank (internes Feld der
  * BLZ-Datei). Der Wert wird wahrscheinlich nicht oft benötigt, ist aber der
@@ -1835,18 +2478,75 @@ static VALUE bank_nr(int argc,VALUE* argv,VALUE self)
  * 
  */
 
+/* bank_suche_int(): dies ist die generische Suchfunktion für alle Textsuchen.
+ * Die jeweilige Suchfunktion der C-Bibliothek wird durch einen
+ * Funktionspointer (letztes Argument) festgelegt.
+ */
+static VALUE bank_suche_int(int argc,VALUE* argv,VALUE self,int (*suchfkt_s)(char*,int*,int**,int**,char***,int**),
+      int (*suchfkt_i)(int,int,int*,int**,int**,int**,int**))
+{
+   char such_name[128],**base_name,error_msg[512];
+   int i,j,k,retval,such1,such2,anzahl,anzahl2,last_blz,uniq,*start_idx,*zweigstelle,*blz_base,*base_name_i;
+   int *idx_o,*cnt_o;
+   VALUE ret_blz,ret_idx,ret_suche;
+
+   if(suchfkt_s){
+      get_params(argc,argv,such_name,NULL,NULL,&uniq,7);
+      retval=(*suchfkt_s)(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
+   }
+   else{
+      get_params_int(argc,argv,&such1,&such2,&uniq);
+      if(!such2)such2=such1;
+      retval=(*suchfkt_i)(such1,such2,&anzahl,&start_idx,&zweigstelle,&base_name_i,&blz_base);
+   }
+   if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
+   if(retval<0)RUNTIME_ERROR(retval);
+   if(uniq) /* bei uniq>0 sortieren, uniq>1 sortieren + uniq */
+      lut_suche_sort1(anzahl,blz_base,zweigstelle,start_idx,&anzahl2,&idx_o,&cnt_o,uniq>1);
+   else{
+      anzahl2=anzahl;
+      idx_o=start_idx;
+      cnt_o=NULL;
+   }
+   ret_suche=rb_ary_new2(anzahl2);
+   ret_blz=rb_ary_new2(anzahl2);
+   ret_idx=rb_ary_new2(anzahl2);
+   for(i=k=0,last_blz=-1;i<anzahl2;i++){
+      j=idx_o[i];   /* Index innerhalb der BLZ-Datei */
+      if(uniq>1 && blz_base[j]==last_blz)
+         continue;
+      else
+         last_blz=blz_base[j];
+      if(suchfkt_s)
+         rb_ary_store(ret_suche,k,rb_str_new2(base_name[j]));
+      else{
+         if(suchfkt_i==lut_suche_regel)
+            rb_ary_store(ret_suche,k,INT2FIX(base_name_i[j]/100));   /* nur die Regel ausgeben, ohne Version */
+         else
+            rb_ary_store(ret_suche,k,INT2FIX(base_name_i[j]));
+      }
+      rb_ary_store(ret_blz,k,INT2FIX(blz_base[j]));
+      rb_ary_store(ret_idx,k++,INT2FIX(zweigstelle[j]));
+   }
+   if(uniq){
+      kc_free((char*)idx_o);
+      kc_free((char*)cnt_o);
+   }
+   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl2));
+}
+
 /**
- * ===<tt>KontoCheckRaw::bank_suche_bic(search_bic)</tt>
- * =====<tt>KontoCheck::suche()</tt>
+ * ===KontoCheckRaw::bank_suche_bic( search_bic [,sort_uniq [,sort]])
+ * =====KontoCheck::suche()
  *
  * Diese Funktion sucht alle Banken, deren BIC mit dem angegebenen Wert <search_bic> beginnen.
  * Die Rückgabe ist ein Array mit fünf Elementen:
  *
- *    0. Das erste Element ist ein Array mit den gefundenen BIC-Werten
- *    1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
- *    2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
- *    3. das vierte Element ist der Statuscode (s.u.)
- *    4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
+ * * Das erste Element ist ein Array mit den gefundenen BIC-Werten
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
+ * * das vierte Element ist der Statuscode (s.u.)
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
  *
  * Mögliche Statuscodes:
  *
@@ -1859,38 +2559,21 @@ static VALUE bank_nr(int argc,VALUE* argv,VALUE self)
  */
 static VALUE bank_suche_bic(int argc,VALUE* argv,VALUE self)
 {
-   char such_name[128],**base_name,error_msg[512];
-   int i,j,retval,anzahl,*start_idx,*zweigstelle,*blz_base;
-   VALUE ret_blz,ret_idx,ret_suche;
-
-   get_params(argc,argv,such_name,NULL,NULL,NULL,3);
-   retval=lut_suche_bic(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
-   if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
-   if(retval<0)RUNTIME_ERROR(retval);
-   ret_suche=rb_ary_new2(anzahl);
-   ret_blz=rb_ary_new2(anzahl);
-   ret_idx=rb_ary_new2(anzahl);
-   for(i=0;i<anzahl;i++){
-      j=start_idx[i];   /* Index innerhalb der BLZ-Datei */
-      rb_ary_store(ret_suche,i,rb_str_new2(base_name[j]));
-      rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
-      rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
-   }
-   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
+   return bank_suche_int(argc,argv,self,lut_suche_bic,NULL);
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_suche_namen(name)</tt>
- * =====<tt>KontoCheck::suche()</tt>
+ * ===KontoCheckRaw::bank_suche_namen( name [,sort_uniq [,sort]])
+ * =====KontoCheck::suche()
  *
- * Diese Funktion sucht alle Banken, deren Namen mit dem angegebenen Wert <search_bic> beginnen.
+ * Diese Funktion sucht alle Banken, deren Namen mit dem angegebenen Wert <name> beginnen.
  * Die Rückgabe ist ein Array mit fünf Elementen:
  *
- *    0. Das erste Element ist ein Array mit den gefundenen Namenswerten
- *    1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
- *    2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
- *    3. das vierte Element ist der Statuscode (s.u.)
- *    4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
+ * * Das erste Element ist ein Array mit den gefundenen Namen
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
+ * * das vierte Element ist der Statuscode (s.u.)
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
  *
  * Mögliche Statuscodes:
  *
@@ -1903,38 +2586,21 @@ static VALUE bank_suche_bic(int argc,VALUE* argv,VALUE self)
  */
 static VALUE bank_suche_namen(int argc,VALUE* argv,VALUE self)
 {
-   char such_name[128],**base_name,error_msg[512];
-   int i,j,retval,anzahl,*start_idx,*zweigstelle,*blz_base;
-   VALUE ret_blz,ret_idx,ret_suche;
-
-   get_params(argc,argv,such_name,NULL,NULL,NULL,3);
-   retval=lut_suche_namen(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
-   if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
-   if(retval<0)RUNTIME_ERROR(retval);
-   ret_suche=rb_ary_new2(anzahl);
-   ret_blz=rb_ary_new2(anzahl);
-   ret_idx=rb_ary_new2(anzahl);
-   for(i=0;i<anzahl;i++){
-      j=start_idx[i];   /* Index innerhalb der BLZ-Datei */
-      rb_ary_store(ret_suche,i,rb_str_new2(base_name[j]));
-      rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
-      rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
-   }
-   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
+   return bank_suche_int(argc,argv,self,lut_suche_namen,NULL);
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_suche_namen_kurz(short_name)</tt>
- * =====<tt>KontoCheck::suche()</tt>
+ * ===KontoCheckRaw::bank_suche_namen_kurz( short_name [,sort_uniq [,sort]])
+ * =====KontoCheck::suche()
  *
  * Diese Funktion sucht alle Banken, deren Kurznamen mit dem angegebenen Wert <search_bic> beginnen.
  * Die Rückgabe ist ein Array mit fünf Elementen:
  *
- *    0. Das erste Element ist ein Array mit den gefundenen Namenswerten
- *    1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
- *    2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
- *    3. das vierte Element ist der Statuscode (s.u.)
- *    4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
+ * * Das erste Element ist ein Array mit den gefundenen Kurznamen
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
+ * * das vierte Element ist der Statuscode (s.u.)
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
  *
  * Mögliche Statuscodes:
  *
@@ -1947,39 +2613,22 @@ static VALUE bank_suche_namen(int argc,VALUE* argv,VALUE self)
  */
 static VALUE bank_suche_namen_kurz(int argc,VALUE* argv,VALUE self)
 {
-   char such_name[128],**base_name,error_msg[512];
-   int i,j,retval,anzahl,*start_idx,*zweigstelle,*blz_base;
-   VALUE ret_blz,ret_idx,ret_suche;
-
-   get_params(argc,argv,such_name,NULL,NULL,NULL,3);
-   retval=lut_suche_namen_kurz(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
-   if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
-   if(retval<0)RUNTIME_ERROR(retval);
-   ret_suche=rb_ary_new2(anzahl);
-   ret_blz=rb_ary_new2(anzahl);
-   ret_idx=rb_ary_new2(anzahl);
-   for(i=0;i<anzahl;i++){
-      j=start_idx[i];   /* Index innerhalb der BLZ-Datei */
-      rb_ary_store(ret_suche,i,rb_str_new2(base_name[j]));
-      rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
-      rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
-   }
-   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
+   return bank_suche_int(argc,argv,self,lut_suche_namen_kurz,NULL);
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_suche_plz(plz1[,plz2])</tt>
- * =====<tt>KontoCheck::suche()</tt>
+ * ===KontoCheckRaw::bank_suche_plz( plz1 [,plz2 [,sort_uniq [,sort]]])
+ * =====KontoCheck::suche()
  *
  * Diese Funktion sucht alle Banken, deren PLZ gleich <plz1> ist oder (bei
- * Angabe von plz2) die im Bereich zwischen <plz1> und <plz2> liegen.. Die
+ * Angabe von plz2) die im Bereich zwischen <plz1> und <plz2> liegen. Die
  * Rückgabe ist ein Array mit fünf Elementen:
  *
- *    0. Das erste Element ist ein Array mit den gefundenen Namenswerten
- *    1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
- *    2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
- *    3. das vierte Element ist der Statuscode (s.u.)
- *    4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
+ * * Das erste Element ist ein Array mit den gefundenen Postleitzahlen
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
+ * * das vierte Element ist der Statuscode (s.u.)
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
  *
  * Mögliche Statuscodes:
  *
@@ -1992,39 +2641,22 @@ static VALUE bank_suche_namen_kurz(int argc,VALUE* argv,VALUE self)
  */
 static VALUE bank_suche_plz(int argc,VALUE* argv,VALUE self)
 {
-   char error_msg[512];
-   int i,j,retval,such1,such2,anzahl,*start_idx,*base_name,*zweigstelle,*blz_base;
-   VALUE ret_blz,ret_idx,ret_suche;
-
-   get_params_int(argc,argv,&such1,&such2);
-   retval=lut_suche_plz(such1,such2,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
-   if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
-   if(retval<0)RUNTIME_ERROR(retval);
-   ret_suche=rb_ary_new2(anzahl);
-   ret_blz=rb_ary_new2(anzahl);
-   ret_idx=rb_ary_new2(anzahl);
-   for(i=0;i<anzahl;i++){
-      j=start_idx[i];   /* Index innerhalb der BLZ-Datei */
-      rb_ary_store(ret_suche,i,INT2FIX(base_name[j]));
-      rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
-      rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
-   }
-   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
+   return bank_suche_int(argc,argv,self,NULL,lut_suche_plz);
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_suche_pz(pz1[,pz2])</tt>
- * =====<tt>KontoCheck::suche()</tt>
+ * === KontoCheckRaw::bank_suche_pz( pz1 [,pz2 [,sort_uniq [,sort]]])
+ * ===== KontoCheck::suche()
  *
  * Diese Funktion sucht alle Banken, deren Prüfziffer gleich <pz1> ist oder (bei
- * Angabe von pz2) die im Bereich zwischen <pz1> und <pz2> liegen.. Die
+ * Angabe von pz2) die im Bereich zwischen <pz1> und <pz2> liegen. Die
  * Rückgabe ist ein Array mit fünf Elementen:
  *
- *    0. Das erste Element ist ein Array mit den gefundenen Prüfziffern
- *    1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
- *    2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
- *    3. das vierte Element ist der Statuscode (s.u.)
- *    4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
+ * * Das erste Element ist ein Array mit den gefundenen Prüfziffern
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
+ * * das vierte Element ist der Statuscode (s.u.)
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
  *
  * Mögliche Statuscodes:
  *
@@ -2037,46 +2669,25 @@ static VALUE bank_suche_plz(int argc,VALUE* argv,VALUE self)
  */
 static VALUE bank_suche_pz(int argc,VALUE* argv,VALUE self)
 {
-   char error_msg[512];
-   int i,j,retval,such1,such2,anzahl,*start_idx,*base_name,*zweigstelle,*blz_base;
-   VALUE ret_blz,ret_idx,ret_suche;
-
-   get_params_int(argc,argv,&such1,&such2);
-   retval=lut_suche_pz(such1,such2,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
-   if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
-   if(retval<0)RUNTIME_ERROR(retval);
-   ret_suche=rb_ary_new2(anzahl);
-   ret_blz=rb_ary_new2(anzahl);
-   ret_idx=rb_ary_new2(anzahl);
-   for(i=0;i<anzahl;i++){
-      j=start_idx[i];   /* Index innerhalb der BLZ-Datei */
-      rb_ary_store(ret_suche,i,INT2FIX(base_name[j]));
-      rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
-      rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
-   }
-   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
+   return bank_suche_int(argc,argv,self,NULL,lut_suche_pz);
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_suche_blz(blz1[,blz2])</tt>
- * =====<tt>KontoCheck::suche()</tt>
+ * ===KontoCheckRaw::bank_suche_blz( blz1 [,blz2 [,uniq]])
+ * =====KontoCheck::suche()
  *
  * Diese Funktion sucht alle Banken, deren Bankleitzahl gleich <blz1> ist oder (bei
- * Angabe von blz2) die im Bereich zwischen <blz1> und <blz2> liegen.. Die
+ * Angabe von blz2) die im Bereich zwischen <blz1> und <blz2> liegen. Die
  * Rückgabe ist ein Array mit fünf Elementen:
  *
- *    0. Das erste Element ist ein Array mit den gefundenen Bankleitzahlen
- *    1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen (bei dieser Funktion doppelt gemoppelt :-) )
- *    2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
- *    3. das vierte Element ist der Statuscode (s.u.)
- *    4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
+ * * Das erste Element ist ein Array mit den gefundenen Bankleitzahlen
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen (bei dieser Funktion doppelt gemoppelt :-) )
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
+ * * das vierte Element ist der Statuscode (s.u.)
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
  *
  * Mögliche Statuscodes:
  *
- * find all banks with bic between blz1 and blz2
- *
- * possible return values (and short description):
- *
  *     -78  (KEY_NOT_FOUND)              "Die Suche lieferte kein Ergebnis"
  *     -70  (LUT1_FILE_USED)             "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
  *     -53  (LUT2_BLZ_NOT_INITIALIZED)   "Das Feld BLZ wurde nicht initialisiert"
@@ -2086,34 +2697,75 @@ static VALUE bank_suche_pz(int argc,VALUE* argv,VALUE self)
  */
 static VALUE bank_suche_blz(int argc,VALUE* argv,VALUE self)
 {
-   char error_msg[512];
-   int i,j,retval,such1,such2,anzahl,*start_idx,*base_name,*zweigstelle,*blz_base;
-   VALUE ret_blz,ret_idx,ret_suche;
-
-   get_params_int(argc,argv,&such1,&such2);
-   retval=lut_suche_blz(such1,such2,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
-   if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
-   if(retval<0)RUNTIME_ERROR(retval);
-   ret_suche=rb_ary_new2(anzahl);
-   ret_blz=rb_ary_new2(anzahl);
-   ret_idx=rb_ary_new2(anzahl);
-   for(i=0;i<anzahl;i++){
-      j=start_idx[i];   /* Index innerhalb der BLZ-Datei */
-      rb_ary_store(ret_suche,i,INT2FIX(base_name[j]));
-      rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
-      rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
-   }
-   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
+   return bank_suche_int(argc,argv,self,NULL,lut_suche_blz);
 }
 
 /**
- * ===<tt>KontoCheckRaw::bank_suche_ort(suchort)</tt>
- * =====<tt>KontoCheck::suche()</tt>
+ * ===KontoCheckRaw::bank_suche_ort( suchort [,uniq])
+ * =====KontoCheck::suche()
  *
  * Diese Funktion sucht alle Banken, deren Sitz mit dem angegebenen Wert <suchort> beginnen.
  * Die Rückgabe ist ein Array mit fünf Elementen:
  *
- *    0. Das erste Element ist ein Array mit den gefundenen Orten
+ * * Das erste Element ist ein Array mit den gefundenen Orten
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
+ * * das vierte Element ist der Statuscode (s.u.)
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
+ *
+ * Mögliche Statuscodes:
+ *
+ *     -78  (KEY_NOT_FOUND)              "Die Suche lieferte kein Ergebnis"
+ *     -70  (LUT1_FILE_USED)             "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
+ *     -49  (LUT2_ORT_NOT_INITIALIZED)   "Das Feld Ort wurde nicht initialisiert"
+ *     -40  (LUT2_NOT_INITIALIZED)       "die Programmbibliothek wurde noch nicht initialisiert"
+ *      -9  (ERROR_MALLOC)               "kann keinen Speicher allokieren"
+ *       1  (OK)                         "ok"
+ */
+static VALUE bank_suche_ort(int argc,VALUE* argv,VALUE self)
+{
+   return bank_suche_int(argc,argv,self,lut_suche_ort,NULL);
+}
+
+/**
+ * === KontoCheckRaw::bank_suche_regel( regel1 [,regel2 [,sort_uniq [,sort]]])
+ * ===== KontoCheck::suche()
+ *
+ * Diese Funktion sucht alle Banken, deren IBAN-Regel gleich <regel1> ist oder
+ * (bei Angabe von regel2) die im Bereich zwischen <regel1> und <regel2>
+ * liegen. Die Rückgabe ist ein Array mit fünf Elementen:
+ *
+ * * Das erste Element ist ein Array mit den gefundenen Regeln
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
+ * * das vierte Element ist der Statuscode (s.u.)
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
+ *
+ * Mögliche Statuscodes:
+ *
+ *     -78  (KEY_NOT_FOUND)              "Die Suche lieferte kein Ergebnis"
+ *     -70  (LUT1_FILE_USED)             "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
+ *     -45  (LUT2_PZ_NOT_INITIALIZED)    "Das Feld Prüfziffer wurde nicht initialisiert"
+ *     -40  (LUT2_NOT_INITIALIZED)       "die Programmbibliothek wurde noch nicht initialisiert"
+ *      -9  (ERROR_MALLOC)               "kann keinen Speicher allokieren"
+ *       1  (OK)                         "ok"
+ */
+static VALUE bank_suche_regel(int argc,VALUE* argv,VALUE self)
+{
+   return bank_suche_int(argc,argv,self,NULL,lut_suche_regel);
+}
+
+/**
+ * ===KontoCheckRaw::bank_suche_volltext( suchwort [,sort_uniq [,sort]])
+ * =====KontoCheck::suche()
+ * 
+ * Diese Funktion sucht alle Banken, bei denen in Name, Kurzname oder Ort das
+ * angegebenen Wort <suchwort> vorkommt. Dabei wird immer nur ein einziges Wort
+ * gesucht; falls mehrere Worte angegeben werden, wird der Fehlerwert
+ * LUT2_VOLLTEXT_SINGLE_WORD_ONLY zurückgegeben. Die Rückgabe ist ein Array mit
+ * fünf Elementen:
+ *
+ *    0. Das erste Element ist ein Array mit den gefundenen Suchworten
  *    1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
  *    2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
  *    3. das vierte Element ist der Statuscode (s.u.)
@@ -2121,44 +2773,205 @@ static VALUE bank_suche_blz(int argc,VALUE* argv,VALUE self)
  *
  * Mögliche Statuscodes:
  *
- *    LUT1_FILE_USED             "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
- *    LUT2_NOT_INITIALIZED       "die Programmbibliothek wurde noch nicht initialisiert"
- *    LUT2_ORT_NOT_INITIALIZED   "Das Feld Ort wurde nicht initialisiert"
- *    ERROR_MALLOC               "kann keinen Speicher allokieren"
- *    KEY_NOT_FOUND              "Die Suche lieferte kein Ergebnis"
- *    OK                         "ok"
+ *    -118  (LUT2_VOLLTEXT_SINGLE_WORD_ONLY) "Die Volltextsuche sucht jeweils nur ein einzelnes Wort; benutzen Sie bank_suche_multiple() zur Suche nach mehreren Worten"
+ *    -114  (LUT2_VOLLTEXT_NOT_INITIALIZED)  "Das Feld Volltext wurde nicht initialisiert"
+ *     -78  (KEY_NOT_FOUND)              "Die Suche lieferte kein Ergebnis"
+ *     -70  (LUT1_FILE_USED)             "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
+ *     -40  (LUT2_NOT_INITIALIZED)       "die Programmbibliothek wurde noch nicht initialisiert"
+ *      -9  (ERROR_MALLOC)               "kann keinen Speicher allokieren"
+ *       1  (OK)                         "ok"
  */
-static VALUE bank_suche_ort(int argc,VALUE* argv,VALUE self)
+static VALUE bank_suche_volltext(int argc,VALUE* argv,VALUE self)
 {
-   char such_name[128],**base_name,error_msg[512];
-   int i,j,retval,anzahl,*start_idx,*zweigstelle,*blz_base;
+   char such_wort[128],**base_name,error_msg[512];
+   int i,j,k,retval,anzahl,anzahl2,last_blz,uniq,*start_idx,*zweigstelle,*blz_base,base_name_idx,zweigstellen_anzahl;
+   int *idx_o,*cnt_o;
    VALUE ret_blz,ret_idx,ret_suche;
 
-   get_params(argc,argv,such_name,NULL,NULL,NULL,3);
-   retval=lut_suche_ort(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
+   get_params(argc,argv,such_wort,NULL,NULL,&uniq,7);
+   retval=lut_suche_volltext(such_wort,&anzahl,&base_name_idx,&base_name,&zweigstellen_anzahl,&start_idx,&zweigstelle,&blz_base);
    if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
    if(retval<0)RUNTIME_ERROR(retval);
    ret_suche=rb_ary_new2(anzahl);
-   ret_blz=rb_ary_new2(anzahl);
-   ret_idx=rb_ary_new2(anzahl);
-   for(i=0;i<anzahl;i++){
-      j=start_idx[i];   /* Index innerhalb der BLZ-Datei */
+
+      /* base_name ist hier komplett unabhängig von den Bankleitzahlen; auch
+       * die Größe der beiden Arrays stimmt nicht überein!!! Daher müssen
+       * die gefundenen Volltexte in einer eigenen Schleife gespeichert werden.
+       */
+   for(i=0;i<anzahl;i++){  /* gefundene Volltexte zurückgeben */
+      j=base_name_idx+i;
       rb_ary_store(ret_suche,i,rb_str_new2(base_name[j]));
-      rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
-      rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
    }
-   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
+      /* die Anzahl der BLZs steht in der Variablen zweigstellen_anzahl */
+   if(uniq) /* bei uniq>0 sortieren, uniq>1 sortieren + uniq */
+      lut_suche_sort1(zweigstellen_anzahl,blz_base,zweigstelle,start_idx,&anzahl2,&idx_o,&cnt_o,uniq>1);
+   else{
+      anzahl2=zweigstellen_anzahl;
+      idx_o=start_idx;
+      cnt_o=NULL;
+   }
+   ret_blz=rb_ary_new2(anzahl2);
+   ret_idx=rb_ary_new2(anzahl2);
+   for(i=k=0,last_blz=-1;i<anzahl2;i++){
+      j=idx_o[i];   /* Index innerhalb der BLZ-Datei */
+      if(uniq>1 && blz_base[j]==last_blz)
+         continue;
+      else
+         last_blz=blz_base[j];
+      rb_ary_store(ret_blz,k,INT2FIX(blz_base[j]));
+      rb_ary_store(ret_idx,k++,INT2FIX(zweigstelle[j]));
+   }
+   if(uniq){
+      kc_free((char*)idx_o);
+      kc_free((char*)cnt_o);
+   }
+   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl2));
 }
 
 /**
- * ===<tt>KontoCheckRaw::version()</tt>
- * =====<tt>KontoCheck::version()</tt>
+ * ===KontoCheckRaw::bank_suche_multiple( suchtext [,such_cmd] [,uniq])
+ * =====KontoCheck::suche()
+ *
+ * Diese Funktion sucht alle Banken, die mehreren Kriterien entsprechen. Dabei
+ * können bis zu 26 Teilsuchen definiert werden, die beliebig miteinander
+ * verknüpft werden können (additiv, subtraktiv und multiplikativ).
+ *
+ * ====Aufruf:
+ * result=bank_suche_multiple(such_string [,such_cmd] [,uniq])
+ *
+ * ====Parameter:
+ * * such_string: Dieser Parameter gibt die Felder an, nach denen gesucht wird.
+ *   Er besteht aus einem oder mehreren Suchbefehlen, die jeweils folgenden
+ *   Aufbau haben: [such_index:]suchwert[@suchfeld]
+ *
+ *   Der (optionale) Suchindex ist ein Buchstabe von a-z, mit dem das Suchfeld
+ *   im Suchkommando (zweiter Parameter) referenziert werden kann. Falls er
+ *   nicht angegeben wird, erhält der erste Suchstring den Index a, der zweite
+ *   den Index b etc.
+ *
+ *   Der Suchwert ist der Wert nach dem gesucht werden soll. Für die Textfelder
+ *   ist es der Beginn des Wortes (aa passt z.B. auf Aach, Aachen, Aalen,
+ *   Aarbergen), für numerische Felder kann es eine Zahl oder ein Zahlbereich
+ *   in der Form 22-33 sein.
+ *
+ *   Das Suchfeld gibt an, nach welchem Feld der BLZ-Datei gesucht werden soll.
+ *   Falls das Suchfeld nicht angegeben wird, wird eine Volltextsuche (alle
+ *   Einzelworte in Name, Kurzname und Ort) gemacht. Die folgende Werte sind
+ *   möglich:
+ *
+ *    bl    BLZ
+ *    bi    BIC
+ *    k     Kurzname
+ *    n     Name
+ *    o     Ort
+ *    pl    PLZ
+ *    pr    Prüfziffer
+ *    pz    Prüfziffer
+ *    v     Volltext
+ *
+ *   In der obigen Tabelle der Suchfelder sind nur die
+ *   Kurzversionen angegeben; eine Angabe wie aa@ort oder
+ *   57000-58000@plz ist auch problemlos möglich.
+ *
+ * * such_cmd: Dieser Parameter gibt an, wie die Teilsuchen miteinander
+ *   verknüpft werden sollen. Der Ausdruck abc bedeutet, daß die BLZs in den
+ *   Teilsuchen a, b und c enthalten sein müssen; der Ausdruck a+b+c, daß sie
+ *   in mindestens einer Teilsuche enthalten sein muß; der Ausdruck a-b, daß
+ *   sie in a, aber nicht in b enthalten sein darf (Beispiel s.u.). Falls das
+ *   Suchkommando nicht angegeben wird, müssen die Ergebnis-BLZs in allen
+ *   Teilsuchen enthalten sein.
+ *
+ * * uniq: Falls dieser Parameter 0 ist, werden alle gefundenen Zweigstellen
+ *   ausgegeben; falls er 1 ist, wird für jede Bank nur eine Zweigstelle
+ *   ausgegeben. Die Ausgabe ist (anders als bei den anderen Suchroutinen,
+ *   bedingt durch die Arbeitsweise der Funktion) immer nach BLZ sortiert.
+ *   Falls der Parameter weggelassen wird, wird der Standardwert für uniq aus
+ *   konto_check.h benutzt.
+ *
+ * ====Beispiele:
+ * * ret=KontoCheckRaw::bank_suche_multiple( "b:55000000-55100000@blz o:67000-68000@plz sparkasse","bo")
+ *   Bei diesem Aufruf werden nur die beiden ersten Teilsuchen (nach BLZ und
+ *   PLZ) benutzt; die Suche findet alle Banken mit einer BLZ zwischen 55000000
+ *   und 55100000 im PLZ-Bereich 67000 bis 68000.
+ * * ret=KontoCheckRaw::bank_suche_multiple( "b:55000000-55030000@blz o:67000-68000@plz sparkasse","co")
+ *   Ähnlicher Aufruf wie oben, allerdings werden nur die beiden letzten Teilsuchen
+ *   berücksichtigt.
+ * * ret=KontoCheckRaw::bank_suche_multiple( "67000-68000@plz sparda",0)
+ *   Dieser Aufruf gibt alle Filialen der Sparda-Bank im PLZ-Bereich 67000 bis 68000
+ *   zurück.
+ * * ret=KontoCheckRaw::bank_suche_multiple( "skat")
+ *   Dieser Aufruf ist einfach eine Volltextsuche nach der Skat-Bank. Der
+ *   direkte Aufruf von bank_suche_volltext() ist intern natürlich wesentlich
+ *   leichtgewichtiger, aber die Suche so auch möglich.
+ *
+ * ====Rückgabe:
+ * Die Rückgabe ist ein Array mit fünf Elementen:
+ *
+ * * Das erste Element ist immer nil (nur für Kompatibilität mit den anderen Suchfunktionen)
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
+ * * das vierte Element ist der Statuscode (s.u.)
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
  *
- * Diese Funktion gibt den Versions-String der C-Bibliothek zurück.
+ *
+ * ====Mögliche Statuscodes:
+ * * -70  (LUT1_FILE_USED)             "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
+ * * -48  (LUT2_NAME_KURZ_NOT_INITIALIZED) "Das Feld Kurzname wurde nicht initialisiert"
+ * * -40  (LUT2_NOT_INITIALIZED)       "die Programmbibliothek wurde noch nicht initialisiert"
+ * * -9  (ERROR_MALLOC)               "kann keinen Speicher allokieren"
+ * *  1  (OK)                         "ok"
+ * * 14  (SOME_KEYS_NOT_FOUND)        "ok; ein(ige) Schlüssel wurden nicht gefunden"
+ */
+static VALUE bank_suche_multiple(int argc,VALUE* argv,VALUE self)
+{
+   char such_text[1280],such_cmd[256],error_msg[512];
+   int i,retval,uniq;
+   UINT4 *blz,*zweigstelle,anzahl;
+   VALUE ret_blz,ret_idx;
+
+   get_params(argc,argv,such_text,such_cmd,NULL,&uniq,6);
+   retval=lut_suche_multiple(such_text,uniq>1,such_cmd,&anzahl,&zweigstelle,&blz);
+   if(retval==KEY_NOT_FOUND || !anzahl)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
+   if(retval<0)RUNTIME_ERROR(retval);
+   ret_blz=rb_ary_new2(anzahl);
+   ret_idx=rb_ary_new2(anzahl);
+   for(i=0;i<(int)anzahl;i++){
+      rb_ary_store(ret_blz,i,INT2FIX(blz[i]));
+      rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[i]));
+   }
+   kc_free((char*)blz);
+   kc_free((char*)zweigstelle);
+   return rb_ary_new3(5,Qnil,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
+}
+
+
+/**
+ * ===KontoCheckRaw::version( [mode] )
+ * =====KontoCheck::version( [mode] )
+ *
+ * Diese Funktion gibt die Versions-Infos der C-Bibliothek zurück.
+ *
+ * ====Mögliche Werte für mode:
+ * * 0 bzw. ohne Parameter: Versionsstring der C-Bibliothek
+ * * 1: Versionsnummer
+ * * 2: Versionsdatum
+ * * 3: Compilerdatum und -zeit
+ * * 4: Datum der Prüfziffermethoden
+ * * 5: Datum der IBAN-Regeln
+ * * 6: Klartext-Datum der Bibliotheksversion
+ * * 7: Versionstyp (devel, beta, final)
  */
 static VALUE version_rb(int argc,VALUE* argv,VALUE self)
 {
-   return rb_str_new2(get_kto_check_version());
+   int level;
+   VALUE level_rb;
+
+   rb_scan_args(argc,argv,"01",&level_rb);
+   if(NIL_P(level_rb))
+      level=0;
+   else
+      level=NUM2INT(level_rb);
+   return rb_str_new2(get_kto_check_version_x(level));
 }
 
 /**
@@ -2168,18 +2981,23 @@ void Init_konto_check_raw()
 {
 /* 
  * This is a C/Ruby library to check the validity of German Bank Account
- * Numbers. All currently defined test methods by Deutsche Bundesbank (April
- * 2011: 00 to D8) are implemented. 
+ * Numbers. All currently defined test methods by Deutsche Bundesbank
+ * (March 2013: 00 to E0) are implemented. 
  * 
- * <b>ATTENTION:</b> There are a few important changes in the API between version 0.0.2 (version
- * by Peter Horn/Provideal), version 0.0.6 (jeanmartin) and this version:
+ * <b>ATTENTION:</b> There are a few important changes in the API between
+ * version 0.0.2 (version by Peter Horn/Provideal), version 0.0.6 (jeanmartin)
+ * and this version:
  * 
- * * The function KontoCheck::load_bank_data() is no longer used; it is replaced by KontoCheck::init() and KontoCheck::generate_lutfile().
- * * The function KontoCheck::konto_check(blz,kto) changed the order of parameters from (kto,blz) to (blz,kto)
+ * * The function KontoCheck::load_bank_data() is no longer used; it is
+ *   replaced by KontoCheck::init() and KontoCheck::generate_lutfile().
+ * * The function KontoCheck::konto_check( blz,kto) changed the order of
+ *   parameters from (kto,blz) to (blz,kto)
  * 
  * Another change affects only the version 0.0.6 by jeanmartin:
  * 
- * * In KontoCheck::init(level,name,set) the order of the two first parameters is now free; the order is determined by the type of the variable (level is integer, filename string). 
+ * * In KontoCheck::init( level,name,set) the order of the two first parameters
+ *   is now free; the order is determined by the type of the variable (level is
+ *   integer, filename string). 
  * 
  * Because this class is inteded for german bank accounts, the rest of the
  * documentation is in german too.
@@ -2258,6 +3076,8 @@ void Init_konto_check_raw()
    rb_define_module_function(KontoCheck,"free",free_rb,0);
    rb_define_module_function(KontoCheck,"konto_check",konto_check,-1);
    rb_define_module_function(KontoCheck,"konto_check_pz",konto_check_pz,-1);
+   rb_define_module_function(KontoCheck,"konto_check_regel",konto_check_regel,-1);
+   rb_define_module_function(KontoCheck,"konto_check_regel_dbg",konto_check_regel_dbg,-1);
    rb_define_module_function(KontoCheck,"bank_valid",bank_valid,-1);
    rb_define_module_function(KontoCheck,"bank_filialen",bank_filialen,-1);
    rb_define_module_function(KontoCheck,"bank_alles",bank_alles,-1);
@@ -2273,6 +3093,8 @@ void Init_konto_check_raw()
    rb_define_module_function(KontoCheck,"bank_loeschung",bank_loeschung,-1);
    rb_define_module_function(KontoCheck,"bank_nachfolge_blz",bank_nachfolge_blz,-1);
    rb_define_module_function(KontoCheck,"dump_lutfile",dump_lutfile_rb,-1);
+   rb_define_module_function(KontoCheck,"lut_blocks",lut_blocks_rb,-1);
+   rb_define_module_function(KontoCheck,"lut_blocks1",lut_blocks1_rb,-1);
    rb_define_module_function(KontoCheck,"lut_info",lut_info_rb,-1);
    rb_define_module_function(KontoCheck,"keep_raw_data",keep_raw_data_rb,1);
    rb_define_module_function(KontoCheck,"encoding",encoding_rb,-1);
@@ -2284,6 +3106,7 @@ void Init_konto_check_raw()
    rb_define_module_function(KontoCheck,"retval2html",retval2html_rb,1);
    rb_define_module_function(KontoCheck,"retval2utf8",retval2utf8_rb,1);
    rb_define_module_function(KontoCheck,"generate_lutfile",generate_lutfile_rb,-1);
+   rb_define_module_function(KontoCheck,"ci_check",ci_check_rb,1);
    rb_define_module_function(KontoCheck,"iban_check",iban_check_rb,-1);
    rb_define_module_function(KontoCheck,"iban2bic",iban2bic_rb,-1);
    rb_define_module_function(KontoCheck,"iban_gen",iban_gen_rb,-1);
@@ -2296,18 +3119,85 @@ void Init_konto_check_raw()
    rb_define_module_function(KontoCheck,"bank_suche_blz",bank_suche_blz,-1);
    rb_define_module_function(KontoCheck,"bank_suche_plz",bank_suche_plz,-1);
    rb_define_module_function(KontoCheck,"bank_suche_pz",bank_suche_pz,-1);
-   rb_define_module_function(KontoCheck,"version",version_rb,0);
+   rb_define_module_function(KontoCheck,"bank_suche_regel",bank_suche_regel,-1);
+   rb_define_module_function(KontoCheck,"bank_suche_volltext",bank_suche_volltext,-1);
+   rb_define_module_function(KontoCheck,"bank_suche_multiple",bank_suche_multiple,-1);
+   rb_define_module_function(KontoCheck,"version",version_rb,-1);
    rb_define_module_function(KontoCheck,"load_bank_data",load_bank_data,1);
 
       /* Rückgabewerte der konto_check Bibliothek */
+      /* (-145) Es werden nur deutsche BICs unterstützt */
+   rb_define_const(KontoCheck,"BIC_ONLY_GERMAN",INT2FIX(BIC_ONLY_GERMAN));
+      /* (-144) Die Länge des BIC muß genau 8 oder 11 Zeichen sein */
+   rb_define_const(KontoCheck,"INVALID_BIC_LENGTH",INT2FIX(INVALID_BIC_LENGTH));
+      /* (-143) Die IBAN-Prüfsumme stimmt, es wurde allerdings eine IBAN-Regel nicht beachtet (BLZ nicht ersetzt, wahrscheinlich falsch) */
+   rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_RULE_IGNORED_BLZ",INT2FIX(IBAN_CHKSUM_OK_RULE_IGNORED_BLZ));
+      /* (-142) Die IBAN-Prüfsumme stimmt, konto_check wurde jedoch noch nicht initialisiert (Kontoprüfung nicht möglich) */
+   rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_KC_NOT_INITIALIZED",INT2FIX(IBAN_CHKSUM_OK_KC_NOT_INITIALIZED));
+      /* (-141) Die IBAN-Prüfsumme stimmt, die BLZ ist allerdings ungültig */
+   rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_BLZ_INVALID",INT2FIX(IBAN_CHKSUM_OK_BLZ_INVALID));
+      /* (-140) Die IBAN-Prüfsumme stimmt, für die Bank gibt es allerdings eine (andere) Nachfolge-BLZ */
+   rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_NACHFOLGE_BLZ_DEFINED",INT2FIX(IBAN_CHKSUM_OK_NACHFOLGE_BLZ_DEFINED));
+      /* (-139) es konnten nicht alle Datenblocks die für die IBAN-Berechnung notwendig sind geladen werden */
+   rb_define_const(KontoCheck,"LUT2_NOT_ALL_IBAN_BLOCKS_LOADED",INT2FIX(LUT2_NOT_ALL_IBAN_BLOCKS_LOADED));
+      /* (-138) Der Datensatz ist noch nicht gültig, außerdem konnten nicht alle Blocks geladen werden */
+   rb_define_const(KontoCheck,"LUT2_NOT_YET_VALID_PARTIAL_OK",INT2FIX(LUT2_NOT_YET_VALID_PARTIAL_OK));
+      /* (-137) Der Datensatz ist nicht mehr gültig, außerdem konnten nicht alle Blocks geladen werdeng */
+   rb_define_const(KontoCheck,"LUT2_NO_LONGER_VALID_PARTIAL_OK",INT2FIX(LUT2_NO_LONGER_VALID_PARTIAL_OK));
+      /* (-136) ok, bei der Initialisierung konnten allerdings ein oder mehrere Blocks nicht geladen werden */
+   rb_define_const(KontoCheck,"LUT2_BLOCKS_MISSING",INT2FIX(LUT2_BLOCKS_MISSING));
+      /* (-135) falsch, es wurde ein Unterkonto hinzugefügt (IBAN-Regel) */
+   rb_define_const(KontoCheck,"FALSE_UNTERKONTO_ATTACHED",INT2FIX(FALSE_UNTERKONTO_ATTACHED));
+      /* (-134) Die BLZ findet sich in der Ausschlussliste für IBAN-Berechnungen */
+   rb_define_const(KontoCheck,"BLZ_BLACKLISTED",INT2FIX(BLZ_BLACKLISTED));
+      /* (-133) Die BLZ ist in der Bundesbank-Datei als gelöscht markiert und somit ungültig */
+   rb_define_const(KontoCheck,"BLZ_MARKED_AS_DELETED",INT2FIX(BLZ_MARKED_AS_DELETED));
+      /* (-132) Die IBAN-Prüfsumme stimmt, es gibt allerdings einen Fehler in der eigenen IBAN-Bestimmung (wahrscheinlich falsch) */
+   rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_SOMETHING_WRONG",INT2FIX(IBAN_CHKSUM_OK_SOMETHING_WRONG));
+      /* (-131) Die IBAN-Prüfsumme stimmt, eine IBAN-Berechnung ist allerdings nicht erlaubt (wahrscheinlich falsch) */
+   rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_NO_IBAN_CALCULATION",INT2FIX(IBAN_CHKSUM_OK_NO_IBAN_CALCULATION));
+      /* (-130) Die IBAN-Prüfsumme stimmt, es wurde allerdings eine IBAN-Regel nicht beachtet (wahrscheinlich falsch) */
+   rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_RULE_IGNORED",INT2FIX(IBAN_CHKSUM_OK_RULE_IGNORED));
+      /* (-129) Die IBAN-Prüfsumme stimmt, es fehlt aber ein Unterkonto (wahrscheinlich falsch) */
+   rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_UNTERKTO_MISSING",INT2FIX(IBAN_CHKSUM_OK_UNTERKTO_MISSING));
+      /* (-128) Die BLZ passt nicht zur angegebenen IBAN-Regel */
+   rb_define_const(KontoCheck,"IBAN_INVALID_RULE",INT2FIX(IBAN_INVALID_RULE));
+      /* (-127) Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten) */
+   rb_define_const(KontoCheck,"IBAN_AMBIGUOUS_KTO",INT2FIX(IBAN_AMBIGUOUS_KTO));
+      /* (-126) Die IBAN-Regel ist noch nicht implementiert */
+   rb_define_const(KontoCheck,"IBAN_RULE_NOT_IMPLEMENTED",INT2FIX(IBAN_RULE_NOT_IMPLEMENTED));
+      /* (-125) Die IBAN-Regel ist nicht bekannt */
+   rb_define_const(KontoCheck,"IBAN_RULE_UNKNOWN",INT2FIX(IBAN_RULE_UNKNOWN));
+      /* (-124) Für die Bankverbindung ist keine IBAN-Berechnung erlaubt */
+   rb_define_const(KontoCheck,"NO_IBAN_CALCULATION",INT2FIX(NO_IBAN_CALCULATION));
+      /* (-123) Die Bankverbindung ist mit der alten BLZ stimmig, mit der Nachfolge-BLZ nicht */
+   rb_define_const(KontoCheck,"OLD_BLZ_OK_NEW_NOT",INT2FIX(OLD_BLZ_OK_NEW_NOT));
+      /* (-122) Das Feld IBAN-Regel wurde nicht initialisiert */
+   rb_define_const(KontoCheck,"LUT2_IBAN_REGEL_NOT_INITIALIZED",INT2FIX(LUT2_IBAN_REGEL_NOT_INITIALIZED));
+      /* (-121) Die Länge der IBAN für das angegebene Länderkürzel ist falsch */
+   rb_define_const(KontoCheck,"INVALID_IBAN_LENGTH",INT2FIX(INVALID_IBAN_LENGTH));
+      /* (-120) Keine Bankverbindung/IBAN angegeben */
+   rb_define_const(KontoCheck,"LUT2_NO_ACCOUNT_GIVEN",INT2FIX(LUT2_NO_ACCOUNT_GIVEN));
+      /* (-119) Ungültiges Zeichen ( ()+-/&.,\' ) für die Volltextsuche gefunden */
+   rb_define_const(KontoCheck,"LUT2_VOLLTEXT_INVALID_CHAR",INT2FIX(LUT2_VOLLTEXT_INVALID_CHAR));
+      /* (-118) Die Volltextsuche sucht jeweils nur ein einzelnes Wort, benutzen Sie lut_suche_multiple() zur Suche nach mehreren Worten */
+   rb_define_const(KontoCheck,"LUT2_VOLLTEXT_SINGLE_WORD_ONLY",INT2FIX(LUT2_VOLLTEXT_SINGLE_WORD_ONLY));
+      /* (-117) die angegebene Suchresource ist ungültig */
+   rb_define_const(KontoCheck,"LUT_SUCHE_INVALID_RSC",INT2FIX(LUT_SUCHE_INVALID_RSC));
+      /* (-116) Suche: im Verknüpfungsstring sind nur die Zeichen a-z sowie + und - erlaubt */
+   rb_define_const(KontoCheck,"LUT_SUCHE_INVALID_CMD",INT2FIX(LUT_SUCHE_INVALID_CMD));
+      /* (-115) Suche: es müssen zwischen 1 und 26 Suchmuster angegeben werden */
+   rb_define_const(KontoCheck,"LUT_SUCHE_INVALID_CNT",INT2FIX(LUT_SUCHE_INVALID_CNT));
+      /* (-114) Das Feld Volltext wurde nicht initialisiert */
+   rb_define_const(KontoCheck,"LUT2_VOLLTEXT_NOT_INITIALIZED",INT2FIX(LUT2_VOLLTEXT_NOT_INITIALIZED));
       /* (-113) das Institut erlaubt keine eigene IBAN-Berechnung */
    rb_define_const(KontoCheck,"NO_OWN_IBAN_CALCULATION",INT2FIX(NO_OWN_IBAN_CALCULATION));
       /* (-112) die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden */
    rb_define_const(KontoCheck,"KTO_CHECK_UNSUPPORTED_COMPRESSION",INT2FIX(KTO_CHECK_UNSUPPORTED_COMPRESSION));
       /* (-111) der angegebene Wert für die Default-Kompression ist ungültig */
    rb_define_const(KontoCheck,"KTO_CHECK_INVALID_COMPRESSION_LIB",INT2FIX(KTO_CHECK_INVALID_COMPRESSION_LIB));
-      /* (-110) wahrscheinlich OK; es wurde allerdings ein (weggelassenes) Unterkonto angefügt */
-   rb_define_const(KontoCheck,"OK_UNTERKONTO_ATTACHED",INT2FIX(OK_UNTERKONTO_ATTACHED));
+      /* (-110) (nicht mehr als Fehler, sondern positive Ausgabe - Dummy für den alten Wert) */
+   rb_define_const(KontoCheck,"OK_UNTERKONTO_ATTACHED_OLD",INT2FIX(OK_UNTERKONTO_ATTACHED_OLD));
       /* (-109) Ungültige Signatur im Default-Block */
    rb_define_const(KontoCheck,"KTO_CHECK_DEFAULT_BLOCK_INVALID",INT2FIX(KTO_CHECK_DEFAULT_BLOCK_INVALID));
       /* (-108) Die maximale Anzahl Einträge für den Default-Block wurde erreicht */
@@ -2316,7 +3206,7 @@ void Init_konto_check_raw()
    rb_define_const(KontoCheck,"KTO_CHECK_NO_DEFAULT_BLOCK",INT2FIX(KTO_CHECK_NO_DEFAULT_BLOCK));
       /* (-106) Der angegebene Schlüssel wurde im Default-Block nicht gefunden */
    rb_define_const(KontoCheck,"KTO_CHECK_KEY_NOT_FOUND",INT2FIX(KTO_CHECK_KEY_NOT_FOUND));
-      /* (-105) Beide Datensätze sind nicht mehr gültig; dieser ist  aber jünger als der andere */
+      /* (-105) Beide Datensätze sind nicht mehr gültig, dieser ist aber jünger als der andere */
    rb_define_const(KontoCheck,"LUT2_NO_LONGER_VALID_BETTER",INT2FIX(LUT2_NO_LONGER_VALID_BETTER));
       /* (-104) Die Auftraggeber-Kontonummer des C-Datensatzes unterscheidet sich von der des A-Satzes */
    rb_define_const(KontoCheck,"DTA_SRC_KTO_DIFFERENT",INT2FIX(DTA_SRC_KTO_DIFFERENT));
@@ -2388,7 +3278,7 @@ void Init_konto_check_raw()
    rb_define_const(KontoCheck,"IPI_INVALID_LENGTH",INT2FIX(IPI_INVALID_LENGTH));
       /* (-70) Es wurde eine LUT-Datei im Format 1.0/1.1 geladen */
    rb_define_const(KontoCheck,"LUT1_FILE_USED",INT2FIX(LUT1_FILE_USED));
-      /* (-69) Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto) */
+      /* (-69) Für die aufgerufene Funktion fehlt ein notwendiger Parameter */
    rb_define_const(KontoCheck,"MISSING_PARAMETER",INT2FIX(MISSING_PARAMETER));
       /* (-68) Die Funktion iban2bic() arbeitet nur mit deutschen Bankleitzahlen */
    rb_define_const(KontoCheck,"IBAN2BIC_ONLY_GERMAN",INT2FIX(IBAN2BIC_ONLY_GERMAN));
@@ -2498,7 +3388,7 @@ void Init_konto_check_raw()
    rb_define_const(KontoCheck,"BLZ_GELOESCHT",INT2FIX(BLZ_GELOESCHT));
       /* (-15) Fehler in der blz.txt Datei (falsche Zeilenlänge) */
    rb_define_const(KontoCheck,"INVALID_BLZ_FILE",INT2FIX(INVALID_BLZ_FILE));
-      /* (-14) undefinierte Funktion; die library wurde mit THREAD_SAFE=0 kompiliert */
+      /* (-14) undefinierte Funktion, die library wurde mit THREAD_SAFE=0 kompiliert */
    rb_define_const(KontoCheck,"LIBRARY_IS_NOT_THREAD_SAFE",INT2FIX(LIBRARY_IS_NOT_THREAD_SAFE));
       /* (-13) schwerer Fehler im Konto_check-Modul */
    rb_define_const(KontoCheck,"FATAL_ERROR",INT2FIX(FATAL_ERROR));
@@ -2532,7 +3422,7 @@ void Init_konto_check_raw()
    rb_define_const(KontoCheck,"OK",INT2FIX(OK));
       /* (2) ok, ohne Prüfung */
    rb_define_const(KontoCheck,"OK_NO_CHK",INT2FIX(OK_NO_CHK));
-      /* (3) ok; für den Test wurde eine Test-BLZ verwendet */
+      /* (3) ok, für den Test wurde eine Test-BLZ verwendet */
    rb_define_const(KontoCheck,"OK_TEST_BLZ_USED",INT2FIX(OK_TEST_BLZ_USED));
       /* (4) Der Datensatz ist aktuell gültig */
    rb_define_const(KontoCheck,"LUT2_VALID",INT2FIX(LUT2_VALID));
@@ -2540,18 +3430,42 @@ void Init_konto_check_raw()
    rb_define_const(KontoCheck,"LUT2_NO_VALID_DATE",INT2FIX(LUT2_NO_VALID_DATE));
       /* (6) Die Datei ist im alten LUT-Format (1.0/1.1) */
    rb_define_const(KontoCheck,"LUT1_SET_LOADED",INT2FIX(LUT1_SET_LOADED));
-      /* (7) ok; es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert */
+      /* (7) ok, es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert */
    rb_define_const(KontoCheck,"LUT1_FILE_GENERATED",INT2FIX(LUT1_FILE_GENERATED));
       /* (8) In der DTAUS-Datei wurden kleinere Fehler gefunden */
    rb_define_const(KontoCheck,"DTA_FILE_WITH_WARNINGS",INT2FIX(DTA_FILE_WITH_WARNINGS));
-      /* (9) ok; es wurde allerdings eine LUT-Datei im Format 2.0 generiert (Compilerswitch) */
+      /* (9) ok, es wurde allerdings eine LUT-Datei im Format 2.0 generiert (Compilerswitch) */
    rb_define_const(KontoCheck,"LUT_V2_FILE_GENERATED",INT2FIX(LUT_V2_FILE_GENERATED));
-      /* (10) ok; der Wert für den Schlüssel wurde überschrieben */
+      /* (10) ok, der Wert für den Schlüssel wurde überschrieben */
    rb_define_const(KontoCheck,"KTO_CHECK_VALUE_REPLACED",INT2FIX(KTO_CHECK_VALUE_REPLACED));
-      /* (11) wahrscheinlich ok; die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten */
+      /* (11) wahrscheinlich ok, die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten */
    rb_define_const(KontoCheck,"OK_UNTERKONTO_POSSIBLE",INT2FIX(OK_UNTERKONTO_POSSIBLE));
-      /* (12) wahrscheinlich ok; die Kontonummer enthält eine Unterkontonummer */
+      /* (12) wahrscheinlich ok, die Kontonummer enthält eine Unterkontonummer */
    rb_define_const(KontoCheck,"OK_UNTERKONTO_GIVEN",INT2FIX(OK_UNTERKONTO_GIVEN));
-      /* (13) ok; die Anzahl Slots wurde auf SLOT_CNT_MIN hochgesetzt */
+      /* (13) ok, die Anzahl Slots wurde auf SLOT_CNT_MIN (60) hochgesetzt */
    rb_define_const(KontoCheck,"OK_SLOT_CNT_MIN_USED",INT2FIX(OK_SLOT_CNT_MIN_USED));
+      /* (14) ok, ein(ige) Schlüssel wurden nicht gefunden */
+   rb_define_const(KontoCheck,"SOME_KEYS_NOT_FOUND",INT2FIX(SOME_KEYS_NOT_FOUND));
+      /* (15) Die Bankverbindung wurde nicht getestet */
+   rb_define_const(KontoCheck,"LUT2_KTO_NOT_CHECKED",INT2FIX(LUT2_KTO_NOT_CHECKED));
+      /* (16) Es wurden fast alle Blocks (außer den IBAN-Regeln) geladen */
+   rb_define_const(KontoCheck,"LUT2_OK_WITHOUT_IBAN_RULES",INT2FIX(LUT2_OK_WITHOUT_IBAN_RULES));
+      /* (17) ok, für die BLZ wurde allerdings die Nachfolge-BLZ eingesetzt */
+   rb_define_const(KontoCheck,"OK_NACHFOLGE_BLZ_USED",INT2FIX(OK_NACHFOLGE_BLZ_USED));
+      /* (18) ok, die Kontonummer wurde allerdings ersetzt */
+   rb_define_const(KontoCheck,"OK_KTO_REPLACED",INT2FIX(OK_KTO_REPLACED));
+      /* (19) ok, die Bankleitzahl wurde allerdings ersetzt */
+   rb_define_const(KontoCheck,"OK_BLZ_REPLACED",INT2FIX(OK_BLZ_REPLACED));
+      /* (20) ok, die Bankleitzahl und Kontonummer wurde allerdings ersetzt */
+   rb_define_const(KontoCheck,"OK_BLZ_KTO_REPLACED",INT2FIX(OK_BLZ_KTO_REPLACED));
+      /* (21) ok, die Bankverbindung ist (ohne Test) als richtig anzusehen */
+   rb_define_const(KontoCheck,"OK_IBAN_WITHOUT_KC_TEST",INT2FIX(OK_IBAN_WITHOUT_KC_TEST));
+      /* (22) ok, für IBAN ist (durch eine Regel) allerdings ein anderer BIC definiert */
+   rb_define_const(KontoCheck,"OK_INVALID_FOR_IBAN",INT2FIX(OK_INVALID_FOR_IBAN));
+      /* (23) ok, für die BIC-Bestimmung der ehemaligen Hypo-Bank für IBAN wird i.A. zusätzlich die Kontonummer benötigt */
+   rb_define_const(KontoCheck,"OK_HYPO_REQUIRES_KTO",INT2FIX(OK_HYPO_REQUIRES_KTO));
+      /* (24) ok, die Kontonummer wurde ersetzt, die neue Kontonummer hat keine Prüfziffer */
+   rb_define_const(KontoCheck,"OK_KTO_REPLACED_NO_PZ",INT2FIX(OK_KTO_REPLACED_NO_PZ));
+      /* (25) ok, es wurde ein (weggelassenes) Unterkonto angefügt */
+   rb_define_const(KontoCheck,"OK_UNTERKONTO_ATTACHED",INT2FIX(OK_UNTERKONTO_ATTACHED));
 }