konto_check 5.8.0 → 5.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 053b8ec3c8f061abf51dda3b7a61869f45240975
+  data.tar.gz: c07b4ce5d8d9da73d093069c657fcebdd7f8b799
+SHA512:
+  metadata.gz: 6b50d6fa5e45d49234decd9cbe6cd6d3773d7d7f9991450519ab5e7a5c9f4df0e0effdf90882ba67527d9233d14a60d00d94a6f33f792a20c62dfc57381bbcc8
+  data.tar.gz: 494a525b1b2416f5b978d77c555371c5578dc5ae7716869b2ce559db65bdd8e77f79b97e040cab32a2a433edaa5f3d0bd64be4379d9c241114cf0deac1167e68

data/ext/konto_check_raw/konto_check.c

@@ -13,7 +13,7 @@
  * #  wurden aus der aktuellen BLZ-Datei der Deutschen Bundesbank           #
  * #  �bernommen.                                                           #
  * #                                                                        #
- * #  Copyright (C) 2002-2015 Michael Plugge <m.plugge@hs-mannheim.de>      #
+ * #  Copyright (C) 2002-2017 Michael Plugge <m.plugge@hs-mannheim.de>      #
  * #                                                                        #
  * #  Dieses Programm ist freie Software; Sie d�rfen es unter den           #
  * #  Bedingungen der GNU Lesser General Public License, wie von der Free   #
@@ -45,15 +45,15 @@
  * # im Internet herunterladen.                                             #
  * ##########################################################################
  */
-#line 332 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 332 "konto_check.lxx"
 
 /* Definitionen und Includes  */
 #ifndef VERSION
-#define VERSION "5.8 (final)"
+#define VERSION "5.10 (final)"
 #define VERSION_MAJOR 5
-#define VERSION_MINOR 8
+#define VERSION_MINOR 10
 #endif
-#define VERSION_DATE "2015-08-22"
+#define VERSION_DATE "2017-03-10"
 
 #ifndef INCLUDE_KONTO_CHECK_DE
 #define INCLUDE_KONTO_CHECK_DE 1
@@ -104,8 +104,8 @@ static lzo_align_t __LZO_MMODEL wrkmem[LZO1X_1_MEM_COMPRESS];
 #define KONTO_CHECK_VARS
 #include "konto_check.h"
 
-   /* Flag, um die �nderungen zum September 2015 zu aktivieren */
-static int pz_aenderungen_aktivieren_2015_09;
+   /* Flag, um die �nderungen zum M�rz 2017 zu aktivieren */
+static int pz_aenderungen_aktivieren_2017_03;
 
    /* falls die Variable verbose_debug gesetzt wird, werden bei einigen
     * Funktionen mittels perror() zus�tzliche Debuginfos ausgegeben. Die
@@ -242,7 +242,7 @@ static int convert_encoding(char **data,UINT4 *len);
 #define free(ptr) efree(ptr)
 #endif
 
-#line 770 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 770 "konto_check.lxx"
 
    /* Testwert zur Markierung ung�ltiger Ziffern im BLZ-String (>8 Stellen) */
 #define BLZ_FEHLER 100000000
@@ -378,7 +378,7 @@ static int convert_encoding(char **data,UINT4 *len);
     */
 #define CHECK_RETVAL(fkt) do{if((retval=fkt)!=OK)goto fini;}while(0)     /* es mu� noch aufger�umt werden, daher goto */
 #define CHECK_RETURN(fkt) do{if((retval=fkt)!=OK)return retval;}while(0)
-#line 911 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 911 "konto_check.lxx"
 
    /* einige Makros zur Umwandlung zwischen unsigned int und char */
 #define UCP  (unsigned char*)
@@ -498,7 +498,7 @@ int pz=-777;
 
 #define E_START(x)
 #define E_END(x)
-#line 1036 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 1036 "konto_check.lxx"
 
    /* Variable f�r die Methoden 27, 29 und 69 */
 static const int m10h_digits[4][10]={
@@ -947,7 +947,7 @@ static int create_lutfile_int(char *name, char *prolog, int slots,FILE **lut)
  * ###########################################################################
  */
 
-#line 1485 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 1485 "konto_check.lxx"
 DLL_EXPORT int write_lut_block(char *lutname,UINT4 typ,UINT4 len,char *data)
 {
    char buffer[SLOT_BUFFER],*ptr;
@@ -985,7 +985,7 @@ DLL_EXPORT int write_lut_block(char *lutname,UINT4 typ,UINT4 len,char *data)
  * #############################################################################
  */
 
-#line 1523 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 1523 "konto_check.lxx"
 static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data)
 {
    char buffer[SLOT_BUFFER],*ptr,*cptr;
@@ -1121,7 +1121,7 @@ static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data)
  * ###########################################################################
  */
 
-#line 1659 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 1659 "konto_check.lxx"
 DLL_EXPORT int read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **data)
 {
    int retval;
@@ -1144,7 +1144,7 @@ DLL_EXPORT int read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **da
  * ###########################################################################
  */
 
-#line 1683 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 1683 "konto_check.lxx"
 DLL_EXPORT int read_lut_slot(char *lutname,int slot,UINT4 *blocklen,char **data)
 {
    int retval;
@@ -1166,7 +1166,7 @@ DLL_EXPORT int read_lut_slot(char *lutname,int slot,UINT4 *blocklen,char **data)
  * ###########################################################################
  */
 
-#line 1706 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 1706 "konto_check.lxx"
 static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **data)
 {
    char buffer[SLOT_BUFFER],*ptr,*sbuffer,*dbuffer;
@@ -1256,7 +1256,7 @@ static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **
             FREE(sbuffer);
             RETURN(ERROR_MALLOC);
          }
-#line 1811 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 1811 "konto_check.lxx"
 
          if(fread(sbuffer,1,compressed_len,lut)<compressed_len){
             FREE(sbuffer);
@@ -2849,7 +2849,7 @@ DLL_EXPORT int lut_info_id(char *lut_name,int *info1,int *info2,int *valid1,int
  * ###########################################################################
  */
 
-#line 3404 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 3404 "konto_check.lxx"
 DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int *valid2)
 {
    char *ptr,*ptr1,buffer[128];
@@ -2937,7 +2937,7 @@ DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int
 
       /* Infoblocks lesen: 1. Infoblock */
    if((ret=read_lut_block_int(in,0,LUT2_INFO,&cnt,&ptr))==OK){
-#line 3493 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 3493 "konto_check.lxx"
       *(ptr+cnt)=0;
       if(valid1){
          for(ptr1=ptr,v1=v2=0;*ptr1 && *ptr1!='\n' && !isdigit(*ptr1);ptr1++);
@@ -2985,7 +2985,7 @@ DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int
 
       /* Infoblocks lesen: 2. Infoblock */
    if((ret=read_lut_block_int(in,0,LUT2_2_INFO,&cnt,&ptr))==OK){
-#line 3542 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 3542 "konto_check.lxx"
       *(ptr+cnt)=0;
       if(valid2){
          for(ptr1=ptr,v1=v2=0;*ptr1 && *ptr1!='\n' && !isdigit(*ptr1);ptr1++);
@@ -3204,7 +3204,7 @@ DLL_EXPORT int copy_lutfile(char *old_name,char *new_name,int new_slots)
    qsort(slotdir,slot_cnt,sizeof(int),cmp_int);
    for(last_slot=-1,i=0;i<(int)slot_cnt;i++)if((typ=slotdir[i]) && typ!=(UINT4)last_slot){
       read_lut_block_int(lut1,0,typ,&len,&data);
-#line 3762 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 3762 "konto_check.lxx"
       write_lut_block_int(lut2,typ,len,data);
       FREE(data);
       last_slot=typ;
@@ -3434,7 +3434,7 @@ DLL_EXPORT int lut_init(char *lut_name,int required,int set)
  * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
  * ###########################################################################
  */
-#line 3992 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 3992 "konto_check.lxx"
 DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,int incremental)
 {
    char *ptr,*dptr,*data,*eptr,*prolog,*info,*user_info,*hs=NULL,*info1,*info2,*ci=NULL,name_buffer[LUT_PATH_LEN];
@@ -3662,7 +3662,7 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
          typ1=typ;
       if(lut2_block_status[typ]==OK)continue;   /* jeden Block nur einmal einlesen */
       retval=read_lut_block_int(lut,0,typ,&len,&data);
-#line 4221 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 4221 "konto_check.lxx"
 
       switch(retval){
          case LUT_CRC_ERROR:
@@ -3750,7 +3750,7 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
             if(typ==LUT2_2_NAME || typ==LUT2_2_NAME_KURZ){
                FREE(data);
                i=read_lut_block_int(lut,0,LUT2_2_NAME_NAME_KURZ,&len,&data);
-#line 4313 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 4313 "konto_check.lxx"
                if(i==OK){  /* was gefunden; Typ �ndern, dann weiter wie bei OK */
                   typ=LUT2_2_NAME_NAME_KURZ;
                   typ1=LUT2_NAME_NAME_KURZ;
@@ -3818,7 +3818,7 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
             if(!(blz=(int *)calloc(lut2_cnt_hs+1,sizeof(int)))
                   || (!startidx && !(startidx=(int *)calloc(lut2_cnt_hs,sizeof(int))))  /* Index der Hauptstelle in den gro�en Arrays */
                   || (!hs_idx && !(hs_idx=(int *)calloc(lut2_cnt,sizeof(int))))   /* reziprok zu startidx */
-                  || !(hash=(short int *)calloc(sizeof(short),HASH_BUFFER_SIZE)))
+                  || !(hash=(short int *)calloc(HASH_BUFFER_SIZE,sizeof(short))))
                lut2_block_status[typ]=lut2_block_status[typ1]=ERROR_MALLOC;
             else{
                for(i=0,eptr=data+len;ptr<eptr && i<lut2_cnt_hs;i++){
@@ -4346,7 +4346,7 @@ DLL_EXPORT int lut_blocks_id(int mode,int *lut_filename,int *lut_blocks_ok,int *
  * ###########################################################################
  */
 
-#line 4909 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 4909 "konto_check.lxx"
 DLL_EXPORT const char *current_lutfile_name(int *set,int *level,int *retval)
 {
    if(init_status<7 || !current_lutfile){
@@ -5100,7 +5100,7 @@ static int iban_init(void)
  * ###########################################################################
  */
 
-#line 5663 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 5663 "konto_check.lxx"
 static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_version,RETVAL *retvals)
 {
    char tmp_buffer[16];
@@ -8067,8 +8067,16 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
          /* Deutsche Bundesbank */
       case 42:
 
-            /* nur 8-stellige Konten sind zur IBAN-Berechnung freigegeben */
-         if(*kto!='0' || kto[1]!='0')return NO_IBAN_CALCULATION;
+            /* ab Dezember 2016 sind auch 10-stellige Konten der Form nnn4400001 bis nnn4499999 zul�ssig */
+         if(k1>=10){ /* 10-stellige Kontonummern ab Dezember 2016 */
+            if(kto[3]=='4' && kto[4]=='4' && (kto[5]!='0' || kto[6]!='0' ||  kto[7]!='0' || kto[8]!='0' || kto[9]!='0'))
+               return OK;
+            else
+               return NO_IBAN_CALCULATION;
+         }
+
+            /* ansonsten sind nur noch 8-stellige Konten freigegeben */
+         if(k1!=0 || k2<10000000)return NO_IBAN_CALCULATION;
 
             /* Konten ohne IBAN-Berechnung:  nnn 0 0000 bis nnn 0 0999 */
          if(kto[5]=='0' && kto[6]=='0')return NO_IBAN_CALCULATION;
@@ -8777,7 +8785,7 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
    }
 }
 
-#line 9340 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 9348 "konto_check.lxx"
 /* Funktion lut_multiple() +���2 */
 /* ###########################################################################
  * # lut_multiple(): Universalfunktion, um zu einer gegebenen Bankleitzahl   #
@@ -9045,7 +9053,7 @@ DLL_EXPORT int lut_cleanup(void)
    FREE(sort_pz_f);
    FREE(sort_plz);
    FREE(sort_iban_regel);
-#line 9602 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 9610 "konto_check.lxx"
    if(name_raw && name_data!=name_raw)
       FREE(name_raw);
    else
@@ -9114,7 +9122,7 @@ DLL_EXPORT int lut_cleanup(void)
       lut_cleanup(); /* neuer Versuch, aufzur�umen */
       RETURN(INIT_FATAL_ERROR);
    }
-#line 9676 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 9684 "konto_check.lxx"
    init_status&=1;
    init_in_progress=0;
    return OK;
@@ -9287,10 +9295,8 @@ static void init_atoi_table(void)
    int i,ziffer;
    unsigned long l;
 
-#if 1
-      /* �nderungen zum 07.09.2015 aktivieren */
-   if(time(NULL)>1441576800 ||0)pz_aenderungen_aktivieren_2015_09=1;
-#endif
+      /* �nderungen zum 06.03.2017 aktivieren */
+   if(time(NULL)>1488754800 ||0)pz_aenderungen_aktivieren_2017_03=1;
 
    /* ung�ltige Ziffern; Blanks und Tabs werden ebenfalls als ung�ltig
     * angesehen(!), da die Stellenzuordnung sonst nicht mehr stimmt. Ausnahme:
@@ -9555,7 +9561,7 @@ static void init_atoi_table(void)
    lut_block_name2[126]="2. IBAN Regel idx";
    lut_block_name2[127]="2. BIC Hauptst.idx";
    lut_blocklen_max=453;
-#line 9918 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 9924 "konto_check.lxx"
    init_status|=1;
 }
 
@@ -9615,7 +9621,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
 
    switch(pz_methode){
 
-#line 9981 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 9987 "konto_check.lxx"
 /* Berechnungsmethoden 00 bis 09 +���3
    Berechnung nach der Methode 00 +���4 */
 /*
@@ -11950,7 +11956,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * ######################################################################
  */
 
-#line 11992 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 11998 "konto_check.lxx"
       case 51:
          if(*(kto+2)=='9'){   /* Ausnahme */
 
@@ -12212,8 +12218,8 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
          else
             return FALSE;
 
-#line 12206 "ruby/ext/konto_check_raw/konto_check.lxx"
-#line 12208 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 12212 "konto_check.lxx"
+#line 12214 "konto_check.lxx"
 /*  Berechnung nach der Methode 53 +���4 */
 /*
  * ######################################################################
@@ -12512,7 +12518,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # bewerten.                                                          #
  * ######################################################################
  */
-#line 12477 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 12483 "konto_check.lxx"
       case 57:
 #if DEBUG>0
          if(retvals){
@@ -13158,7 +13164,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # Pr�fzifferberechnung)                                              #
  * ######################################################################
  */
-#line 13057 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 13063 "konto_check.lxx"
       case 66:
 #if DEBUG>0
       case 2066:
@@ -13750,15 +13756,18 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
 /*  Berechnung nach der Methode 74 +���4 */
 /*
  * ######################################################################
- * #    Berechnung nach der Methode 74 (ge�ndert zum 4.6.2007)          #
+ * #    Berechnung nach der Methode 74 (ge�ndert zum 5.12.2016)         #
  * ######################################################################
  * # Modulus 10, Gewichtung 2, 1, 2, 1, 2 ff.                           #
  * # Die Kontonummer (2- bis 10-stellig) ist durch linksb�ndige         #
  * # Nullenauff�llung 10-stellig darzustellen. Die 10. Stelle ist       #
- * # per Definition die Pr�fziffer. Die f�r die Berechnung              #
- * # relevanten Stellen werden von rechts nach links mit den Ziffern    #
- * # 2, 1, 2, 1, 2 ff. multipliziert. Die weitere Berechnung und die    #
- * # Ergebnisse entsprechen dem Verfahren 00.                           #
+ * # per Definition die Pr�fziffer.                                     #
+ * #                                                                    #
+ * # Variante 1:                                                        #
+ * # Die f�r die Berechnung relevanten Stellen werden von rechts nach   #
+ * # links mit den Ziffern  2, 1, 2, 1, 2 ff. multipliziert. Die        #
+ * # weitere Berechnung und die  Ergebnisse entsprechen dem Verfahren   #
+ * # 00.                                                                #
  * #                                                                    #
  * # Ausnahme:                                                          #
  * # Bei 6-stelligen Kontonummern ist folgende Besonderheit zu          #
@@ -13767,8 +13776,16 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # einen Pr�fziffernfehler, so ist eine weitere Berechnung            #
  * # vorzunehmen. Hierbei ist die Summe der Produkte auf die n�chste    #
  * # Halbdekade hochzurechnen. Die Differenz ist die Pr�fziffer.        #
+ * #                                                                    #
+ * # F�hrt die Berechnung nach Variante 1 zu einem Pr�fzifferfehler,    #
+ * # so ist nach Variante 2 zu pr�fen.                                  #
+ * #                                                                    #
+ * # Variante 2:                                                        #
+ * # Modulus 11, Gewichtung 2, 3, 4, 5, 6, 7, 2, 3, 4                   #
+ * # Gewichtung und Berechnung erfolgen nach der Methode 04.            #
  * ######################################################################
  */
+
       case 74:
          if(kto[0]=='0' && kto[1]=='0' && kto[2]=='0' && kto[3]=='0' && kto[4]=='0'
                && kto[5]=='0' && kto[6]=='0' && kto[7]=='0' && kto[8]=='0')return INVALID_KTO;
@@ -13850,8 +13867,28 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
             if(pz)pz=10-pz;
             CHECK_PZ10;
          }
-         else
-            return FALSE;
+
+#if DEBUG>0
+      case 3074:
+         if(retvals){
+            retvals->methode="74c";
+            retvals->pz_methode=3074;
+         }
+#endif
+         pz = (kto[0]-'0') * 4
+            + (kto[1]-'0') * 3
+            + (kto[2]-'0') * 2
+            + (kto[3]-'0') * 7
+            + (kto[4]-'0') * 6
+            + (kto[5]-'0') * 5
+            + (kto[6]-'0') * 4
+            + (kto[7]-'0') * 3
+            + (kto[8]-'0') * 2;
+
+         MOD_11_176;   /* pz%=11 */
+         if(pz)pz=11-pz;
+         INVALID_PZ10;
+         CHECK_PZ10;
 
 /*  Berechnung nach der Methode 75 +���4 */
 /*
@@ -15317,9 +15354,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
             retvals->pz_methode=4087;
          }
 #endif
-            /* die neue Untermethode wird erst ab 7. September 2015 g�ltig */
-         if(!pz_aenderungen_aktivieren_2015_09)return UNDEFINED_SUBMETHOD;
-
          pz = (kto[3]-'0') * 7
             + (kto[4]-'0') * 6
             + (kto[5]-'0') * 5
@@ -16060,7 +16094,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
 #endif
                for(p1=0,ptr=kto+4,i=0;i<5;ptr--,i++)
                   p1+=(*ptr-'0')*w93[i];
-                  *(kto+9)= *(kto+5);  /* Pr�fziffer nach Stelle 10 */
+               *(kto+9)= *(kto+5);  /* Pr�fziffer nach Stelle 10 */
             }
          }
 #endif
@@ -16794,7 +16828,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
             else{
                for(p1=0,ptr=kto+4,i=0;i<5;ptr--,i++)
                   p1+=(*ptr-'0')*w93[i];
-                  *(kto+9)= *(kto+5);  /* Pr�fziffer nach Stelle 10 */
+               *(kto+9)= *(kto+5);  /* Pr�fziffer nach Stelle 10 */
             }
          }
 #endif
@@ -20287,6 +20321,95 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
          if(pz)pz=10-pz;
          CHECK_PZ10;
 
+/* Berechnung nach der Methode E3 +���4 */
+/*
+ * ######################################################################
+ * #               Berechnung nach der Methode E3                       #
+ * ######################################################################
+ * # Die Kontonummer ist einschlie�lich der Pr�fziffer 10-stellig,      #
+ * # ggf. ist die Kontonummer f�r die Pr�fzifferberechnung durch        #
+ * # linksb�ndige Auff�llung mit Nullen 10-stellig darzustellen.        #
+ * #                                                                    #
+ * # Variante 1:                                                        #
+ * # Modulus 10, Gewichtung 2, 1, 2, 1, 2, 1, 2, 1, 2                   #
+ * #                                                                    #
+ * # Die Berechnung erfolgt nach der Methode 00.                        #
+ * # F�hrt die Berechnung nach Variante 1 zu einem Pr�fzifferfehler,    #
+ * # so ist nach Variante 2 zu pr�fen.                                  #
+ * #                                                                    #
+ * # Variante 2:                                                        #
+ * # Modulus 10, Gewichtung 2, 1, 2, 1, 2, 1, 2, 1, 2 (modifiziert)     #
+ * #                                                                    #
+ * # Die Berechnung erfolgt nach der Methode 21.                        #
+ * ######################################################################
+ */
+
+      case 143:
+#if DEBUG>0
+         if(retvals){
+            retvals->methode="E3";
+            retvals->pz_methode=143;
+         }
+#endif
+if(!pz_aenderungen_aktivieren_2017_03)return NOT_DEFINED;
+
+   /* Variante 1: Berechnung nach der Methode 00 */
+#if DEBUG>0
+      case 1143:
+         if(retvals){
+            retvals->methode="E3a";
+            retvals->pz_methode=1143;
+         }
+#endif
+#ifdef __ALPHA
+         pz = ((kto[0]<'5') ? (kto[0]-'0')*2 : (kto[0]-'0')*2-9)
+            +  (kto[1]-'0')
+            + ((kto[2]<'5') ? (kto[2]-'0')*2 : (kto[2]-'0')*2-9)
+            +  (kto[3]-'0')
+            + ((kto[4]<'5') ? (kto[4]-'0')*2 : (kto[4]-'0')*2-9)
+            +  (kto[5]-'0')
+            + ((kto[6]<'5') ? (kto[6]-'0')*2 : (kto[6]-'0')*2-9)
+            +  (kto[7]-'0')
+            + ((kto[8]<'5') ? (kto[8]-'0')*2 : (kto[8]-'0')*2-9);
+#else
+         pz=(kto[1]-'0')+(kto[3]-'0')+(kto[5]-'0')+(kto[7]-'0');
+         if(kto[0]<'5')pz+=(kto[0]-'0')*2; else pz+=(kto[0]-'0')*2-9;
+         if(kto[2]<'5')pz+=(kto[2]-'0')*2; else pz+=(kto[2]-'0')*2-9;
+         if(kto[4]<'5')pz+=(kto[4]-'0')*2; else pz+=(kto[4]-'0')*2-9;
+         if(kto[6]<'5')pz+=(kto[6]-'0')*2; else pz+=(kto[6]-'0')*2-9;
+         if(kto[8]<'5')pz+=(kto[8]-'0')*2; else pz+=(kto[8]-'0')*2-9;
+#endif
+         MOD_10_80;   /* pz%=10 */
+         if(pz)pz=10-pz;
+         CHECK_PZX10;
+
+   /* Variante 2: Berechnung nach der Methode 21 */
+#if DEBUG>0
+      case 2143:
+         if(retvals){
+            retvals->methode="E3b";
+            retvals->pz_methode=2143;
+         }
+#endif
+
+         pz = (kto[0]-'0') * 2
+            + (kto[1]-'0')
+            + (kto[2]-'0') * 2
+            + (kto[3]-'0')
+            + (kto[4]-'0') * 2
+            + (kto[5]-'0')
+            + (kto[6]-'0') * 2
+            + (kto[7]-'0')
+            + (kto[8]-'0') * 2;
+
+         if(pz>=80)pz=pz-80+8;
+         if(pz>=40)pz=pz-40+4;
+         if(pz>=20)pz=pz-20+2;
+         if(pz>=10)pz=pz-10+1;
+         if(pz>=10)pz=pz-10+1;
+         if(pz)pz=10-pz;
+         CHECK_PZ10;
+
 /* nicht abgedeckte F�lle +���3 */
 /*
  * ######################################################################
@@ -20304,7 +20427,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
          return NOT_IMPLEMENTED;
    }
 }
-#line 19060 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 19159 "konto_check.lxx"
 
 /*
  * ######################################################################
@@ -20402,7 +20525,7 @@ DLL_EXPORT int kto_check_blz(char *blz,char *kto)
 #if DEBUG>0    /* es werden einige Funktionen benutzt, die nur in der Debug-Variante enthalten sind */
 DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,const char **bic,int *regel,RETVAL *retvals)
 {
-#line 19158 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 19257 "konto_check.lxx"
    char *blz_o,buffer[32],kto_o[16],*blz_n,*kto_n,*ptr,*dptr;
    const char *bicp;
    int ret,ret_regel,r;
@@ -20450,7 +20573,7 @@ DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,con
    }
    else  /* BLZ und Kto gleich */
       return ret;
-#line 19206 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 19305 "konto_check.lxx"
 }
 
 #else   /* !DEBUG */
@@ -20600,7 +20723,7 @@ DLL_EXPORT int kto_check_blz_dbg(char *blz,char *kto,RETVAL *retvals)
  * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
  * ###########################################################################
  */
-#line 19356 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 19455 "konto_check.lxx"
 DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals)
 {
    int untermethode,pz_methode;
@@ -20836,7 +20959,7 @@ DLL_EXPORT int get_lut_info2_b(char *lutname,int *version,char **prolog_p,char *
    }
    else
       **user_info_p=0;
-#line 19577 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 19676 "konto_check.lxx"
    FREE(prolog);
    return OK;
 }
@@ -20972,23 +21095,23 @@ DLL_EXPORT const char *get_kto_check_version_x(int mode)
          return __DATE__ ", " __TIME__;    /* Compilierdatum und -zeit */
       case 4:                              /* Datum der Pr�fziffermethode */
 #if 1
-         if(pz_aenderungen_aktivieren_2015_09)
-            return "07.09.2015";
+         if(pz_aenderungen_aktivieren_2017_03)
+            return "06.03.2017";
          else
-            return "08.06.2015 (Aenderungen vom 07.09.2015 enthalten aber noch nicht aktiviert)";
+            return "05.12.2016 (Aenderungen vom 06.03.2017 enthalten aber noch nicht aktiviert)";
 #else
-         return "07.09.2015";
+         return "06.03.2017";
 #endif
       case 5:
-        return "07.09.2015";
+        return "05.12.2016";
       case 6:
-        return "22. August 2015";            /* Klartext-Datum der Bibliotheksversion */
+        return "3. M�rz 2017";            /* Klartext-Datum der Bibliotheksversion */
       case 7:
         return "final";              /* Versions-Typ der Bibliotheksversion (development, beta, final) */
       case 8:
         return "5";             /* Hauptversionszahl */
       case 9:
-        return "8";             /* Unterversionszahl */
+        return "10";             /* Unterversionszahl */
    }
 }
 
@@ -21134,7 +21257,7 @@ DLL_EXPORT int dump_lutfile(char *outputname,UINT4 *required)
       default:
          break;
    }
-#line 19814 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 19913 "konto_check.lxx"
    fputc('\n',out);
    while(--i)fputc('=',out);
    fputc('\n',out);
@@ -21270,7 +21393,7 @@ DLL_EXPORT int rebuild_blzfile(char *inputname,char *outputname,UINT4 set)
    }
    else  /* set-Parameter 1 oder 2: LUT-Datei als Eingabedatei */
       if(set>2)set=2;   /* set darf nur 0, 1 oder 2 sein; 0 wurde schon behandelt, negative Werte gibt es nicht (UINT4 Parameter) */
-      if((ret=kto_check_init_p(inputname,9,set,0))<=0)RETURN(ret);
+   if((ret=kto_check_init_p(inputname,9,set,0))<=0)RETURN(ret);
 
    if(!(out=fopen(outputname,"w"))){
       PRINT_VERBOSE_DEBUG_FILE("fopen");
@@ -21459,7 +21582,7 @@ DLL_EXPORT const char *iban2bic_id(char *iban,int *retval,int *blz,int *kto)
    return iban2bic(iban,retval,b,k);
 }
 
-#line 20139 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 20238 "konto_check.lxx"
 /* Funktion iban_gen(), iban_bic_gen() und iban_bic_gen1 +���1 */
 /* ###########################################################################
  * # Die Funktion iban_gen generiert aus Bankleitzahl und Kontonummer eine   #
@@ -22292,7 +22415,7 @@ DLL_EXPORT int ipi_check(char *zweck)
  * # Copyright (C) 2009,2011 Michael Plugge <m.plugge@hs-mannheim.de>        #
  * ###########################################################################
  */
-#line 20972 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 21071 "konto_check.lxx"
 
 /* Funktion volltext_zeichen() +���2 */
 /* Diese Funktion gibt f�r Zeichen die bei der Volltextsuche g�ltig sind
@@ -23084,11 +23207,12 @@ static int binary_search(char *a,char **base,int *sort_a,int cnt,int *unten,int
          l=x+1;
       x=(l+r)/2;
    }
-   if(y){
+   if(y){   /* Suchwort im kompletten Bereich nicht gefunden */
       *unten=*anzahl=0;
       return KEY_NOT_FOUND;
    }
 
+      /* Grenzen nach unten und oben bestimmen */
    for(l=x;l>=0 && !(*fkt)(a,base[sort_a[l]]);l--);
    l++;
    *unten=l;
@@ -23138,7 +23262,7 @@ static int qcmp_bic_h(const void *ap,const void *bp)
       return a-b;
 }
 
-#line 21818 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 21918 "konto_check.lxx"
 
 /* Funktion qcmp_bic() +���3 */
 static int qcmp_bic(const void *ap,const void *bp)
@@ -23243,7 +23367,7 @@ static int qcmp_iban_regel(const void *ap,const void *bp)
    else 
       return a-b;
 }
-#line 21833 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 21933 "konto_check.lxx"
 
 /* Funktion init_blzf() +���2
  * Diese Funktion initialisiert das Array mit den Bankleitzahlen f�r alle
@@ -23311,7 +23435,7 @@ DLL_EXPORT int konto_check_idx2blz(int idx,int *zweigstelle,int *retval)
 }
 
 /* Funktion suche_int1() +���2 */
-#line 21901 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 22001 "konto_check.lxx"
 static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstellen_base,int **blz_base,
       int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int cnt,int such_idx)
 {
@@ -23362,7 +23486,7 @@ static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstell
 }
 
 /* Funktion suche_int2() +���2 */
-#line 21952 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 22052 "konto_check.lxx"
 static int suche_int2(int a1,int a2,int *anzahl,int **start_idx,int **zweigstellen_base,int **blz_base,
       int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int such_idx,int pz_suche)
 {
@@ -23527,7 +23651,7 @@ static int *lut_suche_multiple_and(int *such_array,int *start1,int cnt1,int *sta
 
    if(cnt)*cnt=lut2_cnt;
    if(!such_array){
-      if(!(such_array=(int *)calloc(sizeof(int),lut2_cnt))){
+      if(!(such_array=(int *)calloc(lut2_cnt,sizeof(int)))){
          if(retval)*retval=ERROR_MALLOC;
          return NULL;
       }
@@ -23592,8 +23716,8 @@ DLL_EXPORT int lut_suche_init(int uniq)
    int i,id;
    LUT_SUCHE_ARR *a;
 
-   if(!(a=(LUT_SUCHE_ARR *)calloc(sizeof(LUT_SUCHE_ARR),1)))return ERROR_MALLOC;
-   if(!lut_suche_arr && !(lut_suche_arr=(LUT_SUCHE_ARR **)calloc(sizeof(LUT_SUCHE_ARR*),last_lut_suche_idx=100)))return ERROR_MALLOC;
+   if(!(a=(LUT_SUCHE_ARR *)calloc(1,sizeof(LUT_SUCHE_ARR))))return ERROR_MALLOC;
+   if(!lut_suche_arr && !(lut_suche_arr=(LUT_SUCHE_ARR **)calloc(last_lut_suche_idx=100,sizeof(LUT_SUCHE_ARR*))))return ERROR_MALLOC;
    for(i=id=0;i<last_lut_suche_idx;i++)if(!lut_suche_arr[i]){  /* freien Index suchen */
       id=i;
       break;
@@ -23805,6 +23929,41 @@ DLL_EXPORT int lut_suche(int such_id,char *such_cmd,UINT4 *such_cnt,UINT4 **fili
    else
       return OK;
 }
+#if 0
+/* Funktion lut_suche_namen_re() +���2 */
+DLL_EXPORT int lut_suche_namen_re(char *such_str,int *anzahl,int **start_idx,int **zweigstellen_base,
+      char ***base_name,int **blz_base)
+//#error lut_suche_namen_re hier; zun�chst mal die Suche nach Namen, dann erst Volltext etc.
+{
+   if(anzahl)*anzahl=0;
+   if((init_status&7)<7)return LUT2_NOT_INITIALIZED;
+   if(lut_id_status==FALSE)return LUT1_FILE_USED;
+   if(!name)return LUT2_NAME_NOT_INITIALIZED;   
+   if(base_name)*base_name=name;
+   {
+typedef struct{
+   char *pbuffer;
+   int *cnt1;
+   int *cnt2;
+   int *special;
+   char *regexp;
+   int caseless;
+   int pcre;
+   int re_last_index;
+} MATCH_CTX;
+
+      char *buf;
+      int i,j;
+      MATCH_CTX mctx;
+
+      buf=calloc(500,sizeof(int));
+      for (i=j=0;i<500;i++)if(match(such_str,base_name[i],&mctx))buf[j++]=i;
+   }
+
+fprintf(stderr,"Suchstring: %s\n",such_str);
+//   return suche_str(such_str,anzahl,start_idx,zweigstellen_base,blz_base,&name,&sort_name,qcmp_name,LUT2_NAME_SORT);
+}
+#endif
 
 /* Funktion lut_suche_multiple() +���2 */
 DLL_EXPORT int lut_suche_multiple(char *such_str,int uniq,char *such_cmd,UINT4 *anzahl,UINT4 **zweigstellen,UINT4 **blz)
@@ -23846,8 +24005,9 @@ DLL_EXPORT int lut_suche_multiple(char *such_str,int uniq,char *such_cmd,UINT4 *
       }
       else
          idx=j;
+//#error volltext_zeichen() nur bei suche_volltext???
       while(volltext_zeichen(UCPP &ptr))ptr++;
-      typ=LUT_SUCHE_VOLLTEXT;
+      typ=LUT_SUCHE_VOLLTEXT; /* Default-Einstellung */
       i1=i2=0;
       if(*ptr=='-'){    /* Bereich (f�r numerische Suche) angegeben */
          pi2=++ptr;
@@ -23941,7 +24101,7 @@ static int cmp_suche_sort(const void *ap,const void *bp)
 DLL_EXPORT int lut_suche_sort1(int anzahl,int *blz_base,int *zweigstellen_base,int *idx,int *anzahl_o,int **idx_op,int **cnt_op,int uniq)
 {
    int i,j,last_idx,*idx_a,*cnt_o;
-#line 22532 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 22668 "konto_check.lxx"
 
    if(idx_op)*idx_op=NULL;
    if(cnt_op)*cnt_op=NULL;
@@ -24023,7 +24183,7 @@ DLL_EXPORT int lut_suche_sort2(int anzahl,int *blz,int *zweigstellen,int *anzahl
    return OK;
 }
 
-#line 22615 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 22751 "konto_check.lxx"
 /* Funktion lut_suche_volltext() +���2 */
 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)
@@ -24153,7 +24313,7 @@ DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int
    return suche_int1(such1,such2,anzahl,start_idx,zweigstellen_base,blz_base,&blz_f,&sort_blz,qcmp_blz,cnt,0);
 }
 
-#line 22765 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 22901 "konto_check.lxx"
 /* Funktion lut_suche_bic() +���2 */
 DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,
       char ***base_name,int **blz_base)
@@ -24244,7 +24404,7 @@ DLL_EXPORT int lut_suche_regel(int such1,int such2,int *anzahl,int **start_idx,i
    return suche_int2(such1*100,such2*100+99,anzahl,start_idx,zweigstellen_base,blz_base,&iban_regel,&sort_iban_regel,qcmp_iban_regel,LUT2_IBAN_REGEL_SORT,0);
 }
 
-#line 22798 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 22934 "konto_check.lxx"
 
 /* Funktion lut_suche_bic_h() +���2 */
 DLL_EXPORT int lut_suche_bic_h(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,
@@ -24630,7 +24790,7 @@ DLL_EXPORT const char *iban_ort(char *iban,int filiale,int*retval)
 {
    return iban_fkt_s(iban,filiale,retval,lut_ort);
 }
-#line 22887 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 23023 "konto_check.lxx"
 
 static int bic_fkt_c(char *bic1,int mode,int filiale,int *retval,char *base,int error)
 {
@@ -25575,7 +25735,7 @@ static int convert_encoding(char **data,UINT4 *len)
 DLL_EXPORT const char *pz2str(int pz,int *ret)
 {
    if(ret){
-      if(pz%1000>=143)
+      if(pz%1000>=144)
          *ret=NOT_DEFINED;
       else
          *ret=OK;
@@ -25724,6 +25884,7 @@ DLL_EXPORT const char *pz2str(int pz,int *ret)
       case 140: return "E0";
       case 141: return "E1";
       case 142: return "E2";
+      case 143: return "E3";
       case 1013: return "13a";
       case 1049: return "49a";
       case 1050: return "50a";
@@ -25789,6 +25950,7 @@ DLL_EXPORT const char *pz2str(int pz,int *ret)
       case 1136: return "D6a";
       case 1138: return "D8a";
       case 1139: return "D9a";
+      case 1143: return "E3a";
       case 2013: return "13b";
       case 2049: return "49b";
       case 2050: return "50b";
@@ -25854,10 +26016,12 @@ DLL_EXPORT const char *pz2str(int pz,int *ret)
       case 2136: return "D6b";
       case 2138: return "D8b";
       case 2139: return "D9b";
+      case 2143: return "E3b";
       case 3051: return "51c";
       case 3057: return "57c";
       case 3068: return "68c";
       case 3073: return "73c";
+      case 3074: return "74c";
       case 3075: return "75c";
       case 3080: return "80c";
       case 3081: return "81c";
@@ -25910,7 +26074,7 @@ DLL_EXPORT const char *pz2str(int pz,int *ret)
       default:   return "???";
    }
 }
-#line 23842 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 23978 "konto_check.lxx"
 
 /* Funktion lut_keine_iban_berechnung() +���1 */
 /*
@@ -26025,7 +26189,7 @@ DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int
 /* Funktion pz_aenderungen_enable() +���1 */
 /* ###########################################################################
  * # Die Funktion pz_aenderungen_enable() dient dazu, den Status des Flags   #
- * # pz_aenderungen_aktivieren_2015_09 abzufragen bzw. zu setzen. Falls die Variable #
+ * # pz_aenderungen_aktivieren_2017_03 abzufragen bzw. zu setzen. Falls die Variable #
  * # set 1 ist, werden die �nderungen aktiviert, falls sie 0 ist, werden     #
  * # die �nderungen deaktiviert. Bei allen anderen Werten wird das aktuelle  #
  * # Flag nicht ver�ndert, sondern nur der Status zur�ckgegeben.             #
@@ -26041,8 +26205,8 @@ DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int
 
 DLL_EXPORT int pz_aenderungen_enable(int set)
 {
-   if(set==0 || set==1)pz_aenderungen_aktivieren_2015_09=set;
-   return pz_aenderungen_aktivieren_2015_09;
+   if(set==0 || set==1)pz_aenderungen_aktivieren_2017_03=set;
+   return pz_aenderungen_aktivieren_2017_03;
 }
 
 #if DEBUG>0
@@ -26074,7 +26238,7 @@ DLL_EXPORT char *kto_check_test_vars(char *txt,UINT4 i)
 #endif
 
 
-#line 24006 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 24142 "konto_check.lxx"
 /* Funktionen *_id() +���1 */
 /* ###########################################################################
  * # Die folgenden Funktionen sind die id-Varianten von Funktionen, die      #
@@ -26261,7 +26425,7 @@ static int kc_ptr2id(char *ptr,int *handle,int release_mem)
 
    *handle=-1; /* f�r evl. malloc-Fehler vorbelegen */
    if(!h_cnt){
-      if(!(handle_ptr=(char **)calloc(sizeof(char*),HANDLE_CNT_INCREMENT)) || !(handle_free=(int*)calloc(sizeof(int),HANDLE_CNT_INCREMENT)))return ERROR_MALLOC;
+      if(!(handle_ptr=(char **)calloc(HANDLE_CNT_INCREMENT,sizeof(char*))) || !(handle_free=(int*)calloc(HANDLE_CNT_INCREMENT,sizeof(int))))return ERROR_MALLOC;
       h_cnt=HANDLE_CNT_INCREMENT;
    }
    if(!release_mem)  /* Handle f�r fixen String, suchen ob er schon vergeben wurde */

data/ext/konto_check_raw/konto_check.h

@@ -10,7 +10,7 @@
  * #  Verwendung in anderen Programmen bzw. Programmiersprachen benutzt     #
  * #  werden.                                                               #
  * #                                                                        #
- * #  Copyright (C) 2002-2015 Michael Plugge <m.plugge@hs-mannheim.de>      #
+ * #  Copyright (C) 2002-2017 Michael Plugge <m.plugge@hs-mannheim.de>      #
  * #                                                                        #
  * #  Dieses Programm ist freie Software; Sie d�rfen es unter den           #
  * #  Bedingungen der GNU Lesser General Public License, wie von der Free   #
@@ -77,7 +77,10 @@
  * einige Arrays damit initialisiert werden.
  */
 
-#define DEFAULT_ENCODING 1
+#ifndef DEFAULT_ENCODING
+#  define DEFAULT_ENCODING 1
+#endif
+
 #define KEEP_RAW_DATA    1
 
 /* 
@@ -328,6 +331,8 @@ extern const char *lut2_feld_namen[256];
  */
 
 #undef FALSE
+#define INVALID_REGULAR_EXPRESSION_CNT        -152
+#define INVALID_REGULAR_EXPRESSION            -151
 #define INVALID_HANDLE                        -150
 #define INVALID_BIQ_INDEX                     -149
 #define ARRAY_INDEX_OUT_OF_RANGE              -148
@@ -479,7 +484,7 @@ extern const char *lut2_feld_namen[256];
 #define OK_KTO_REPLACED_NO_PZ                   24
 #define OK_UNTERKONTO_ATTACHED                  25
 #define OK_SHORT_BIC_USED                       26
-#line 276 "konto_check_h.lx"
+#line 279 "konto_check_h.lx"
 
 #define MAX_BLZ_CNT 30000  /* maximale Anzahl BLZ's in generate_lut() */
 

data/ext/konto_check_raw/konto_check_raw_ruby.c

@@ -811,7 +811,7 @@ static VALUE lut_blocks_rb(int argc,VALUE* argv,VALUE self)
  */
 static VALUE lut_blocks1_rb(int argc,VALUE* argv,VALUE self)
 {
-   rb_scan_args(argc,argv,"0");
+   rb_scan_args(argc,argv,"0",NULL);
    return INT2FIX(lut_blocks(0,NULL,NULL,NULL));
 }
 
@@ -4354,11 +4354,11 @@ 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
- * (00 to E2) are implemented.
+ * (00 to E3) 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 (V. 5.8 from 2015-08-22):
+ * and this version (V. 5.10 from 2017-03-10):
  *
  * * The function KontoCheck::load_bank_data() is no longer used; it is
  *   replaced by KontoCheck::init() and KontoCheck::generate_lutfile().
@@ -4540,6 +4540,10 @@ void Init_konto_check_raw()
    rb_define_module_function(KontoCheck,"load_bank_data",load_bank_data,1);
 
       /* Rückgabewerte der konto_check Bibliothek */
+      /* (-152) Ungültiger Zähler in regulärem Ausdruck (innerhalb von {}) */
+   rb_define_const(KontoCheck,"INVALID_REGULAR_EXPRESSION_CNT",INT2FIX(INVALID_REGULAR_EXPRESSION_CNT));
+      /* (-151) Ungültiger regulärer Ausdruck (enthält zwei Zeichen aus [+?*] nacheinander) */
+   rb_define_const(KontoCheck,"INVALID_REGULAR_EXPRESSION",INT2FIX(INVALID_REGULAR_EXPRESSION));
       /* (-150) Ungültiges Handle angegeben */
    rb_define_const(KontoCheck,"INVALID_HANDLE",INT2FIX(INVALID_HANDLE));
       /* (-149) Ungültiger Index für die biq_*() Funktionen */

data/ext/konto_check_raw/retvals.h

@@ -48,6 +48,8 @@ DLL_EXPORT const char *kto_check_retval2txt(int retval)
 DLL_EXPORT const char *kto_check_retval2iso(int retval)
 {
    switch(retval){
+      case INVALID_REGULAR_EXPRESSION_CNT: return "Ung�ltiger Z�hler in regul�rem Ausdruck (innerhalb von {})";
+      case INVALID_REGULAR_EXPRESSION: return "Ung�ltiger regul�rer Ausdruck (enth�lt zwei Zeichen aus [+?*] nacheinander)";
       case INVALID_HANDLE: return "Ung�ltiges Handle angegeben";
       case INVALID_BIQ_INDEX: return "Ung�ltiger Index f�r die biq_*() Funktionen";
       case ARRAY_INDEX_OUT_OF_RANGE: return "Der Array-Index liegt au�erhalb des g�ltigen Bereichs";
@@ -216,6 +218,8 @@ DLL_EXPORT const char *kto_check_retval2iso(int retval)
 DLL_EXPORT const char *kto_check_retval2dos(int retval)
 {
    switch(retval){
+      case INVALID_REGULAR_EXPRESSION_CNT: return "Ung�ltiger Z� hler in regul� rem Ausdruck (innerhalb von {})";
+      case INVALID_REGULAR_EXPRESSION: return "Ung�ltiger regul� rer Ausdruck (enth� lt zwei Zeichen aus [+?*] nacheinander)";
       case INVALID_HANDLE: return "Ung�ltiges Handle angegeben";
       case INVALID_BIQ_INDEX: return "Ung�ltiger Index f�r die biq_*() Funktionen";
       case ARRAY_INDEX_OUT_OF_RANGE: return "Der Array-Index liegt au�erhalb des g�ltigen Bereichs";
@@ -384,6 +388,8 @@ DLL_EXPORT const char *kto_check_retval2dos(int retval)
 DLL_EXPORT const char *kto_check_retval2html(int retval)
 {
    switch(retval){
+      case INVALID_REGULAR_EXPRESSION_CNT: return "Ungültiger Zähler in regulärem Ausdruck (innerhalb von {})";
+      case INVALID_REGULAR_EXPRESSION: return "Ungültiger regulärer Ausdruck (enthält zwei Zeichen aus [+?*] nacheinander)";
       case INVALID_HANDLE: return "Ungültiges Handle angegeben";
       case INVALID_BIQ_INDEX: return "Ungültiger Index für die biq_*() Funktionen";
       case ARRAY_INDEX_OUT_OF_RANGE: return "Der Array-Index liegt außerhalb des gültigen Bereichs";
@@ -552,6 +558,8 @@ DLL_EXPORT const char *kto_check_retval2html(int retval)
 DLL_EXPORT const char *kto_check_retval2utf8(int retval)
 {
    switch(retval){
+      case INVALID_REGULAR_EXPRESSION_CNT: return "Ungültiger Zähler in regulärem Ausdruck (innerhalb von {})";
+      case INVALID_REGULAR_EXPRESSION: return "Ungültiger regulärer Ausdruck (enthält zwei Zeichen aus [+?*] nacheinander)";
       case INVALID_HANDLE: return "Ungültiges Handle angegeben";
       case INVALID_BIQ_INDEX: return "Ungültiger Index für die biq_*() Funktionen";
       case ARRAY_INDEX_OUT_OF_RANGE: return "Der Array-Index liegt außerhalb des gültigen Bereichs";
@@ -720,6 +728,8 @@ DLL_EXPORT const char *kto_check_retval2utf8(int retval)
 DLL_EXPORT const char *kto_check_retval2txt_short(int retval)
 {
    switch(retval){
+      case INVALID_REGULAR_EXPRESSION_CNT: return "INVALID_REGULAR_EXPRESSION_CNT";
+      case INVALID_REGULAR_EXPRESSION: return "INVALID_REGULAR_EXPRESSION";
       case INVALID_HANDLE: return "INVALID_HANDLE";
       case INVALID_BIQ_INDEX: return "INVALID_BIQ_INDEX";
       case ARRAY_INDEX_OUT_OF_RANGE: return "ARRAY_INDEX_OUT_OF_RANGE";

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konto_check
 version: !ruby/object:Gem::Version
-  version: 5.8.0
-  prerelease: 
+  version: 5.10.0
 platform: ruby
 authors:
 - Provideal Systems GmbH
@@ -11,22 +10,20 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-13 00:00:00.000000000 Z
+date: 2017-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thoughtbot-shoulda
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Check whether a certain bic/account-no-combination or an IBAN can possibly
@@ -42,39 +39,37 @@ extra_rdoc_files:
 - README.textile
 - ext/konto_check_raw/konto_check_raw_ruby.c
 files:
+- LICENSE
+- README.textile
 - ext/konto_check_raw/extconf.rb
 - ext/konto_check_raw/konto_check.c
 - ext/konto_check_raw/konto_check.h
 - ext/konto_check_raw/konto_check_raw_ruby.c
 - ext/konto_check_raw/retvals.h
 - lib/konto_check.rb
-- LICENSE
-- README.textile
 homepage: http://kontocheck.sourceforge.net
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.5.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Checking german BICs/Bank account numbers and IBANs, generate IBANs, retrieve
   information about german Banks, search for Banks matching certain criteria, check
   IBAN or BIC, convert bic/account to IBAN and BIC
 test_files: []
-has_rdoc: