module 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 (Deletion). Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Änderungsflag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

Mögliche Statuscodes:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -43 (LUT2_AENDERUNG_NOT_INITIALIZED) “Das Feld Änderung wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_aenderung(int argc,VALUE* argv,VALUE self)
{
   char blz[16],aenderung[2],error_msg[512];
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   *aenderung=lut_aenderung(blz,filiale,&retval);
   aenderung[1]=0;
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_AENDERUNG_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(aenderung),INT2FIX(retval));
}

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

• 0: Statuscode

• 1: Anzahl Filialen

• 2: Name

• 3: Kurzname

• 4: PLZ

• 5: Ort

• 6: PAN

• 7: BIC

• 8: Prüfziffer

• 9: Laufende Nr.

• 10: Änderungs-Flag

• 11: Löeschung-Flag

• 12: Nachfolge-BLZ

Der Statuscode (Element 0) kann folgende Werte annehmen:

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -38 (LUT2_PARTIAL_OK) “es wurden nicht alle Blocks geladen”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

* Anmerkung: Falls der Statuscode LUT2_PARTIAL_OK ist, wurden bei der Initialisierung nicht alle Blocks geladen (oder es sind nicht alle verfügbar); die entsprechenden Elemente haben dann den Wert nil.

static VALUE bank_alles(int argc,VALUE* argv,VALUE self)
{
   char blz[16],**p_name,**p_name_kurz,**p_ort,**p_bic,*p_aenderung,*p_loeschung,aenderung[2],loeschung[2],error_msg[512];
   int retval,filiale,cnt,*p_blz,*p_plz,*p_pan,p_pz,*p_nr,*p_nachfolge_blz;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   retval=lut_multiple(blz,&cnt,&p_blz, &p_name,&p_name_kurz,&p_plz,&p_ort,&p_pan,&p_bic,&p_pz,&p_nr,
         &p_aenderung,&p_loeschung,&p_nachfolge_blz,NULL,NULL,NULL);
   if(retval==LUT2_BLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   if(filiale<0 || (cnt && filiale>=cnt))return(INT2FIX(LUT2_INDEX_OUT_OF_RANGE));  /* ungültige Filiale */

      /* Fehler; die C-Arrays dürfen in diesem Fall nicht dereferenziert werden */
   if(retval<=0 && retval!=LUT2_PARTIAL_OK)return rb_ary_new3(2,INT2FIX(retval),Qnil);

   if(p_aenderung){
      *aenderung=p_aenderung[filiale];
      *(aenderung+1)=0;
   }
   else
      *aenderung=0;

   if(p_loeschung){
      *loeschung=p_loeschung[filiale];
      *(loeschung+1)=0;
   }
   else
      *loeschung=0;

   /* Makros für StringValue und IntegerValue definieren, damit die Rückgabe
    * einigermaßen übersichtlich bleibt
    */
#define SV(x) *x?rb_str_new2(x):Qnil
#define IV(x) x>=0?INT2FIX(x):Qnil
   return rb_ary_new3(13,INT2FIX(retval),IV(cnt),SV(p_name[filiale]),
         SV(p_name_kurz[filiale]),IV(p_plz[filiale]),SV(p_ort[filiale]),
         IV(p_pan[filiale]),SV(p_bic[filiale]),IV(p_pz),IV(p_nr[filiale]),
         SV(aenderung),SV(loeschung),IV(p_nachfolge_blz[filiale]));
}

::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 mit dem BIC, im zweiten ein Statuscode. Im Fehlerfall wird für den BIC nil zurückgegeben.

Mögliche Statuscodes:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_bic(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   const char *ptr;
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   ptr=lut_bic(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_BIC_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ptr),INT2FIX(retval));
}

::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 wird für alle Banken nur 1 zurückgegeben. Der Rückgabewert ist ein Array mit der Anzahl Filialen im ersten Parameter, und einem Statuscode im zwweiten.

Mögliche Statuswerte sind:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -52 (LUT2_FILIALEN_NOT_INITIALIZED) “Das Feld Filialen wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_filialen(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,cnt;

   get_params(argc,argv,blz,NULL,NULL,NULL,0);
   cnt=lut_filialen(blz,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_FILIALEN_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(cnt),INT2FIX(retval));
}

::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 Elementen: im ersten steht das Flag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

Mögliche Statuscodes:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -42 (LUT2_LOESCHUNG_NOT_INITIALIZED) “Das Feld Löschung wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_loeschung(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,loeschung,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   loeschung=lut_loeschung(blz,filiale,&retval)-'0';
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_LOESCHUNG_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(loeschung),INT2FIX(retval));
}

::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 zwei Elementen: im ersten steht die Nachfolge-BLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die Nachfolge-BLZ nil zurückgegeben.

Mögliche Statuscodes:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -41 (LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED) “Das Feld Nachfolge-BLZ wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_nachfolge_blz(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,n_blz,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   n_blz=lut_nachfolge_blz(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(n_blz),INT2FIX(retval));
}

::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 zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

Mögliche Statuscodes:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -51 (LUT2_NAME_NOT_INITIALIZED) “Das Feld Bankname wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_name(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   const char *name;
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   name=lut_name(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NAME_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

::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 zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

Mögliche Statuscodes:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -48 (LUT2_NAME_KURZ_NOT_INITIALIZED) “Das Feld Kurzname wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_name_kurz(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   const char *name;
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   name=lut_name_kurz(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NAME_KURZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

::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 Vollständigkeit halber enthalten. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Nummer, im zweiten ein Statuscode. Im Fehlerfall wird für die Nummer nil zurückgegeben.

Mögliche Statuscodes:

Possible return values (and short description):

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -44 (LUT2_NR_NOT_INITIALIZED) “Das Feld NR wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_nr(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,nr,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   nr=lut_nr(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NR_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(nr),INT2FIX(retval));
}

::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 ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im zweiten ein Statuscode. Im Fehlerfall wird für den Ort nil zurückgegeben.

Mögliche Statuscodes:

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -49 (LUT2_ORT_NOT_INITIALIZED) “Das Feld Ort wurde nicht initialisiert”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_ort(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   const char *ort;
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   ort=lut_ort(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_ORT_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ort),INT2FIX(retval));
}

::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 zweiten ein Statuscode. Im Fehlerfall wird für den PAN nil zurückgegeben.

Mögliche Statuscodes:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -47 (LUT2_PAN_NOT_INITIALIZED) “Das Feld PAN wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_pan(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,pan,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   pan=lut_pan(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_PAN_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pan),INT2FIX(retval));
}

::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 Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die PLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die PLZ nil zurückgegeben.

Mögliche Statuscodes:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -50 (LUT2_PLZ_NOT_INITIALIZED) “Das Feld PLZ wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_plz(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,plz,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   plz=lut_plz(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_PLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(plz),INT2FIX(retval));
}

::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 Prüfziffermethode geben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Prüfziffer, im zweiten ein Statuscode. Im Fehlerfall wird für den Prüfziffer nil zurückgegeben.

Mögliche Statuscodes:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -45 (LUT2_PZ_NOT_INITIALIZED) “Das Feld Prüfziffer wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_pz(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,pz;

   get_params(argc,argv,blz,NULL,NULL,NULL,0);
   pz=lut_pz(blz,0,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_PZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pz),INT2FIX(retval));
}

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

• 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:

• -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”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC 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_bic(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,lut_suche_bic,NULL);
}

::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 Rückgabe ist ein Array mit fünf Elementen:

• 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:

• -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”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

static VALUE bank_suche_blz(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,NULL,lut_suche_blz);
}

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

  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.

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));
}

::bank_suche_namen( name [,sort_uniq [,sort]])¶ ↑

KontoCheck.suche¶ ↑

Diese Funktion sucht alle Banken, deren Namen mit dem angegebenen Wert <name> beginnen. Die Rückgabe ist ein Array mit fünf Elementen:

• 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:

• -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”

• -51 (LUT2_NAME_NOT_INITIALIZED) “Das Feld Bankname 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_namen(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,lut_suche_namen,NULL);
}

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

• 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:

• -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”

• -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”

static VALUE bank_suche_namen_kurz(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,lut_suche_namen_kurz,NULL);
}

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

• 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);
}

::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 Rückgabe ist ein Array mit fünf Elementen:

• 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:

• -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”

• -50 (LUT2_PLZ_NOT_INITIALIZED) “Das Feld PLZ 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_plz(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,NULL,lut_suche_plz);
}

::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 Rückgabe ist ein Array mit fünf Elementen:

• 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:

• -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_pz(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,NULL,lut_suche_pz);
}

::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);
}

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

• Das erste Element ist ein Array mit den gefundenen Suchworten

• 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:

• -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_volltext(int argc,VALUE* argv,VALUE self)
{
   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_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);

      /* 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]));
   }
      /* 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));
}

::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 Index existiert.

Mögliche Rückgabewerte sind:

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE bank_valid(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int filiale,retval;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   retval=lut_blz(blz,filiale);
   if(retval==LUT2_BLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return INT2FIX(retval);
}

::bic_aenderung( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_aenderung( bic [,mode [,filiale]])¶ ↑

Diese Funktion liefert das 'Änderung' Flag einer Bank (als string). Mögliche Werte sind: A (Addition), M (Modified), U (Unchanged), D (Deletion). Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Änderungsflag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -43 (LUT2_AENDERUNG_NOT_INITIALIZED) “Das Feld Änderung wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_aenderung_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],aenderung[2],error_msg[512];
   int retval,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   *aenderung=bic_aenderung(bic,mode,filiale,&retval);
   aenderung[1]=0;
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(aenderung),INT2FIX(retval));
}

::bic_bic( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_bic( bic [,mode [,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 mit dem BIC, im zweiten ein Statuscode. Im Fehlerfall wird für den BIC nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_bic_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   const char *ptr;
   int retval,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   ptr=bic_bic(bic,mode,filiale,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ptr),INT2FIX(retval));
}

::bic_check( bic)¶ ↑

KontoCheck.bic_check( bic)¶ ↑

Diese Funktion testet die Existenz eines (deutschen) BIC. 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. Der BIC muß mit genau 8 oder 11 Stellen angegeben werden. Intern wird dabei die Funktion lut_suche_bic() verwendet.

Die Funktion arbeitet nur für deutsche Banken, da für andere keine Infos vorliegen.

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:¶ ↑

• -146 (INVALID_PARAMETER_TYPE) “Falscher Parametertyp für die Funktion”

• -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”

• -74 (NO_GERMAN_BIC) “Ein Konto kann kann nur für deutsche Banken geprüft werden”

• 0 (FALSE) “falsch”

• 1 (OK) “ok”

static VALUE bic_check_rb(VALUE self,VALUE bic_v)
{
   char bic[12];
   int retval,cnt;

   if(TYPE(bic_v)!=RUBY_T_STRING)return INT2FIX(INVALID_PARAMETER_TYPE);
   strncpy(bic,RSTRING_PTR(bic_v),11);
   *(bic+11)=0;
   retval=bic_check(bic,&cnt);
   return rb_ary_new3(2,INT2FIX(retval),INT2FIX(cnt));
}

::bic_info( bic [,mode [,filiale]])¶ ↑

KontoCheck::bic_info( bic [,mode [,filiale]])¶ ↑

Diese Funktion sucht Banken mit einem bestimmten BIC und gibt die gefundene Anzahl sowie den Startindex in den internen Arrays zurück. Sie ist für die Funktionsgruppe biq_* gedacht, falls mehrere Werte aus der BLZ-Datei bestimmt werden sollen (z.B. verschiedene Felder oder Werte für mehrere Zweigstellen einer Bank). So erspart man sich die relativ aufwendige Suche; sie ist nur einmal notwendig.

Parameter:

* bic:  BIC zu dem die Banken bestimmt werden sollen (komplett oder teilweise)
* mode: Suchmodus; er kann die folgenden Werte annehmen:
        mode=1: Suche in allen BICs der BLZ-Datei (Haupt- und Nebenstellen)
        mode=2: Suche nur in den BICs der Hauptstellen
        mode=0: zunächst Suche bei den Hauptstellen, dann bei Haupt- und Nebenstellen;
                falls dann noch nichts gefunden wurde, werden die drei letzten Stellen
                (Filialcode) mit XXX gefüllt und noch einmal eine Suche gemacht.

Zurückgegeben wird ein Array mit drei Elementen: Das erste ist der Startindex in den internen Arrays (zur Verwendung in der Funktionsgruppe biq_*()), das zweite die Anzahl der gefundenen BICs und das dritte ein Statuscode. Der Startindex kann sowohl positiv als auch negativ sein; im Fehlerfall wird nil zurückgegeben. Daher sollte in jedem Fall der Statuscode und die zurückgegebee Anzahl gefundener Banken kontrolliert werden.

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”

• -46 LUT2_BIC_NOT_INITIALIZED “Das Feld BIC wurde nicht initialisiert”

• -40 LUT2_NOT_INITIALIZED “die Programmbibliothek wurde noch nicht initialisiert”

• -10 FILE_READ_ERROR “kann Datei nicht lesen”

• -9 ERROR_MALLOC “kann keinen Speicher allokieren”

• 1 OK “ok”

• 26 OK_SHORT_BIC_USED “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_info_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[24],error_msg[512];
   int retval,cnt,mode,start_idx;

   get_params_bic(argc,argv,bic,&mode,NULL,2);
   retval=bic_info(bic,mode,&cnt,&start_idx);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(3,retval<0?Qnil:INT2FIX(start_idx),INT2FIX(cnt),INT2FIX(retval));
}

::bic_loeschung( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_loeschung( bic [,mode [,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 Elementen: im ersten steht das Flag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -42 (LUT2_LOESCHUNG_NOT_INITIALIZED) “Das Feld Löschung wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_loeschung_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   int retval,loeschung,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   loeschung=bic_loeschung(bic,mode,filiale,&retval)-'0';
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(loeschung),INT2FIX(retval));
}

::bic_nachfolge_blz( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_nachfolge_blz( bic [,mode [,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 zwei Elementen: im ersten steht die Nachfolge-BLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die Nachfolge-BLZ nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -41 (LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED) “Das Feld Nachfolge-BLZ wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_nachfolge_blz_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   int retval,n_blz,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   n_blz=bic_nachfolge_blz(bic,mode,filiale,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(n_blz),INT2FIX(retval));
}

::bic_name( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_name( bic [,mode [,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 zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -51 (LUT2_NAME_NOT_INITIALIZED) “Das Feld Bankname wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_name_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   const char *name;
   int retval,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   name=bic_name(bic,mode,filiale,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

::bic_name_kurz( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_name_kurz( bic [,mode [,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 zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -48 (LUT2_NAME_KURZ_NOT_INITIALIZED) “Das Feld Kurzname wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_name_kurz_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   const char *name;
   int retval,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   name=bic_name_kurz(bic,mode,filiale,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

::bic_nr( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_nr( bic [,mode [,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 Vollständigkeit halber enthalten. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Nummer, im zweiten ein Statuscode. Im Fehlerfall wird für die Nummer nil zurückgegeben.

Mögliche Statuscodes:

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -44 (LUT2_NR_NOT_INITIALIZED) “Das Feld NR wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_nr_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   int retval,nr,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   nr=bic_nr(bic,mode,filiale,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(nr),INT2FIX(retval));
}

::bic_ort( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_ort( bic [,mode [,filiale]])¶ ↑

Diese Funktion liefert den Ort einer Bank. Falls der Parameter filiale nicht angegeben ist, wird der Sitz der Hauptstelle ausgegeben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im zweiten ein Statuscode. Im Fehlerfall wird für den Ort nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -49 (LUT2_ORT_NOT_INITIALIZED) “Das Feld Ort wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_ort_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   const char *ort;
   int retval,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   ort=bic_ort(bic,mode,filiale,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ort),INT2FIX(retval));
}

::bic_pan( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_pan( bic [,mode [,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 zweiten ein Statuscode. Im Fehlerfall wird für den PAN nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -47 (LUT2_PAN_NOT_INITIALIZED) “Das Feld PAN wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_pan_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   int retval,pan,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   pan=bic_pan(bic,mode,filiale,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pan),INT2FIX(retval));
}

::bic_plz( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_plz( bic [,mode [,filiale]])¶ ↑

Diese Funktion liefert die Postleitzahl einer Bank. Falls der Parameter filiale nicht angegeben ist, wird die PLZ der Hauptstelle ausgegeben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die PLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die PLZ nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -50 (LUT2_PLZ_NOT_INITIALIZED) “Das Feld PLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_plz_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   int retval,plz,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   plz=bic_plz(bic,mode,filiale,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(plz),INT2FIX(retval));
}

::bic_pz( bic [,mode [,filiale]])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::bic_pz( bic [,mode [,filiale]])¶ ↑

Diese Funktion liefert die Prüfziffer einer Bank. Die Funktion unterstützt keine Filialen; zu jeder bic kann es in der LUT-Datei nur eine Prüfziffermethode geben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Prüfziffer, im zweiten ein Statuscode. Im Fehlerfall wird für den Prüfziffer nil zurückgegeben.

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”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -45 (LUT2_PZ_NOT_INITIALIZED) “Das Feld Prüfziffer wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE bic_pz_rb(int argc,VALUE* argv,VALUE self)
{
   char bic[16],error_msg[512];
   int retval,pz,filiale,mode;

   get_params_bic(argc,argv,bic,&mode,&filiale,0);
   pz=bic_pz(bic,mode,filiale,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pz),INT2FIX(retval));
}

::biq_aenderung( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_aenderung( idx)¶ ↑

Diese Funktion liefert das 'Änderung' Flag einer Bank (als string). Mögliche Werte sind: A (Addition), M (Modified), U (Unchanged), D (Deletion). Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Änderungsflag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -43 (LUT2_AENDERUNG_NOT_INITIALIZED) “Das Feld Änderung wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_aenderung_rb(int argc,VALUE* argv,VALUE self)
{
   char aenderung[2],error_msg[512];
   int retval,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   *aenderung=biq_aenderung(idx,&retval);
   aenderung[1]=0;
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(aenderung),INT2FIX(retval));
}

::biq_bic( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_bic( idx)¶ ↑

Diese Funktion liefert den BIC (Bank Identifier Code) einer Bank. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem BIC, im zweiten ein Statuscode. Im Fehlerfall wird für den BIC nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_bic_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   const char *ptr;
   int retval,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   ptr=biq_bic(idx,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ptr),INT2FIX(retval));
}

::biq_loeschung( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_loeschung( idx)¶ ↑

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 Elementen: im ersten steht das Flag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -42 (LUT2_LOESCHUNG_NOT_INITIALIZED) “Das Feld Löschung wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_loeschung_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   int retval,loeschung,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   loeschung=biq_loeschung(idx,&retval)-'0';
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(loeschung),INT2FIX(retval));
}

::biq_nachfolge_blz( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_nachfolge_blz( idx)¶ ↑

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 zwei Elementen: im ersten steht die Nachfolge-BLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die Nachfolge-BLZ nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -41 (LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED) “Das Feld Nachfolge-BLZ wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_nachfolge_blz_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   int retval,n_blz,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   n_blz=biq_nachfolge_blz(idx,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(n_blz),INT2FIX(retval));
}

::biq_name( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_name( idx)¶ ↑

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 zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -51 (LUT2_NAME_NOT_INITIALIZED) “Das Feld Bankname wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_name_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   const char *name;
   int retval,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   name=biq_name(idx,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

::biq_name_kurz( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_name_kurz( idx)¶ ↑

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 zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -48 (LUT2_NAME_KURZ_NOT_INITIALIZED) “Das Feld Kurzname wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_name_kurz_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   const char *name;
   int retval,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   name=biq_name_kurz(idx,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

::biq_nr( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_nr( idx)¶ ↑

Diese Funktion liefert die laufende Nummer einer Bank (internes Feld der BLZ-Datei). Der Wert wird wahrscheinlich nicht oft benötigt, ist aber der Vollständigkeit halber enthalten. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Nummer, im zweiten ein Statuscode. Im Fehlerfall wird für die Nummer nil zurückgegeben.

Mögliche Statuscodes:

Possible return values (and short description):

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -44 (LUT2_NR_NOT_INITIALIZED) “Das Feld NR wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_nr_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   int retval,nr,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   nr=biq_nr(idx,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(nr),INT2FIX(retval));
}

::biq_ort( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_ort( idx)¶ ↑

Diese Funktion liefert den Ort einer Bank. Falls der Parameter filiale nicht angegeben ist, wird der Sitz der Hauptstelle ausgegeben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im zweiten ein Statuscode. Im Fehlerfall wird für den Ort nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -49 (LUT2_ORT_NOT_INITIALIZED) “Das Feld Ort wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_ort_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   const char *ort;
   int retval,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   ort=biq_ort(idx,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ort),INT2FIX(retval));
}

::biq_pan( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_pan( idx)¶ ↑

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 zweiten ein Statuscode. Im Fehlerfall wird für den PAN nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -47 (LUT2_PAN_NOT_INITIALIZED) “Das Feld PAN wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_pan_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   int retval,pan,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   pan=biq_pan(idx,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pan),INT2FIX(retval));
}

::biq_plz( idx)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_plz( idx)¶ ↑

Diese Funktion liefert die Postleitzahl einer Bank. Falls der Parameter filiale nicht angegeben ist, wird die PLZ der Hauptstelle ausgegeben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die PLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die PLZ nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -50 (LUT2_PLZ_NOT_INITIALIZED) “Das Feld PLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_plz_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   int retval,plz,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   plz=biq_plz(idx,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(plz),INT2FIX(retval));
}

::biq_pz( bic)¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::biq_pz( bic)¶ ↑

Diese Funktion liefert die Prüfziffer einer Bank. Die Funktion unterstützt keine Filialen; zu jeder bic kann es in der LUT-Datei nur eine Prüfziffermethode geben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Prüfziffer, im zweiten ein Statuscode. Im Fehlerfall wird für den Prüfziffer nil zurückgegeben.

Mögliche Statuscodes:

• -70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -45 (LUT2_PZ_NOT_INITIALIZED) “Das Feld Prüfziffer wurde nicht initialisiert”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• -9 (ERROR_MALLOC) “kann keinen Speicher allokieren”

• 1 (OK) “ok”

• 26 (OK_SHORT_BIC_USED) “ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt”

static VALUE biq_pz_rb(int argc,VALUE* argv,VALUE self)
{
   char error_msg[512];
   int retval,pz,idx;

   get_params_bic(argc,argv,NULL,&idx,NULL,1);
   pz=biq_pz(idx,&retval);
   if(retval<0 && retval!=KEY_NOT_FOUND)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pz),INT2FIX(retval));
}

::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:¶ ↑

• -146 (INVALID_PARAMETER_TYPE) “Falscher Parametertyp für die Funktion”

• 0 (FALSE) “falsch”

• 1 (OK) “ok”

static VALUE ci_check_rb(VALUE self,VALUE ci_v)
{
   char ci[36];

   if(TYPE(ci_v)!=RUBY_T_STRING)return INT2FIX(INVALID_PARAMETER_TYPE);
   strncpy(ci,RSTRING_PTR(ci_v),35);
   *(ci+35)=0;
   return INT2FIX(ci_check(ci));
}

::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.

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.

Mögliche Statuscodes:¶ ↑

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• 1 (OK) “ok”

static VALUE current_lutfile_name_rb(VALUE self)
{
   const char *lut_filename;
   int set,level,retval;
   VALUE lut_filename_rb;

   if(!(lut_filename=current_lutfile_name(&set,&level,&retval)))
      lut_filename_rb=Qnil;
   else
      lut_filename_rb=rb_str_new2(lut_filename);
   return rb_ary_new3(4,lut_filename_rb,INT2FIX(set),INT2FIX(level),INT2FIX(retval));
}

::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 Statuscodes:¶ ↑

• -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) “die notwendige Kompressions-Bibliothek wurde 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)
{
   char lut_name[FILENAME_MAX+1],*ptr;
   int retval;
   VALUE dump;

   get_params_file(argc,argv,lut_name,NULL,NULL,2);
   retval=lut_dir_dump_str(lut_name,&ptr);
   if(retval<=0)
      dump=Qnil;
   else
      dump=rb_str_new2(ptr);
   kc_free(ptr);  /* die C-Funktion allokiert Speicher, der muß wieder freigegeben werden */
   return rb_ary_new3(2,dump,INT2FIX(retval));
}

::encoding( [mode])¶ ↑

KontoCheck.encoding( [mode])¶ ↑

::encoding_str( [mode])¶ ↑

::keep_raw_data( mode)¶ ↑

Diese Funktion legt den benutzten Zeichensatz für Fehlermeldungen durch die Funktion ::retval2txt und einige Felder der LUT-Datei (Name, Kurzname, Ort) fest. Wenn die Funktion nicht aufgerufen wird, wird der Wert DEFAULT_ENCODING aus konto_check.h benutzt.

Achtung: Das Verhalten der Funktion hängt von dem Flag ::keep_raw_data der C-Bibliothek ab. Falls das Flag gesetzt ist, werden die Rohdaten der Blocks Name, Kurzname und Ort im Speicher gehalten; bei einem Wechsel der Kodierung wird auch für diese Blocks die Kodierung umgesetzt. Falls das Flag nicht 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 ::keep_raw_data kann das Flag gesetzt gelöscht und abgefragt werden.

Aufruf:¶ ↑

::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”;

static VALUE encoding_rb(int argc,VALUE* argv,VALUE self)
{
   return INT2FIX(kto_check_encoding(enc_mode(argc,argv)));
}

::encoding_str( mode)¶ ↑

KontoCheck.encoding_str( mode)¶ ↑

::encoding( mode)¶ ↑

::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.

Aufruf:¶ ↑

::encoding_str( [mode])

Parameter:¶ ↑

wie bei ::encoding

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)
{
   return rb_str_new2((kto_check_encoding_str(enc_mode(argc,argv))));
}

::free¶ ↑

KontoCheck.free¶ ↑

Diese Funktion gibt allen allokierten Speicher wieder frei. Der Rückgabewert ist immer true.

static VALUE free_rb(VALUE self)
{
   lut_cleanup();
   return Qtrue;
}

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

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)

• gueltigkeit: Gültigkeit des Datensatzes im Format JJJJMMTT-JJJJMMTT. Diese Angabe wird benutzt, um festzustellen, ob ein Datensatz aktuell noch gültig ist.

• felder: (0-9) Welche Daten aufgenommmen 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

• 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. Bei 0 wird eine neue LUT-Datei generiert, bei 1 oder 2 wird der entsprechende Datensatz angehängt.

• iban_blacklist: Datei der Banken, die einer Selbstberechnung des IBAN nicht zugestimmt haben, bzw. von der IBAN-Berechnung ausgeschlossen werden sollen

Rückgabe:¶ ↑

Mögliche Statuscodes:¶ ↑

• -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) “die notwendige Kompressions-Bibliothek wurde 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)
{
   char input_name[FILENAME_MAX+1],output_name[FILENAME_MAX+1],iban_blacklist[FILENAME_MAX+1];
   char user_info[256],gueltigkeit[20],buffer[16],error_msg[512];
   int retval,felder,filialen,set,len;
   VALUE input_name_rb,output_name_rb,user_info_rb,
         gueltigkeit_rb,felder_rb,filialen_rb,set_rb,iban_blacklist_rb;

   rb_scan_args(argc,argv,"26",&input_name_rb,&output_name_rb,
         &user_info_rb,&gueltigkeit_rb,&felder_rb,&filialen_rb,&set_rb,&iban_blacklist_rb);

   if(TYPE(input_name_rb)==RUBY_T_STRING){
      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,"%s","Unable to convert given input filename.");

   if(TYPE(output_name_rb)==RUBY_T_STRING){
      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
      rb_raise(rb_eTypeError,"%s","Unable to convert given output filename.");

   if(NIL_P(user_info_rb)){
      *user_info=0;
   }
   else if(TYPE(user_info_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(user_info_rb))>255)len=255;
      strncpy(user_info,RSTRING_PTR(user_info_rb),len);
      *(user_info+len)=0;
   }
   else
      rb_raise(rb_eTypeError,"%s","Unable to convert given user_info string.");

   if(NIL_P(gueltigkeit_rb)){
      *gueltigkeit=0;
   }
   else if(TYPE(gueltigkeit_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(gueltigkeit_rb))>19)len=19;
      strncpy(gueltigkeit,RSTRING_PTR(gueltigkeit_rb),len);
      *(gueltigkeit+len)=0;
   }
   else
      rb_raise(rb_eTypeError,"%s","Unable to convert given gueltigkeit string.");

   if(NIL_P(felder_rb))
      felder=DEFAULT_LUT_FIELDS_NUM;
   else if(TYPE(felder_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(felder_rb))>15)len=15;
      strncpy(buffer,RSTRING_PTR(felder_rb),len);
      *(buffer+len)=0;
      felder=atoi(buffer);
   }
   else
      felder=NUM2INT(felder_rb);

   if(NIL_P(filialen_rb))
      filialen=0;
   else if(TYPE(filialen_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(felder_rb))>15)len=15;
      strncpy(buffer,RSTRING_PTR(filialen_rb),len);
      *(buffer+len)=0;
      filialen=atoi(buffer);
   }
   else
      filialen=NUM2INT(filialen_rb);

   if(NIL_P(set_rb))
      set=0;
   else if(TYPE(set_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(set_rb))>15)len=15;
      strncpy(buffer,RSTRING_PTR(set_rb),len);
      *(buffer+len)=0;
      set=atoi(buffer);
   }
   else
      set=NUM2INT(set_rb);

   if(NIL_P(iban_blacklist_rb)){
      *iban_blacklist=0;
   }
   else if(TYPE(iban_blacklist_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(iban_blacklist_rb))>FILENAME_MAX)len=FILENAME_MAX;
      strncpy(iban_blacklist,RSTRING_PTR(iban_blacklist_rb),len);
      *(iban_blacklist+len)=0;
   }
   else
      rb_raise(rb_eTypeError,"%s","Unable to convert given iban file name to string.");

   retval=generate_lut2_p(input_name,output_name,user_info,gueltigkeit,felder,filialen,0,0,set);
   if(retval<0)RUNTIME_ERROR(retval);
   if(*iban_blacklist)lut_keine_iban_berechnung(iban_blacklist,output_name,0);
   return INT2FIX(retval);
}

::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 SEPA-Verfahren (Single Euro Payments Area) benötigt; für die deutschen Banken ist er in der BLZ-Datei enthalten. Nähere Infos gibt es z.B. unter 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:¶ ↑

• -130 (IBAN_CHKSUM_OK_RULE_IGNORED “Die IBAN-Prüfsumme stimmt, es wurde allerdings eine IBAN-Regel nicht beachtet (wahrscheinlich falsch)”

• -124 (NO_IBAN_CALCULATION) “Für die Bankverbindung ist keine IBAN-Berechnung erlaubt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -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)
{
   char iban[128],blz[10],kto[16];
//   char error_msg[512];
   const char *bic;
   int retval;

   get_params(argc,argv,iban,NULL,NULL,NULL,3);
   bic=iban2bic(iban,&retval,blz,kto);
   return rb_ary_new3(4,!*bic?Qnil:rb_str_new2(bic),INT2FIX(retval),
         !*blz?Qnil:rb_str_new2(blz),!*kto?Qnil:rb_str_new2(kto));
}

::iban_aenderung( iban [,filiale])¶ ↑

KontoCheck::iban_aenderung( iban [,filiale])¶ ↑

Diese Funktion liefert das 'Änderung' Flag einer Bank (als string). Mögliche Werte sind: A (Addition), M (Modified), U (Unchanged), D (Deletion). Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Änderungsflag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -43 (LUT2_AENDERUNG_NOT_INITIALIZED) “Das Feld Änderung wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_aenderung_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],aenderung[2],error_msg[512];
   int retval,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   *aenderung=iban_aenderung(iban,filiale,&retval);
   aenderung[1]=0;
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_AENDERUNG_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(aenderung),INT2FIX(retval));
}

::iban_bic( iban [,filiale])¶ ↑

KontoCheck::iban_bic( iban [,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 mit dem BIC, im zweiten ein Statuscode. Im Fehlerfall wird für den BIC nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_bic_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   const char *ptr;
   int retval,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   ptr=iban_bic(iban,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_BIC_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ptr),INT2FIX(retval));
}

::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.

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)
{
   char iban[128];
   int retval,retval_kc;

   get_params(argc,argv,iban,NULL,NULL,NULL,3);
   retval=iban_check(iban,&retval_kc);
   return rb_ary_new3(2,INT2FIX(retval),INT2FIX(retval_kc));
}

::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 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 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],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_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=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));
}

::iban_loeschung( iban [,filiale])¶ ↑

KontoCheck::iban_loeschung( iban [,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 Elementen: im ersten steht das Flag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -42 (LUT2_LOESCHUNG_NOT_INITIALIZED) “Das Feld Löschung wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_loeschung_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   int retval,loeschung,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   loeschung=iban_loeschung(iban,filiale,&retval)-'0';
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_LOESCHUNG_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(loeschung),INT2FIX(retval));
}

KontoCheckRaw::iban_nachfolge_iban( iban [,filiale])¶ ↑

KontoCheck::iban_nachfolge_iban( iban [,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 zwei Elementen: im ersten steht die Nachfolge-BLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die Nachfolge-BLZ nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -41 (LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED) “Das Feld Nachfolge-BLZ wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_nachfolge_blz_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   int retval,n_iban,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   n_iban=iban_nachfolge_blz(iban,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(n_iban),INT2FIX(retval));
}

::iban_name( iban [,filiale])¶ ↑

::bic_info( bic [,mode])¶ ↑

KontoCheck::iban_name( iban [,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 zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -51 (LUT2_NAME_NOT_INITIALIZED) “Das Feld Bankname wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_name_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   const char *name;
   int retval,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,1);
   name=iban_name(iban,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NAME_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

::iban_name_kurz( iban [,filiale])¶ ↑

KontoCheck::iban_name_kurz( iban [,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 zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_name_kurz_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   const char *name;
   int retval,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   name=iban_name_kurz(iban,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NAME_KURZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

::iban_nr( iban [,filiale])¶ ↑

KontoCheck::iban_nr( iban [,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 Vollständigkeit halber enthalten. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Nummer, im zweiten ein Statuscode. Im Fehlerfall wird für die Nummer nil zurückgegeben.

Mögliche Statuscodes:

Possible return values (and short description):

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -44 (LUT2_NR_NOT_INITIALIZED) “Das Feld NR wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_nr_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   int retval,nr,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   nr=iban_nr(iban,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NR_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(nr),INT2FIX(retval));
}

::iban_ort( iban [,filiale])¶ ↑

KontoCheck::iban_ort( iban [,filiale])¶ ↑

Diese Funktion liefert den Ort einer Bank. Falls der Parameter filiale nicht angegeben ist, wird der Sitz der Hauptstelle ausgegeben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im zweiten ein Statuscode. Im Fehlerfall wird für den Ort nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -49 (LUT2_ORT_NOT_INITIALIZED) “Das Feld Ort wurde nicht initialisiert”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_ort_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   const char *ort;
   int retval,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   ort=iban_ort(iban,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_ORT_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ort),INT2FIX(retval));
}

::iban_pan( iban [,filiale])¶ ↑

KontoCheck::iban_pan( iban [,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 zweiten ein Statuscode. Im Fehlerfall wird für den PAN nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -47 (LUT2_PAN_NOT_INITIALIZED) “Das Feld PAN wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_pan_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   int retval,pan,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   pan=iban_pan(iban,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_PAN_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pan),INT2FIX(retval));
}

::iban_plz( iban [,filiale])¶ ↑

KontoCheck::iban_plz( iban [,filiale])¶ ↑

Diese Funktion liefert die Postleitzahl einer Bank. Falls der Parameter filiale nicht angegeben ist, wird die PLZ der Hauptstelle ausgegeben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die PLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die PLZ nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -50 (LUT2_PLZ_NOT_INITIALIZED) “Das Feld PLZ wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_plz_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   int retval,plz,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   plz=iban_plz(iban,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_PLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(plz),INT2FIX(retval));
}

::iban_pz( iban)¶ ↑

KontoCheck::iban_pz( iban)¶ ↑

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 Prüfziffermethode geben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Prüfziffer, im zweiten ein Statuscode. Im Fehlerfall wird für den Prüfziffer nil zurückgegeben.

Mögliche Statuscodes:

• -147 (IBAN_ONLY_GERMAN) “Es werden nur deutsche IBANs unterstützt”

• -121 (INVALID_IBAN_LENGTH) “Die Länge der IBAN für das angegebene Länderkürzel ist falsch”

• -55 (LUT2_INDEX_OUT_OF_RANGE) “Der Index für die Filiale ist ungültig”

• -53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”

• -45 (LUT2_PZ_NOT_INITIALIZED) “Das Feld Prüfziffer wurde nicht initialisiert”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

static VALUE iban_pz_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[64],error_msg[512];
   int retval,pz,filiale;

   get_params_bic(argc,argv,iban,&filiale,NULL,3);
   pz=iban_pz(iban,0,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_PZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pz),INT2FIX(retval));
}

::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.

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)

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.

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 wurde 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)
{
   char lut_name[FILENAME_MAX+1],error_msg[512];
   int retval,level,set;

   get_params_file(argc,argv,lut_name,&level,&set,1);
   retval=lut_init(lut_name,level,set);
   switch(retval){
      case OK:
      case LUT1_SET_LOADED:
      case LUT2_PARTIAL_OK:
         break;
      default:
         RUNTIME_ERROR(retval);
   }
   return INT2FIX(retval);
}

::ipi_check( zweck)¶ ↑

KontoCheck.ipi_check( zweck)¶ ↑

Die Funktion testet, ob ein Strukturierter Verwendungszweck gültig ist (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.

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)
{
   char zweck[128];

   get_params(argc,argv,zweck,NULL,NULL,NULL,3);
   return INT2FIX(ipi_check(zweck));
}

::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)
{
   char zweck[24],dst[24],papier[30];
   int retval;

   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),rb_str_new2(papier),INT2FIX(retval));
   else
      return rb_ary_new3(3,Qnil,Qnil,INT2FIX(retval));
}

::keep_raw_data( mode)¶ ↑

::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 und Ort im Speicher gehalten; bei einem Wechsel der Kodierung werden diese Blocks dann auch auf die neue Kodierung umgesetzt. Für die Speicherung der Blocks werden allerdings etwa 900 KB Hauptspeicher benötigt, die andernfalls wieder freigegeben würden.

Da diese Funktion etwas exotisch ist, ist sie nur in der KontoCheckRaw Bibliothek enthalten, nicht in KontoCheck.

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)
{
   int t,mode;

   if(NIL_P(mode_rb))
      mode=0;
   else if((t=TYPE(mode_rb))==RUBY_T_STRING)
      mode=*(RSTRING_PTR(mode_rb))-'0';
   else if(t==RUBY_T_FLOAT || t==RUBY_T_FIXNUM || t==RUBY_T_BIGNUM)
      mode=FIX2INT(mode_rb);
   else  /* nicht unterstützter Typ */
      mode=0;
   return keep_raw_data(mode)?Qtrue:Qfalse;
}

::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)
{
   char kto[16],blz[16],error_msg[512];
   int retval;

   get_params(argc,argv,blz,kto,NULL,NULL,2);
   if((*blz=='0' || strlen(blz)!=8) && lut_blz(kto+2,0)==OK)   /* BLZ/Kto vertauscht, altes Interface */
      rb_raise(rb_eRuntimeError,"%s","It seems that you use the old interface of konto_check?\n"
            "Please check the order of function arguments for konto_test(); should be (blz,kto)");
   if((retval=kto_check_blz(blz,kto))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
   return INT2FIX(retval);
}

::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.

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)
{
   char pz[16],blz[16],kto[16],error_msg[512];
   int retval;

   get_params(argc,argv,pz,kto,blz,NULL,5);
   if((retval=kto_check_pz(pz,kto,blz))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
   return INT2FIX(retval);
}

::konto_check_regel( blz, kto)¶ ↑

::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 wurde 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);
}

::konto_check_regel_dbg( blz, kto)¶ ↑

::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 wurde 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));
}

::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 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 Generierung der Indexblocks; mit Indexblocks macht es noch wesentlich mehr 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, Prüfziffermethoden, PLZ, Ort…) sind in der LUT-Datei in jeweils unabhängigen Blocks gespeichert und können einzeln geladen werden; die Bankdatei von der Deutschen Bundesbank enthält alle Felder in einem linearen 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 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)
{
   rb_raise(rb_eRuntimeError,"%s","Perhaps you used the old interface of konto_check.\n"
         "Use KontoCheck::init() to initialize the library\n"
         "and check the order of function arguments for konto_test(blz,kto)");
}

::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,"%s","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);
}

::lut_blocks1( )¶ ↑

::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",NULL);
   return INT2FIX(lut_blocks(0,NULL,NULL,NULL));
}

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

• 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 wurde 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)
{
   char lut_name[FILENAME_MAX+1],*info1,*info2,error_msg[512];
   int retval,valid1,valid2;
   VALUE info1_rb,info2_rb;

   get_params_file(argc,argv,lut_name,NULL,NULL,3);
   retval=lut_info(lut_name,&info1,&info2,&valid1,&valid2);
   if(!info1)
      info1_rb=Qnil;
   else
      info1_rb=rb_str_new2(info1);
   if(!info2)
      info2_rb=Qnil;
   else
      info2_rb=rb_str_new2(info2);
   kc_free(info1);  /* die C-Funktion allokiert Speicher, der muß wieder freigegeben werden */
   kc_free(info2);
   if(retval<0)RUNTIME_ERROR(retval);
   return rb_ary_new3(5,INT2FIX(retval),INT2FIX(valid1),INT2FIX(valid2),info1_rb,info2_rb);
}

::pz_aenderungen_enable( set)¶ ↑

KontoCheck.pz_aenderungen_enable( set)¶ ↑

Die Funktion ::pz_aenderungen_enable() dient dazu, den Status des Flags pz_aenderungen_aktivieren abzufragen bzw. zu setzen. Falls die Variable set 1 ist, werden die Änderungen aktiviert, falls sie 0 ist, werden die Änderungen deaktiviert. Beim Aufruf ohne Parameter oder mit einem anderen Wert wird das aktuelle Flag nicht verändert, sondern nur der Status zurückgegeben.

Parameter:¶ ↑

set: 0 oder 1: Änderungen deaktivieren/aktivieren

anderer Wert: nur Abfrage des Status

Rückgabe:¶ ↑

Rückgabe: aktueller Status des Flags

static VALUE pz_aenderungen_enable_rb(int argc,VALUE *argv,VALUE self)
{
   int mode;
   VALUE mode_rb=Qnil;

   rb_scan_args(argc,argv,"01",&mode_rb);
   if(mode_rb==Qnil)
      mode=-1;  /* Abfrage */
   else switch(TYPE(mode_rb)){
      case RUBY_T_FLOAT:
      case RUBY_T_FIXNUM:
      case RUBY_T_BIGNUM:
         mode=NUM2INT(mode_rb);
         break;
      default:
         rb_raise(rb_eTypeError,"%s","Unable to convert given value to int");
         break;
   }
   return INT2FIX(pz_aenderungen_enable(mode));
}

::rebuild_blzfile( inputfile,outputfile,set)¶ ↑

KontoCheck.rebuild_blzfile( inputfile,outputfile,set)¶ ↑

Die Funktion ::rebuild_blzfile() war ursprünglich als Härtetest für die LUT2-Routinen konzipiert: mit ihr lässt sich die BLZ-Datei komplett aus einer LUT-Datei neu generieren. Die Funktion ist allerdings auch so interessant, so daß sie in alle Ports eingebunden wurde. Die generierte BLZ-Datei sollte (bis auf die Sortierung und die vier Testbanken) keinen Unterschied zur originalen BLZ-Datei aufweisen.

Falls der Parameter set 1 oder 2 ist, wird als Eingabedatei eine LUT- datei erwartet; bei einem set-Parameter von 0 eine Klartextdatei (Bundesbankdatei).

Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>

Aufruf:¶ ↑

retval=KontoCheckRaw::rebuild_blzfile(inputname,outputname,set)

Parameter:¶ ↑

• inputfile: Eingabedatei (LUT-Datei oder Textdatei der Deutschen Bundesbank)

• outputfile: Name der Ausgabedatei

• set: (0, 1 oder 2)

  0: Die Eingabedatei ist eine Textdatei; es wird eine LUT-Datei generieret und diese wieder zurück umgewandlt.
  1. Das erste Set der LUT-Datei wird extrahiert
  2. Das zweite Set der LUT-Datei wird extrahiert

Rückgabe:¶ ↑

Rückgabe ist ein skalarer Statuscode, der die folgenden Werte annehmen kann:

Mögliche Statuscodes:¶ ↑

• -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) “die notwendige Kompressions-Bibliothek wurde beim Kompilieren nicht eingebunden”

• -64 (INIT_FATAL_ERROR) “Initialisierung fehlgeschlagen (init_wait geblockt)”

• -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)”

• -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”

• -32 (LUT2_COMPRESS_ERROR) “Fehler beim Komprimieren eines LUT-Blocks”

• -31 (LUT2_FILE_CORRUPTED) “Die LUT-Datei ist korrumpiert”

• -20 (LUT_CRC_ERROR) “Prüfsummenfehler in der blz.lut Datei”

• -15 (INVALID_BLZ_FILE) “Fehler in der blz.txt Datei (falsche Zeilenlänge)”

• -13 (FATAL_ERROR) “schwerer Fehler im Konto_check-Modul”

• -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”

• -6 (NO_LUT_FILE) “die blz.lut Datei wurde nicht gefunden”

• 1 (OK) “ok”

static VALUE rebuild_blzfile_rb(int argc,VALUE* argv,VALUE self)
{
   char input_name[FILENAME_MAX+1],output_name[FILENAME_MAX+1];
   char buffer[16];
   int retval,set,len;
   VALUE input_name_rb,output_name_rb,set_rb;

   rb_scan_args(argc,argv,"30",&input_name_rb,&output_name_rb,&set_rb);

   if(TYPE(input_name_rb)==RUBY_T_STRING){
      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,"%s","Unable to convert given input filename.");

   if(TYPE(output_name_rb)==RUBY_T_STRING){
      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
      rb_raise(rb_eTypeError,"%s","Unable to convert given output filename.");

   if(NIL_P(set_rb))
      set=1;
   else if(TYPE(set_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(set_rb))>15)len=15;
      strncpy(buffer,RSTRING_PTR(set_rb),len);
      *(buffer+len)=0;
      set=atoi(buffer);
   }
   else
      set=NUM2INT(set_rb);
   retval=rebuild_blzfile(input_name,output_name,set);
   return INT2FIX(retval);
}

::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)
{
   return rb_str_new2(kto_check_retval2dos(FIX2INT(retval)));
}

::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)
{
   return rb_str_new2(kto_check_retval2html(FIX2INT(retval)));
}

::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)
{
   return rb_str_new2(kto_check_retval2iso(FIX2INT(retval)));
}

::retval2txt( retval)¶ ↑

KontoCheck.retval2txt( retval)¶ ↑

Diese Funktion konvertiert einen numerischen Rückgabewert in einen String. Der benutzte Zeichensatz wird über die Funktion ::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)
{
   return rb_str_new2(kto_check_retval2txt(FIX2INT(retval)));
}

::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)
{
   return rb_str_new2(kto_check_retval2txt_short(FIX2INT(retval)));
}

::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)
{
   return rb_str_new2(kto_check_retval2utf8(FIX2INT(retval)));
}

::scl_b2b¶ ↑

KontoCheck.scl_b2b¶ ↑

::scl_b2b_blz¶ ↑

Diese Funktion bestimmt das Flag B2B (SEPA B2B Direct Debit, Sepa-Firmelastschrift) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zurück. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_b2b(bic)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit zwei Elementen:

• Das erste Element ist das Flag B2B aus dem SEPA-Directory

• Das zweite Element ist der Statuscode (s.u.)

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_b2b(int argc,VALUE* argv,VALUE self)
{
   char bic[12];
   int rv,retval;

   get_params_scl(argc,argv,bic,11);
   rv=lut_scl_b2b(bic,&retval);
   return rb_ary_new3(2,retval>0?INT2FIX(rv):Qnil,INT2FIX(retval));
}

::scl_b2b_blz¶ ↑

KontoCheck.scl_b2b_blz¶ ↑

::scl_b2b¶ ↑

Diese Funktion bestimmt das Flag B2B (SEPA B2B Direct Debit, Sepa-Firmelastschrift) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zurück. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_b2b_blz(blz)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit drei Elementen:

• Das erste Element ist das Flag B2B aus dem SEPA-Directory

• Das zweite Element ist der Statuscode (s.u.)

• Das dritte Element (nur bei ::scl_b2b_blz()) ist der benutzte BIC

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• -139 (LUT2_NOT_ALL_IBAN_BLOCKS_LOADED) “es konnten nicht alle Datenblocks die für die IBAN-Berechnung notwendig sind geladen werden”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_b2b_blz(int argc,VALUE* argv,VALUE self)
{
   char blz[12];
   const char *used_bic;
   int rv,retval;

   get_params_scl(argc,argv,blz,8);
   rv=lut_scl_b2b_blz(blz,&retval,&used_bic);
   if(retval>0)
      return rb_ary_new3(3,INT2FIX(rv),INT2FIX(retval),rb_str_new2(used_bic));
   else
      return rb_ary_new3(3,Qnil,INT2FIX(retval),Qnil);

}

::scl_cor1¶ ↑

KontoCheck.scl_cor1¶ ↑

KontoCheck.scl_cor1_blz¶ ↑

Diese Funktion bestimmt das Flag COR1 (SEPA COR1 Direct Debit (SEPA-Basislastschrift mit verkürzter Vorlagefrist) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zurück. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_cor1(bic)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit zwei Elementen:

• Das erste Element ist das Flag SDD aus dem SEPA-Directory

• Das zweite Element ist der Statuscode (s.u.)

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_cor1(int argc,VALUE* argv,VALUE self)
{
   char bic[12];
   int rv,retval;

   get_params_scl(argc,argv,bic,11);
   rv=lut_scl_cor1(bic,&retval);
   return rb_ary_new3(2,retval>0?INT2FIX(rv):Qnil,INT2FIX(retval));
}

::scl_cor1_blz¶ ↑

KontoCheck.scl_cor1¶ ↑

::scl_cor1¶ ↑

Diese Funktion bestimmt das Flag COR1 (SEPA COR1 Direct Debit (SEPA-Basislastschrift mit verkürzter Vorlagefrist) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zurück. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_cor1_blz(blz)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit drei Elementen:

• Das erste Element ist das Flag SDD aus dem SEPA-Directory

• Das zweite Element ist der Statuscode (s.u.)

• Das dritte Element (nur bei ::scl_cor1_blz()) ist der benutzte BIC

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• -139 (LUT2_NOT_ALL_IBAN_BLOCKS_LOADED) “es konnten nicht alle Datenblocks die für die IBAN-Berechnung notwendig sind geladen werden”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_cor1_blz(int argc,VALUE* argv,VALUE self)
{
   char blz[12];
   const char *used_bic;
   int rv,retval;

   get_params_scl(argc,argv,blz,8);
   rv=lut_scl_cor1_blz(blz,&retval,&used_bic);
   if(retval>0)
      return rb_ary_new3(3,INT2FIX(rv),INT2FIX(retval),rb_str_new2(used_bic));
   else
      return rb_ary_new3(3,Qnil,INT2FIX(retval),Qnil);
}

::scl_init([lutname})¶ ↑

KontoCheck.scl_init)¶ ↑

Mit den scl_* Funktionen können für einen gegebenen BIC oder eine BLZ die Einträge des SCL-Verzeichnisses bestimmt werden. Falls die _blz() Version der Funktionen verwendet wird, muß die Bibliothek mittels KontoCheck.init und KontoCheck.scl_init initialisiert werden, um sowohl die Kontodaten als auch die Daten des SCL-Verzeichnisses einzulesen.

Die Funktion ::scl_init liest die SCL-Blocks aus einer LUT-Datei und initialisiert die zugehörigen internen Datenstrukturen.initialisiert SCL-Datenstrukturen. Falls der Parameter lut_name nicht angegeben ist, wird die LUT-Datei benutzt, mit der die Bibliothek mittels KontoCheck.init initialisiert wurde.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_init()

Rückgabe:¶ ↑

Es wird ein skalarer Statuscode zurückgegeben, der Auskunft über die Initialisierung bzw. aufgetretene Fehler gibt.

Mögliche Statuscodes:¶ ↑

• -155 (INVALID_SCL_INFO_BLOCK) “(Ungültiger SCL-Info-Block in der LUT-Datei”

• -154 (NO_SCL_BLOCKS) “Ungültige Eingabewerte in der SCL-Datei”

• -40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”

• -10 (FILE_READ_ERROR) “kann Datei nicht lesen”

• 1 (OK) “ok”

static VALUE scl_init_rb(int argc,VALUE* argv,VALUE self)
{
   char lut_name[FILENAME_MAX+1];
   const char *l_name;
   int retval;

   get_params_file(argc,argv,lut_name,NULL,NULL,3);
   if(!*lut_name){
      l_name=current_lutfile_name(NULL,NULL,&retval);
      if(l_name && retval>0){
         strcpy(lut_name,l_name);
      }
      else
         return INT2FIX(retval);
   }
   retval=lut_scl_init(lut_name);
   return INT2FIX(retval);
}

::scl_multi¶ ↑

KontoCheck.scl_multi¶ ↑

Diese Funktion bestimmt alle Werte des BIC-Verzeichnisses zu einem gegebenen BIC. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_multi(bic)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit vier Elementen:

• Das erste Element ist der Statuscode (s.u.)

• Das zweite Element sind die SCL Flags (als String)

• das dritte Element ist der benutzte BIC

• das vierte Element ist der Institutsname aus dem BIC-Verzeichnis

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• -139 (LUT2_NOT_ALL_IBAN_BLOCKS_LOADED) “es konnten nicht alle Datenblocks die für die IBAN-Berechnung notwendig sind geladen werden”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_multi(int argc,VALUE* argv,VALUE self)
{
   char bic[12];
   const char *scl_flags,*used_bic,*scl_name;
   int retval;

   get_params_scl(argc,argv,bic,11);
   retval=lut_scl_multi(bic,&scl_flags,&used_bic,&scl_name);
   if(retval>0)
      return rb_ary_new3(4,INT2FIX(retval),rb_str_new2(scl_flags),rb_str_new2(used_bic),rb_str_new2(scl_name));
   else
      return rb_ary_new3(4,INT2FIX(retval),Qnil,Qnil,Qnil);
}

KontoCheckRaw::scl_scc(bic)¶ ↑

KontoCheck.scl_scc¶ ↑

::scl_scc_blz¶ ↑

Diese Funktion bestimmt das Flag SCC (SEPA Card Clearing, SCC Karteneinzüge) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zurück. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_scc(bic)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit zwei Elementen:

• Das erste Element ist das Flag SDD aus dem SEPA-Directory

• Das zweite Element ist der Statuscode (s.u.)

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_scc(int argc,VALUE* argv,VALUE self)
{
   char bic[12];
   int rv,retval;

   get_params_scl(argc,argv,bic,11);
   rv=lut_scl_scc(bic,&retval);
   return rb_ary_new3(2,retval>0?INT2FIX(rv):Qnil,INT2FIX(retval));
}

::scl_sct¶ ↑

KontoCheck.scl_sct¶ ↑

::scl_sct_blz¶ ↑

Diese Funktion bestimmt das Flag SCT (SEPA Credit Transfer) des SCL- Verzeichnisses und gibt das Flag (0 bzw. 1) zurück. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_sct(bic)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit zwei Elementen:

• Das erste Element ist das Flag SCT aus dem SEPA-Directory

• Das zweite Element ist der Statuscode (s.u.)

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_sct(int argc,VALUE* argv,VALUE self)
{
   char bic[12];
   int rv,retval;

   get_params_scl(argc,argv,bic,11);
   rv=lut_scl_sct(bic,&retval);
   return rb_ary_new3(2,retval>0?INT2FIX(rv):Qnil,INT2FIX(retval));
}

::scl_sct_blz¶ ↑

KontoCheck.scl_sct_blz¶ ↑

::scl_sct¶ ↑

Diese Funktion bestimmt das Flag SCT (SEPA Credit Transfer) des SCL- Verzeichnisses und gibt das Flag (0 bzw. 1) zurück. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_sct_blz(blz)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit drei Elementen:

• Das erste Element ist das Flag SCT aus dem SEPA-Directory

• Das zweite Element ist der Statuscode (s.u.)

• Das dritte Element ist der benutzte BIC

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• -139 (LUT2_NOT_ALL_IBAN_BLOCKS_LOADED) “es konnten nicht alle Datenblocks die für die IBAN-Berechnung notwendig sind geladen werden”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_sct_blz(int argc,VALUE* argv,VALUE self)
{
   char blz[12];
   const char *used_bic;
   int rv,retval;

   get_params_scl(argc,argv,blz,8);
   rv=lut_scl_sct_blz(blz,&retval,&used_bic);
   if(retval>0)
      return rb_ary_new3(3,INT2FIX(rv),INT2FIX(retval),rb_str_new2(used_bic));
   else
      return rb_ary_new3(3,Qnil,INT2FIX(retval),Qnil);
}

::scl_sdd¶ ↑

KontoCheck.scl_sdd¶ ↑

::scl_sdd_blz¶ ↑

Diese Funktion bestimmt das Flag SDD (SEPA CORE Direct Debit (SEPA-Basislastschrift) des SCL- Verzeichnisses und gibt das Flag (0 bzw. 1) zurück. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_sdd(bic)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit zwei Elementen:

• Das erste Element ist das Flag SDD aus dem SEPA-Directory

• Das zweite Element ist der Statuscode (s.u.)

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_sdd(int argc,VALUE* argv,VALUE self)
{
   char bic[12];
   int rv,retval;

   get_params_scl(argc,argv,bic,11);
   rv=lut_scl_sdd(bic,&retval);
   return rb_ary_new3(2,retval>0?INT2FIX(rv):Qnil,INT2FIX(retval));
}

::scl_sdd_blz¶ ↑

KontoCheck.scl_sdd¶ ↑

::scl_sdd¶ ↑

Diese Funktion bestimmt das Flag SDD (SEPA CORE Direct Debit (SEPA-Basislastschrift) des SCL- Verzeichnisses und gibt das Flag (0 bzw. 1) zurück. Im Fehlerfall wird nil zurückgegeben und die Variable retval auf den entsprechende Fehlercode (<0) gesetzt.

Aufruf:¶ ↑

• ret=KontoCheckRaw::scl_sdd_blz(blz)

Rückgabe:¶ ↑

Die Rückgabe ist ein Array mit drei Elementen:

• Das erste Element ist das Flag SDD aus dem SEPA-Directory

• Das zweite Element ist der Statuscode (s.u.)

• Das dritte Element (nur bei ::scl_sdd_blz()) ist der benutzte BIC

Mögliche Statuscodes:¶ ↑

• -158 (NO_SCL_BLOCKS_LOADED) “die SCL-Blocks wurden noch nicht eingelesen”

• -156 (SCL_BIC_NOT_FOUND) “Der BIC wurde im SCL-Verzeichnis nicht gefunden”

• -139 (LUT2_NOT_ALL_IBAN_BLOCKS_LOADED) “es konnten nicht alle Datenblocks die für die IBAN-Berechnung notwendig sind geladen werden”

• -5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”

• -4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”

• 1 (OK) “ok”

• 27 (OK_SCL_EXTENSION_BIC_USED) “ok, für den BIC wurde die Extension XXX angehängt”

• 28 (OK_SCL_WILDCARD_BIC_USED) “ok, für den BIC wurde die Wildcard-Version (8stellig) benutzt”

static VALUE scl_sdd_blz(int argc,VALUE* argv,VALUE self)
{
   char blz[12];
   const char *used_bic;
   int rv,retval;

   get_params_scl(argc,argv,blz,8);
   rv=lut_scl_sdd_blz(blz,&retval,&used_bic);
   if(retval>0)
      return rb_ary_new3(3,INT2FIX(rv),INT2FIX(retval),rb_str_new2(used_bic));
   else
      return rb_ary_new3(3,Qnil,INT2FIX(retval),Qnil);
}

::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)
{
   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));
}