konto_check 0.2.1 → 5.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,3 +1,7 @@
1
+ /* vim: ft=c:set si:set fileencoding=iso-8859-1
2
+ */
3
+ #line 9 "konto_check_h.lx"
4
+
1
5
  /*
2
6
  * ##########################################################################
3
7
  * # Dies ist konto_check, ein Programm zum Testen der Pr�fziffern #
@@ -45,11 +49,65 @@
45
49
 
46
50
  /*
47
51
  * ##########################################################################
48
- * # Die Berechnungsmethoden B6 und D1 werden zum 5.9.11 ge�ndert; mit dem #
49
- * # folgenden Makro werden die neuen Berechnungsmethoden aktiviert. #
52
+ * # Hier eine Info der Flessabank zur IBAN-Berechnung (abgerufen 13.6.12 #
53
+ * # von http://www.flessabank.de/aktuell.php?akt=149) #
54
+ * # #
55
+ * # Aktuelles Bankleitzahl/BIC #
56
+ * # #
57
+ * # Im Rahmen eines umfassenden Konsolidierungsprojekts der Deutschen #
58
+ * # Bundesbank und der Europ�ischen Zentralbank werden immer mehr Filialen #
59
+ * # der Deutschen Bundesbank geschlossen. Dabei wird auch die aktuelle #
60
+ * # Bankleitzahlenlogik f�r die Deutsche Bundesbank �berarbeitet. #
61
+ * # #
62
+ * # Um als FLESSABANK dieser ver�nderten Situation gerecht zu werden, #
63
+ * # haben wir uns entschlossen, unsere Bankleitzahlenstruktur zu #
64
+ * # vereinfachen und auf die zentrale Bankleitzahl 793 301 11 umzustellen. #
65
+ * # Ihre Kontonummern bleiben dabei unver�ndert g�ltig! #
66
+ * # #
67
+ * # Betroffen sind hiervon folgende Bankleitzahlen: #
68
+ * # 700 301 11 (Niederlassung M�nchen) #
69
+ * # 763 301 11 (Niederlassung Erlangen) #
70
+ * # 770 301 11 (Niederlassung Bamberg) #
71
+ * # 783 301 11 (Niederlassung Coburg) #
72
+ * # 840 301 11 (Niederlassung Meiningen) #
73
+ * # #
74
+ * # F�r die Bereiche Internet-Banking und girocard ist bereits heute nur #
75
+ * # die Bankleitzahl 793 301 11 g�ltig. Auch Ihre IBAN (International Bank #
76
+ * # Account Number = Internationale Kontonummer) wird ausschlie�lich mit #
77
+ * # der Bankleitzahl 793 301 11 erstellt. Wir teilen Ihnen diese zusammen #
78
+ * # mit unserem BIC (Bank Identifier Code = Bankkennung) auf jedem #
79
+ * # Kontoauszug mit. #
80
+ * # #
81
+ * # Update zur Flessa-Bank (abgerufen 28.10.13): Die obigen Bankleitzahlen #
82
+ * # haben in der aktuellen BLZ-Datei das L�schflag gesetzt und als #
83
+ * # Nachfolge-BLZ die 79330111 eingetragen. Damit er�brigt sich die #
84
+ * # Korrektur f�r die Flessa-Bank. #
50
85
  * ##########################################################################
51
86
  */
52
- #define METHODE_NEU_2011_09_05 1
87
+
88
+ #define FLESSA_KORREKTUR 0
89
+
90
+ /* IBAN-Regeln benutzen (g�ltig ab 3.6.2013) */
91
+ #define USE_IBAN_RULES 1
92
+
93
+ /* �nderungen der Pr�fziffermethoden zum 9. September 2013 erzwingen
94
+ * (bei 0 werden sie abh�ngig vom Datum aktiviert).
95
+ */
96
+ #define FORCE_AENDERUNGEN_2013_09 0
97
+
98
+ /* die neue Version der Regel 20 wird zum 9. Dezember in den offiziellen IBAN-Regeln ver�ffentlicht;
99
+ * die Bundesbank hat jedoch schon die Regelversion am 28. August ver�ffentlicht, mit der Bitte, sie
100
+ * m�glichst schon zum 9. September einzusetzen. Durch die neue Regelversion werden die F�lle mit dem
101
+ * R�ckgabewert IBAN_AMBIGUOUS_KTO komplett eliminiert.
102
+ */
103
+
104
+ #define DB_NEUE_VERSION 1 /* bei 1: neue Version der DB-Regel benutzen */
105
+
106
+ /* Debug-Version f�r iban_gen in Perl aktivieren (zur Ausgabe der benutzten
107
+ * Pr�fziffermethode in iban_gen()). Dies ist nur m�glich, falls das Makro
108
+ * DEBUG auf 1 gesetzt ist.
109
+ */
110
+ #define PERL_IBAN_DBG 1
53
111
 
54
112
  /* Das Makro DEFAULT_ENCODING legt die Ausgabe-Kodierung f�r die Funktion
55
113
  * kto_check_retval2txt() und die Blocks Name, Kurzname und Ort aus der
@@ -77,9 +135,16 @@
77
135
  * # unterschiedliche Interpretationen der Berechnungsmethoden existieren. #
78
136
  * ##########################################################################
79
137
  */
138
+ #define BAV_ENABLE 0
139
+
140
+ #if BAV_ENABLE==1
80
141
  #ifndef BAV_KOMPATIBEL
81
142
  #define BAV_KOMPATIBEL 0
82
143
  #endif
144
+ #else
145
+ #undef BAV_KOMPATIBEL
146
+ #define BAV_KOMPATIBEL 0
147
+ #endif
83
148
 
84
149
  /*
85
150
  * ##########################################################################
@@ -173,6 +238,19 @@
173
238
  # define DLL_EXPORT_V
174
239
  #endif
175
240
 
241
+ /*
242
+ * ######################################################################
243
+ * # AWK_ADD_MICROTIME: AWK-Funktionalit�t mit Mikrosekunden-Aufl�sung #
244
+ * # Falls das folgende Makro auf 1 gesetzt wird, wird im awk-Port die #
245
+ * # Funktion microtime() definiert, die - anders als systime() - mit #
246
+ * # hoher Aufl�sung (Mikrosekunden) arbeitet. Parameter etc. finden #
247
+ * # sich in konto_check_awk.c. Standardm��ig ist die Funktion nicht #
248
+ * # aktiviert. #
249
+ * ######################################################################
250
+ */
251
+ #define AWK_ADD_MICROTIME 1
252
+
253
+
176
254
  /*
177
255
  * ######################################################################
178
256
  * # Defaultnamen und Suchpfad f�r die LUT-Datei #
@@ -188,7 +266,7 @@
188
266
  #endif
189
267
 
190
268
  /* maximale L�nge f�r Default-Suchpfad und Dateiname der LUT-Datei */
191
- #define LUT_PATH_LEN 128
269
+ #define LUT_PATH_LEN 512
192
270
 
193
271
  /*
194
272
  * ######################################################################
@@ -196,10 +274,10 @@
196
274
  * ######################################################################
197
275
  */
198
276
 
199
- #define DEFAULT_LUT_FIELDS_NUM 5
200
- #define DEFAULT_LUT_FIELDS lut_set_5
277
+ #define DEFAULT_LUT_FIELDS_NUM 9
278
+ #define DEFAULT_LUT_FIELDS lut_set_9
201
279
  #define DEFAULT_LUT_VERSION 3
202
- #define DEFAULT_SLOTS 40
280
+ #define DEFAULT_SLOTS 60
203
281
  #define DEFAULT_INIT_LEVEL 5
204
282
  #define LAST_LUT_BLOCK 100
205
283
 
@@ -246,6 +324,10 @@
246
324
  #define LUT2_PLZ_SORT 20
247
325
  #define LUT2_PZ_SORT 21
248
326
  #define LUT2_OWN_IBAN 22
327
+ #define LUT2_VOLLTEXT_TXT 23
328
+ #define LUT2_VOLLTEXT_IDX 24
329
+ #define LUT2_IBAN_REGEL 25
330
+ #define LUT2_IBAN_REGEL_SORT 26
249
331
 
250
332
  #define LUT2_2_BLZ 101
251
333
  #define LUT2_2_FILIALEN 102
@@ -269,6 +351,10 @@
269
351
  #define LUT2_2_PLZ_SORT 120
270
352
  #define LUT2_2_PZ_SORT 121
271
353
  #define LUT2_2_OWN_IBAN 122
354
+ #define LUT2_2_VOLLTEXT_TXT 123
355
+ #define LUT2_2_VOLLTEXT_IDX 124
356
+ #define LUT2_2_IBAN_REGEL 125
357
+ #define LUT2_2_IBAN_REGEL_SORT 126
272
358
 
273
359
  #define LUT2_DEFAULT 501
274
360
 
@@ -285,10 +371,42 @@ extern const char *lut2_feld_namen[256];
285
371
  */
286
372
 
287
373
  #undef FALSE
374
+ #define BIC_ONLY_GERMAN -145
375
+ #define INVALID_BIC_LENGTH -144
376
+ #define IBAN_CHKSUM_OK_RULE_IGNORED_BLZ -143
377
+ #define IBAN_CHKSUM_OK_KC_NOT_INITIALIZED -142
378
+ #define IBAN_CHKSUM_OK_BLZ_INVALID -141
379
+ #define IBAN_CHKSUM_OK_NACHFOLGE_BLZ_DEFINED -140
380
+ #define LUT2_NOT_ALL_IBAN_BLOCKS_LOADED -139
381
+ #define LUT2_NOT_YET_VALID_PARTIAL_OK -138
382
+ #define LUT2_NO_LONGER_VALID_PARTIAL_OK -137
383
+ #define LUT2_BLOCKS_MISSING -136
384
+ #define FALSE_UNTERKONTO_ATTACHED -135
385
+ #define BLZ_BLACKLISTED -134
386
+ #define BLZ_MARKED_AS_DELETED -133
387
+ #define IBAN_CHKSUM_OK_SOMETHING_WRONG -132
388
+ #define IBAN_CHKSUM_OK_NO_IBAN_CALCULATION -131
389
+ #define IBAN_CHKSUM_OK_RULE_IGNORED -130
390
+ #define IBAN_CHKSUM_OK_UNTERKTO_MISSING -129
391
+ #define IBAN_INVALID_RULE -128
392
+ #define IBAN_AMBIGUOUS_KTO -127
393
+ #define IBAN_RULE_NOT_IMPLEMENTED -126
394
+ #define IBAN_RULE_UNKNOWN -125
395
+ #define NO_IBAN_CALCULATION -124
396
+ #define OLD_BLZ_OK_NEW_NOT -123
397
+ #define LUT2_IBAN_REGEL_NOT_INITIALIZED -122
398
+ #define INVALID_IBAN_LENGTH -121
399
+ #define LUT2_NO_ACCOUNT_GIVEN -120
400
+ #define LUT2_VOLLTEXT_INVALID_CHAR -119
401
+ #define LUT2_VOLLTEXT_SINGLE_WORD_ONLY -118
402
+ #define LUT_SUCHE_INVALID_RSC -117
403
+ #define LUT_SUCHE_INVALID_CMD -116
404
+ #define LUT_SUCHE_INVALID_CNT -115
405
+ #define LUT2_VOLLTEXT_NOT_INITIALIZED -114
288
406
  #define NO_OWN_IBAN_CALCULATION -113
289
407
  #define KTO_CHECK_UNSUPPORTED_COMPRESSION -112
290
408
  #define KTO_CHECK_INVALID_COMPRESSION_LIB -111
291
- #define OK_UNTERKONTO_ATTACHED -110
409
+ #define OK_UNTERKONTO_ATTACHED_OLD -110
292
410
  #define KTO_CHECK_DEFAULT_BLOCK_INVALID -109
293
411
  #define KTO_CHECK_DEFAULT_BLOCK_FULL -108
294
412
  #define KTO_CHECK_NO_DEFAULT_BLOCK -107
@@ -412,6 +530,19 @@ extern const char *lut2_feld_namen[256];
412
530
  #define OK_UNTERKONTO_POSSIBLE 11
413
531
  #define OK_UNTERKONTO_GIVEN 12
414
532
  #define OK_SLOT_CNT_MIN_USED 13
533
+ #define SOME_KEYS_NOT_FOUND 14
534
+ #define LUT2_KTO_NOT_CHECKED 15
535
+ #define LUT2_OK_WITHOUT_IBAN_RULES 16
536
+ #define OK_NACHFOLGE_BLZ_USED 17
537
+ #define OK_KTO_REPLACED 18
538
+ #define OK_BLZ_REPLACED 19
539
+ #define OK_BLZ_KTO_REPLACED 20
540
+ #define OK_IBAN_WITHOUT_KC_TEST 21
541
+ #define OK_INVALID_FOR_IBAN 22
542
+ #define OK_HYPO_REQUIRES_KTO 23
543
+ #define OK_KTO_REPLACED_NO_PZ 24
544
+ #define OK_UNTERKONTO_ATTACHED 25
545
+ #line 321 "konto_check_h.lx"
415
546
 
416
547
  #define MAX_BLZ_CNT 30000 /* maximale Anzahl BLZ's in generate_lut() */
417
548
 
@@ -487,8 +618,8 @@ typedef struct{
487
618
  * # Dieser Parameter gibt an, wieviele Slots das Inhaltsverzeichnis einer #
488
619
  * # LUT-Datei mindestens haben soll. F�r jeden Block in der LUT-Datei wird #
489
620
  * # ein Slot im Inhaltsverzeichnis ben�tigt; bei einer LUT-Datei mit allen #
490
- * # Eintr�gen (Level 9) sind das 19 Slots, falls zwei Datens�tze in der #
491
- * # Datei gehalten werden sollen, 38 (inklusive Indexblocks). #
621
+ * # Eintr�gen (Level 9) sind das 23 Slots, falls zwei Datens�tze in der #
622
+ * # Datei gehalten werden sollen, 46 (inklusive Indexblocks). #
492
623
  * # #
493
624
  * # Das Slotverzeichnis ist eine relativ einfache Datenstruktur; es #
494
625
  * # enth�lt f�r jeden Slot nur drei 4 Byte-Integers (Typ, Offset und #
@@ -503,7 +634,7 @@ typedef struct{
503
634
  * # #
504
635
  * ##########################################################################
505
636
  */
506
- #define SLOT_CNT_MIN 40
637
+ #define SLOT_CNT_MIN 60
507
638
 
508
639
  /*
509
640
  * ##########################################################################
@@ -610,6 +741,39 @@ DLL_EXPORT int kto_check_pz(char *pz,char *kto,char *blz);
610
741
  DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals);
611
742
  #endif
612
743
 
744
+ /* ###########################################################################
745
+ * # Die Funktion kto_check_regel() entspricht der Funktion #
746
+ * # kto_check_blz(). Der einzige Unterschied ist, da� vor dem Test gepr�ft #
747
+ * # wird, ob f�r die BLZ/Konto-Kombination eine IBAN-Regel angewendet #
748
+ * # werden mu� (z.B. bei Spendenkonten etc.). U.U. wird die BLZ und/oder #
749
+ * # Kontonummer ersetzt und die Berechnung mit den modifizierten Werten #
750
+ * # gemacht. Die Werte f�r BLZ und Kontonummer werden nicht zur�ckgegeben; #
751
+ * # das kann mittels der Funktion kto_check_blz2() erfolgen. #
752
+ * # #
753
+ * # Die Funktion kto_check_regel_dbg() ist das Gegenst�ck zu #
754
+ * # kto_check_blz_dbg(); bei dieser Funktion werden zus�tzlich noch einige #
755
+ * # interne Werte zur�ckgegeben. Die beiden Variablen blz2 und kto2 #
756
+ * # m�ssen auf einen Speicherbereich von mindestens 9 bzw. 11 Byte zeigen; #
757
+ * # in diese Speicherbereiche werden die neue BLZ bzw. Kontonummer #
758
+ * # geschrieben. Praktischerweise sollten dies lokale Variablen der #
759
+ * # aufrufenden Funktion sein. #
760
+ * # #
761
+ * # Parameter: #
762
+ * # blz: Bankleitzahl (immer 8-stellig) #
763
+ * # kto: Kontonummer #
764
+ * # blz2: benutzte BLZ (evl. durch die Regeln modifiziert) #
765
+ * # kto2: benutzte Kontonummer (evl. modifiziert) #
766
+ * # bic: BIC der benutzten Bank #
767
+ * # Regel: benutzte IBAN-Regel #
768
+ * # retvals: Struktur, in der die benutzte Pr�fziffermethode und die #
769
+ * # berechnete Pr�fziffer zur�ckgegeben werden #
770
+ * # #
771
+ * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de> #
772
+ * ###########################################################################
773
+ */
774
+ DLL_EXPORT int kto_check_regel(char *blz,char *kto);
775
+ DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,const char **bic,int *regel,RETVAL *retvals);
776
+
613
777
  /*
614
778
  * ######################################################################
615
779
  * # cleanup_kto(): Aufr�umarbeiten #
@@ -689,6 +853,7 @@ DLL_EXPORT int get_lut_info_t(char **info,char *lut_name,KTO_CHK_CTX *ctx);
689
853
  * ######################################################################
690
854
  */
691
855
  DLL_EXPORT const char *get_kto_check_version(void);
856
+ DLL_EXPORT const char *get_kto_check_version_x(int mode);
692
857
 
693
858
  /*
694
859
  * ######################################################################
@@ -791,16 +956,56 @@ DLL_EXPORT int lut_loeschung_i(int b,int zweigstelle,int *retval);
791
956
  DLL_EXPORT int lut_nachfolge_blz(char *b,int zweigstelle,int *retval);
792
957
  DLL_EXPORT int lut_nachfolge_blz_i(int b,int zweigstelle,int *retval);
793
958
  DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int set);
959
+ DLL_EXPORT int lut_iban_regel(char *b,int zweigstelle,int *retval);
960
+ DLL_EXPORT int lut_iban_regel_i(int b,int zweigstelle,int *retval);
961
+
962
+ /*
963
+ * ######################################################################
964
+ * # Suche von Banken nach verschiedenen Kriterien #
965
+ * ######################################################################
966
+ */
794
967
 
795
- /* Suche von BLZs */
796
- DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,char ***base_name,int **blz_base);
797
- DLL_EXPORT int lut_suche_namen(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,char ***base_name,int **blz_base);
798
- DLL_EXPORT int lut_suche_namen_kurz(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,char ***base_name,int **blz_base);
799
- DLL_EXPORT int lut_suche_ort(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,char ***base_name,int **blz_base);
800
- DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base);
801
- DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base);
802
- DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base);
968
+ #define LUT_SUCHE_VOLLTEXT 1
969
+ #define LUT_SUCHE_BIC 2
970
+ #define LUT_SUCHE_NAMEN 3
971
+ #define LUT_SUCHE_NAMEN_KURZ 4
972
+ #define LUT_SUCHE_ORT 5
973
+ #define LUT_SUCHE_BLZ 6
974
+ #define LUT_SUCHE_PLZ 7
975
+ #define LUT_SUCHE_PZ 8
976
+ #define LUT_SUCHE_REGEL 9
977
+
978
+ /* Defaultwert f�r sort/uniq bei Suchfunktionen (=> nur eine Zweigstelle
979
+ * zur�ckgeben) (betrifft nur PHP, Perl und Ruby, bei denen der Parameter
980
+ * weggelassen werden kann).
981
+ *
982
+ * F�r Perl gibt es eine eigene Definition, da sort und uniq bis einschlie�lich
983
+ * Version 4.1 nicht unterst�tzt wurden. Mit der Standarddefinition von
984
+ * UNIQ_DEFAULT (2) w�rde sich eine �nderung im Verhalten ergeben,
985
+ * die so nicht erw�nscht ist.
986
+ */
987
+ #define UNIQ_DEFAULT 2
988
+ #define UNIQ_DEFAULT_PERL 0
989
+
990
+ DLL_EXPORT int kto_check_idx2blz(int idx,int *zweigstelle,int *retval);
803
991
  DLL_EXPORT int konto_check_idx2blz(int idx,int *zweigstelle,int *retval);
992
+ DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,char ***base_name,int **blz_base);
993
+ DLL_EXPORT int lut_suche_namen(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,char ***base_name,int **blz_base);
994
+ DLL_EXPORT int lut_suche_namen_kurz(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,char ***base_name,int **blz_base);
995
+ DLL_EXPORT int lut_suche_ort(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,char ***base_name,int **blz_base);
996
+ DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base);
997
+ DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base);
998
+ DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base);
999
+ DLL_EXPORT int lut_suche_regel(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base);
1000
+ DLL_EXPORT int lut_suche_volltext(char *such_wort,int *anzahl,int *base_name_idx,char ***base_name,int *zweigstellen_anzahl,int **start_idx,int **zweigstellen_base,int **blz_base);
1001
+ DLL_EXPORT int lut_suche_multiple(char *such_worte,int uniq,char *such_cmd,UINT4 *anzahl,UINT4 **zweigstellen,UINT4 **blz);
1002
+ DLL_EXPORT int lut_suche_sort1(int anzahl,int *blz_base,int *zweigstellen_base,int *idx,int *anzahl_o,int **idx_op,int **cnt_o,int uniq);
1003
+ DLL_EXPORT int lut_suche_sort2(int anzahl,int *blz,int *zweigstellen,int *anzahl_o,int **blz_op,int **zweigstellen_op,int **cnt_o,int uniq);
1004
+ DLL_EXPORT int lut_suche_init(int uniq);
1005
+ DLL_EXPORT int lut_suche_free(int id);
1006
+ DLL_EXPORT int lut_suche_set(int such_id,int idx,int typ,int i1,int i2,char *txt);
1007
+ DLL_EXPORT int lut_suche(int such_id,char *such_cmd,UINT4 *such_cnt,UINT4 **filiale,UINT4 **blz);
1008
+ DLL_EXPORT int lut_blocks(int mode,char **lut_filename,char **lut_blocks_ok,char **lut_blocks_fehler);
804
1009
 
805
1010
  /* (Benutzerdefinierte) Default-Werte in der LUT-Datei lesen und schreiben */
806
1011
  #define DEFAULT_CNT 50 /* Anzahl Eintr�ge (fest) */
@@ -816,9 +1021,12 @@ DLL_EXPORT int kto_check_write_default(char *lutfile,int block_id);
816
1021
  DLL_EXPORT int lut_cleanup(void);
817
1022
 
818
1023
  /* IBAN-Sachen */
1024
+ DLL_EXPORT int ci_check(char *ci);
819
1025
  DLL_EXPORT int iban_check(char *iban,int *retval);
820
1026
  DLL_EXPORT const char *iban2bic(char *iban,int *retval,char *blz,char *kto);
821
1027
  DLL_EXPORT char *iban_gen(char *kto,char *blz,int *retval);
1028
+ DLL_EXPORT char *iban_bic_gen(char *blz,char *kto,const char **bicp,char *blz2,char *kto2,int *retval);
1029
+ DLL_EXPORT char *iban_bic_gen1(char *blz,char *kto,const char **bicp,int *retval);
822
1030
  DLL_EXPORT int ipi_gen(char *zweck,char *dst,char *papier);
823
1031
  DLL_EXPORT int ipi_check(char *zweck);
824
1032
 
@@ -848,6 +1056,9 @@ const DLL_EXPORT char *pz2str(int pz,int *ret);
848
1056
  DLL_EXPORT_V extern UINT4 current_date;
849
1057
  #endif
850
1058
 
1059
+ /* String mit den LUT-Blocks, die nicht geladen werden konnten */
1060
+ DLL_EXPORT_V extern char *lut_blocks_missing;
1061
+
851
1062
  /*
852
1063
  * ######################################################################
853
1064
  * # die folgenden globalen Variablen waren in Version 1 und 2 von #
@@ -1,12 +1,14 @@
1
+ /* encoding=utf-8
2
+ vim: ft=c:set si:set fileencoding=utf-8
3
+ */
4
+
1
5
  /*==================================================================
2
6
  *
3
7
  * KontoCheck Module, C Ruby Extension
4
8
  *
5
- * Copyright (c) 2010 Provideal Systems GmbH
6
- *
7
- * Peter Horn, peter.horn@provideal.net
8
- *
9
- * many extensions by Michael Plugge, m.plugge@hs-mannheim.de
9
+ * Copyright (c) 2010-2012 Peter Horn <peter.horn@provideal.net>,
10
+ * Jan Schwenzien <jan@schwenzien.org>
11
+ * Michael Plugge <m.plugge@hs-mannheim.de>
10
12
  *
11
13
  * ------------------------------------------------------------------
12
14
  *
@@ -41,6 +43,7 @@
41
43
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
42
44
  */
43
45
 
46
+ #line 54 "konto_check_raw_ruby.lxx"
44
47
  // Include the Ruby headers and goodies
45
48
  #include "ruby.h"
46
49
  #include <stdio.h>
@@ -68,6 +71,10 @@
68
71
  // Defining a space for information and references about the module to be stored internally
69
72
  VALUE KontoCheck = Qnil;
70
73
 
74
+ /* generische Suchfunktionen für alle einfachen Suchroutinen */
75
+ static VALUE bank_suche_int(int argc,VALUE* argv,VALUE self,int (*suchfkt)(char*,int*,int**,int**,char***,int**),
76
+ int (*suchfkt_i)(int,int,int*,int**,int**,int**,int**));
77
+
71
78
  /**
72
79
  * get_params_file()
73
80
  *
@@ -164,9 +171,9 @@ static void get_params_file(int argc,VALUE* argv,char *arg1s,int *arg1i,int *arg
164
171
  *arg1s=0;
165
172
  }
166
173
  else if(TYPE(v1_rb)==RUBY_T_STRING){
167
- strncpy(arg1s,RSTRING_PTR(v1_rb),FILENAME_MAX);
168
174
  /* der Ruby-String ist nicht notwendig null-terminiert; manuell erledigen */
169
175
  if((len=RSTRING_LEN(v1_rb))>FILENAME_MAX)len=FILENAME_MAX;
176
+ strncpy(arg1s,RSTRING_PTR(v1_rb),len);
170
177
  *(arg1s+len)=0;
171
178
  }
172
179
  else
@@ -178,13 +185,17 @@ static void get_params_file(int argc,VALUE* argv,char *arg1s,int *arg1i,int *arg
178
185
  *
179
186
  * extract two numeric params from argc/argv (for integer search functions)
180
187
  */
181
- static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2)
188
+
189
+ #define BUFLEN_GET_PARAMS 127
190
+ static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2,int *uniq_p)
182
191
  {
183
- char buffer[16];
184
- int len,cnt;
185
- VALUE arg1_rb,arg2_rb,*arr_ptr;
192
+ char *ptr,buffer[BUFLEN_GET_PARAMS+1];
193
+ int len,cnt,arg2_set,uniq,sort,tmp;
194
+ VALUE arg1_rb,arg2_rb,arg3_rb,arg4_rb,*arr_ptr;
186
195
 
187
- rb_scan_args(argc,argv,"11",&arg1_rb,&arg2_rb);
196
+ *arg1=*arg2=arg2_set=0;
197
+ uniq=sort=-1;
198
+ rb_scan_args(argc,argv,"13",&arg1_rb,&arg2_rb,&arg3_rb,&arg4_rb);
188
199
 
189
200
  /* Falls als erster Parameter ein Array übergeben wird, wird der erste
190
201
  * Wert werden als Minimal- und der zweite als Maximalwert genommen.
@@ -192,6 +203,8 @@ static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2)
192
203
  if(TYPE(arg1_rb)==RUBY_T_ARRAY){
193
204
  cnt=RARRAY_LEN(arg1_rb); /* Anzahl Werte */
194
205
  arr_ptr=RARRAY_PTR(arg1_rb); /* Pointer auf die Array-Daten */
206
+ arg3_rb=arg2_rb;
207
+ arg4_rb=arg3_rb;
195
208
  switch(cnt){
196
209
  case 0:
197
210
  arg1_rb=arg2_rb=Qnil;
@@ -208,27 +221,68 @@ static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2)
208
221
  }
209
222
 
210
223
  if(NIL_P(arg1_rb))
211
- *arg1=0;
224
+ *arg1=-1;
212
225
  else if(TYPE(arg1_rb)==RUBY_T_STRING){
213
- strncpy(buffer,RSTRING_PTR(arg1_rb),15);
214
226
  /* der Ruby-String ist nicht notwendig null-terminiert; manuell erledigen */
215
- if((len=RSTRING_LEN(arg1_rb))>15)len=15;
227
+ if((len=RSTRING_LEN(arg1_rb))>BUFLEN_GET_PARAMS)len=BUFLEN_GET_PARAMS;
228
+ strncpy(buffer,RSTRING_PTR(arg1_rb),len);
216
229
  *(buffer+len)=0;
217
230
  *arg1=atoi(buffer);
231
+ /* Bereichsangabe wert1-wert2 */
232
+ for(ptr=buffer;*ptr && *ptr!='-';ptr++);
233
+ if(*ptr=='-'){
234
+ *arg2=atoi(ptr+1);
235
+ arg2_set=1;
236
+ }
218
237
  }
219
238
  else
220
239
  *arg1=NUM2INT(arg1_rb);
221
240
 
222
- if(NIL_P(arg2_rb))
223
- *arg2=*arg1;
224
- else if(TYPE(arg2_rb)==RUBY_T_STRING){
225
- strncpy(buffer,RSTRING_PTR(arg2_rb),15);
226
- if((len=RSTRING_LEN(arg2_rb))>15)len=15;
227
- *(buffer+len)=0;
228
- *arg2=atoi(buffer);
241
+ if(!NIL_P(arg2_rb)){
242
+ if(TYPE(arg2_rb)==RUBY_T_STRING){
243
+ if((len=RSTRING_LEN(arg2_rb))>BUFLEN_GET_PARAMS)len=BUFLEN_GET_PARAMS;
244
+ strncpy(buffer,RSTRING_PTR(arg2_rb),len);
245
+ *(buffer+len)=0;
246
+ tmp=atoi(buffer);
247
+ if(!arg2_set)
248
+ *arg2=tmp;
249
+ else{ /* *arg2 wurde schon mit arg1 gesetzt; jetzt kommt uniq */
250
+ if(tmp>0)
251
+ uniq=2;
252
+ else if(tmp<=0)
253
+ uniq=0;
254
+ }
255
+ }
256
+ else{
257
+ if(!arg2_set)
258
+ *arg2=NUM2INT(arg2_rb);
259
+ else
260
+ uniq=NUM2INT(arg2_rb);
261
+ }
262
+ }
263
+
264
+ if(!NIL_P(arg3_rb)){
265
+ if(uniq<0){
266
+ if((tmp=NUM2INT(arg3_rb))>0)
267
+ uniq=2;
268
+ else if(tmp<=0)
269
+ uniq=0;
270
+ }
271
+ else
272
+ sort=NUM2INT(arg3_rb);
229
273
  }
274
+
275
+ if(!NIL_P(arg4_rb) && sort<0)sort=NUM2INT(arg4_rb); /* das kann nur noch sort sein */
276
+
277
+ if(uniq>0)
278
+ uniq=2;
279
+ else if(sort>0)
280
+ uniq=1;
281
+ else if(uniq<0 && sort<0)
282
+ uniq=UNIQ_DEFAULT;
230
283
  else
231
- *arg2=NUM2INT(arg2_rb);
284
+ uniq=0;
285
+ if(uniq_p)*uniq_p=uniq;
232
286
  }
233
287
 
234
288
  /**
@@ -238,8 +292,8 @@ static void get_params_int(int argc,VALUE* argv,int *arg1,int *arg2)
238
292
  */
239
293
  static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,int *argi,int arg_mode)
240
294
  {
241
- int len,maxlen=9;
242
- VALUE arg1_rb,arg2_rb,arg3_rb;
295
+ int len,maxlen=9,sort=-1,uniq=-1,tmp;
296
+ VALUE arg1_rb,arg2_rb,arg3_rb,arg4_rb;
243
297
 
244
298
  switch(arg_mode){
245
299
  case 0: /* ein notwendiger Parameter (für lut_filialen und lut_pz) */
@@ -258,7 +312,7 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
258
312
  rb_scan_args(argc,argv,"20",&arg1_rb,&arg2_rb);
259
313
  break;
260
314
 
261
- case 3: /* ein notwendiger Parameter (für iban_check) */
315
+ case 3: /* ein notwendiger Parameter (für iban_check und ci_check) */
262
316
  rb_scan_args(argc,argv,"10",&arg1_rb);
263
317
  maxlen=128;
264
318
  break;
@@ -272,14 +326,29 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
272
326
  rb_scan_args(argc,argv,"21",&arg1_rb,&arg2_rb,&arg3_rb);
273
327
  break;
274
328
 
329
+ case 6: /* ein notwendiger, zwei optionale Parameter (für bank_suche_multiple()) */
330
+ rb_scan_args(argc,argv,"12",&arg1_rb,&arg2_rb,&arg3_rb);
331
+ maxlen=1280;
332
+ break;
333
+
334
+ case 7: /* ein notwendiger, bis zu drei optionale Parameter (für die meisten Suchroutinen) */
335
+ rb_scan_args(argc,argv,"13",&arg1_rb,&arg2_rb,&arg3_rb,&arg4_rb);
336
+ maxlen=128;
337
+ break;
338
+ case 8: /* ein notwendiger Parameter (für bic_check) */
339
+ rb_scan_args(argc,argv,"10",&arg1_rb);
340
+ maxlen=11;
341
+ break;
342
+
343
+
275
344
  default:
276
345
  break;
277
346
  }
278
347
 
279
348
  switch(TYPE(arg1_rb)){
280
349
  case RUBY_T_STRING:
281
- strncpy(arg1s,RSTRING_PTR(arg1_rb),maxlen);
282
350
  if((len=RSTRING_LEN(arg1_rb))>maxlen)len=maxlen;
351
+ strncpy(arg1s,RSTRING_PTR(arg1_rb),len);
283
352
  *(arg1s+len)=0;
284
353
  break;
285
354
  case RUBY_T_FLOAT:
@@ -304,8 +373,8 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
304
373
  }
305
374
  if(arg_mode==2 || arg_mode==5)switch(TYPE(arg2_rb)){ /* für konto_check() und iban_gen(): kto holen */
306
375
  case RUBY_T_STRING:
307
- strncpy(arg2s,RSTRING_PTR(arg2_rb),15);
308
376
  if((len=RSTRING_LEN(arg2_rb))>15)len=15;
377
+ strncpy(arg2s,RSTRING_PTR(arg2_rb),len);
309
378
  *(arg2s+len)=0;
310
379
  break;
311
380
  case RUBY_T_FLOAT:
@@ -323,8 +392,8 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
323
392
  else
324
393
  switch(TYPE(arg3_rb)){
325
394
  case RUBY_T_STRING:
326
- strncpy(arg3s,RSTRING_PTR(arg3_rb),15);
327
395
  if((len=RSTRING_LEN(arg3_rb))>15)len=15;
396
+ strncpy(arg3s,RSTRING_PTR(arg3_rb),len);
328
397
  *(arg3s+len)=0;
329
398
  break;
330
399
  case RUBY_T_FLOAT:
@@ -337,33 +406,117 @@ static void get_params(int argc,VALUE* argv,char *arg1s,char *arg2s,char *arg3s,
337
406
  break;
338
407
  }
339
408
  }
409
+ if(arg_mode==6 || arg_mode==7){ /* für lut_suche(): uniq und such_cmd holen */
410
+ if(argi)*argi=-1; /* Flag für uniq: noch nicht gesetzt */
411
+ if(arg2s)*arg2s=0;
412
+ if(!NIL_P(arg2_rb))switch(TYPE(arg2_rb)){ /* uniq ist immer Integer, such_cmd immer String */
413
+ case RUBY_T_STRING:
414
+ if(arg2s){
415
+ if((len=RSTRING_LEN(arg2_rb))>255)len=255;
416
+ strncpy(arg2s,RSTRING_PTR(arg2_rb),len);
417
+ *(arg2s+len)=0;
418
+ }
419
+ break;
420
+ case RUBY_T_FLOAT:
421
+ case RUBY_T_FIXNUM:
422
+ case RUBY_T_BIGNUM:
423
+ tmp=NUM2INT(arg2_rb);
424
+ if(tmp>=0)uniq=tmp;
425
+ break;
426
+ default:
427
+ rb_raise(rb_eTypeError,"Unable to convert given variable to integer or string");
428
+ break;
429
+ }
430
+
431
+ if(!NIL_P(arg3_rb))switch(TYPE(arg3_rb)){ /* Parameter uniq oder such_cmd (je nach Typ) */
432
+ case RUBY_T_STRING: /* such_cmd */
433
+ if(arg2s){
434
+ if((len=RSTRING_LEN(arg3_rb))>255)len=255;
435
+ strncpy(arg2s,RSTRING_PTR(arg3_rb),len);
436
+ *(arg2s+len)=0;
437
+ }
438
+ break;
439
+ case RUBY_T_FLOAT:
440
+ case RUBY_T_FIXNUM:
441
+ case RUBY_T_BIGNUM:
442
+ tmp=NUM2INT(arg3_rb);
443
+ if(tmp>=0){
444
+ if(uniq<0)
445
+ uniq=tmp;
446
+ else
447
+ sort=tmp;
448
+ }
449
+ break;
450
+ default:
451
+ rb_raise(rb_eTypeError,"Unable to convert given variable to integer or string");
452
+ break;
453
+ }
454
+
455
+ if(!NIL_P(arg4_rb))switch(TYPE(arg4_rb)){ /* Parameter sort */
456
+ case RUBY_T_STRING:
457
+ break; /* String-Variable ignorieren; der Parameter muß numerisch sein!!! */
458
+ case RUBY_T_FLOAT:
459
+ case RUBY_T_FIXNUM:
460
+ case RUBY_T_BIGNUM:
461
+ tmp=NUM2INT(arg4_rb);
462
+ if(tmp>=0){
463
+ if(uniq<0)
464
+ uniq=tmp;
465
+ else
466
+ sort=tmp;
467
+ }
468
+ break;
469
+ default:
470
+ rb_raise(rb_eTypeError,"Unable to convert given variable to integer or string");
471
+ break;
472
+ }
473
+ if(uniq>0)
474
+ uniq=2;
475
+ else if(sort>0)
476
+ uniq=1;
477
+ else if(uniq<0 && sort<0)
478
+ uniq=UNIQ_DEFAULT;
479
+ else
480
+ uniq=0;
481
+ if(argi)*argi=uniq;
482
+ }
340
483
  }
341
484
 
342
485
  /**
343
- * ===<tt>KontoCheckRaw::konto_check_pz(pz,kto)</tt>
344
- * =====<tt>KontoCheck::konto_check_pz(pz,kto)</tt>
486
+ * ===KontoCheckRaw::konto_check_pz( pz, kto [,blz])
487
+ * =====KontoCheck::konto_check_pz( pz, kto [,blz])
345
488
  *
346
489
  * Diese Funktion testet, ob eine gegebene Prüfziffer/Kontonummer-Kombination gültig ist.
347
490
  *
348
- * Der zusätzliche Parameter blz ist nur für die Verfahren 52, 53, B6 und C0 notwendig; bei
349
- * diesen Verfahren geht die BLZ in die Berechnung der Prüfziffer ein. Bei allen anderen
350
- * Prüfzifferverfahren wird er ignoriert. Wird er bei einem dieser Verfahren nicht angegeben,
351
- * wird stattdessen eine Test-BLZ eingesetzt.
352
- *
353
- * Die Funktion gibt einen skalaren Statuswert zurück, der das Ergebnis der
354
- * Prüfung enthält. Mögliche Rückgabewerte sind:
355
- *
356
- * -77 (BAV_FALSE) "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
357
- * -69 (MISSING_PARAMETER) "bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
358
- * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
359
- * -29 (UNDEFINED_SUBMETHOD) "die (Unter)Methode ist nicht definiert"
360
- * -12 (INVALID_KTO_LENGTH) "ein Konto muß zwischen 1 und 10 Stellen haben"
361
- * -3 (INVALID_KTO) "das Konto ist ungültig"
362
- * -2 (NOT_IMPLEMENTED) "die Methode wurde noch nicht implementiert"
363
- * -1 (NOT_DEFINED) "die Methode ist nicht definiert"
364
- * 0 (FALSE) "falsch"
365
- * 1 (OK) "ok"
366
- * 2 (OK_NO_CHK) "ok, ohne Prüfung"
491
+ * ====Aufruf:
492
+ * ret=KontoCheckRaw::konto_check_pz( pz, kto [,blz])
493
+ *
494
+ * ====Parameter:
495
+ * * pz: Prüfzifferverfahren das benutzt werden soll
496
+ * * kto: Kontonummer die getestet werden soll
497
+ * * blz: Dieser Parameter ist nur für die Verfahren 52, 53, B6 und C0
498
+ * notwendig; bei allen anderen Prüfzifferverfahren wird er ignoriert. Bei
499
+ * diesen Verfahren geht die BLZ in die Berechnung der Prüfziffer ein.
500
+ * Wird der Parameter bei einem dieser Verfahren nicht angegeben, wird
501
+ * stattdessen eine Test-BLZ (wie in der Beschreibung der Prüfziffermethoden
502
+ * von der Deutschen Bundesbank angegeben) eingesetzt.
503
+ *
504
+ * ====Rückgabe:
505
+ * Die Funktion gibt einen skalaren Statuscode zurück, der das Ergebnis der
506
+ * Prüfung enthält.
507
+ *
508
+ * ====Mögliche Statuscodes:
509
+ * * -77 (BAV_FALSE) "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
510
+ * * -69 (MISSING_PARAMETER) "bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
511
+ * * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
512
+ * * -29 (UNDEFINED_SUBMETHOD) "die (Unter)Methode ist nicht definiert"
513
+ * * -12 (INVALID_KTO_LENGTH) "ein Konto muß zwischen 1 und 10 Stellen haben"
514
+ * * -3 (INVALID_KTO) "das Konto ist ungültig"
515
+ * * -2 (NOT_IMPLEMENTED) "die Methode wurde noch nicht implementiert"
516
+ * * -1 (NOT_DEFINED) "die Methode ist nicht definiert"
517
+ * * 0 (FALSE) "falsch"
518
+ * * 1 (OK) "ok"
519
+ * * 2 (OK_NO_CHK) "ok, ohne Prüfung"
367
520
  */
368
521
  static VALUE konto_check_pz(int argc,VALUE* argv,VALUE self)
369
522
  {
@@ -376,24 +529,34 @@ static VALUE konto_check_pz(int argc,VALUE* argv,VALUE self)
376
529
  }
377
530
 
378
531
  /**
379
- * ===<tt>KontoCheckRaw::konto_check(blz,kto)</tt>
380
- * =====<tt>KontoCheck::konto_check(blz,kto)</tt>
381
- * Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält. Die Funktion gibt einen skalaren
382
- * Statuswert zurück, der das Ergebnis der Prüfung enthält. Mögliche Rückgabewerte sind:
383
- *
384
- * -77 BAV_FALSE "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
385
- * -69 MISSING_PARAMETER "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
386
- * -40 LUT2_NOT_INITIALIZED "die Programmbibliothek wurde noch nicht initialisiert"
387
- * -29 UNDEFINED_SUBMETHOD "Die (Unter)Methode ist nicht definiert"
388
- * -12 INVALID_KTO_LENGTH "ein Konto muß zwischen 1 und 10 Stellen haben"
389
- * -5 INVALID_BLZ_LENGTH "die Bankleitzahl ist nicht achtstellig"
390
- * -4 INVALID_BLZ "die Bankleitzahl ist ungültig"
391
- * -3 INVALID_KTO "das Konto ist ungültig"
392
- * -2 NOT_IMPLEMENTED "die Methode wurde noch nicht implementiert"
393
- * -1 NOT_DEFINED "die Methode ist nicht definiert"
394
- * 0 FALSE "falsch"
395
- * 1 OK "ok"
396
- * 2 OK_NO_CHK "ok, ohne Prüfung"
532
+ * ===KontoCheckRaw::konto_check( blz, kto)
533
+ * =====KontoCheck::konto_check( blz, kto)
534
+ * Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.
535
+ *
536
+ * ====Aufruf:
537
+ * ret=KontoCheckRaw::konto_check( blz, kto)
538
+ *
539
+ * ====Parameter:
540
+ * * blz: Die Bankleitzahl der zu testenden Bankverbindung
541
+ * * kto: Die Kontonummer der zu testenden Bankverbindung
542
+ *
543
+ * ====Rückgabe:
544
+ * Rückgabe ist ein skalarer Statuswert, der das Ergebnis der Prüfung enthält.
545
+ *
546
+ * ====Mögliche Statuscodes:
547
+ * * -77 BAV_FALSE "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
548
+ * * -69 MISSING_PARAMETER "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
549
+ * * -40 LUT2_NOT_INITIALIZED "die Programmbibliothek wurde noch nicht initialisiert"
550
+ * * -29 UNDEFINED_SUBMETHOD "Die (Unter)Methode ist nicht definiert"
551
+ * * -12 INVALID_KTO_LENGTH "ein Konto muß zwischen 1 und 10 Stellen haben"
552
+ * * -5 INVALID_BLZ_LENGTH "die Bankleitzahl ist nicht achtstellig"
553
+ * * -4 INVALID_BLZ "die Bankleitzahl ist ungültig"
554
+ * * -3 INVALID_KTO "das Konto ist ungültig"
555
+ * * -2 NOT_IMPLEMENTED "die Methode wurde noch nicht implementiert"
556
+ * * -1 NOT_DEFINED "die Methode ist nicht definiert"
557
+ * * 0 FALSE "falsch"
558
+ * * 1 OK "ok"
559
+ * * 2 OK_NO_CHK "ok, ohne Prüfung"
397
560
  */
398
561
  static VALUE konto_check(int argc,VALUE* argv,VALUE self)
399
562
  {
@@ -409,79 +572,337 @@ static VALUE konto_check(int argc,VALUE* argv,VALUE self)
409
572
  }
410
573
 
411
574
  /**
412
- * ===<tt>KontoCheckRaw::init([<p1>[,<p2>[,<set>]]])</tt>
413
- * =====<tt>KontoCheck::init([<p1>[,<p2>[,<set>]]])</tt>
414
- * Die Variablen p1 und p2 stehen für level und lutfile (in beliebiger
415
- * Reihenfolge); die Zuordnung der beiden Parameter erfolgt on the fly durch
416
- * eine Typüberprüfung.
417
- *
575
+ * ===KontoCheckRaw::konto_check_regel( blz, kto)
576
+ * =====KontoCheckRaw::konto_check_regel_dbg( blz, kto)
577
+ * =====KontoCheck::konto_check_regel( blz, kto)
578
+ * =====KontoCheck::konto_check_regel?( blz, kto)
579
+ * Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.
580
+ * Vor der Prüfung werden die IBAN-Regeln angewendet; dabei wird u.U.
581
+ * BLZ und/oder Kontonummer ersetzt.
582
+ *
583
+ * ====Aufruf:
584
+ * ret=KontoCheckRaw::konto_check_regel( blz, kto)
585
+ *
586
+ * ====Parameter:
587
+ * * blz: Die Bankleitzahl der zu testenden Bankverbindung
588
+ * * kto: Die Kontonummer der zu testenden Bankverbindung
589
+ *
590
+ * ====Rückgabe:
591
+ * Rückgabe ist ein skalarer Statuswert, der das Ergebnis der Prüfung enthält.
592
+ * Es sind auch die Rückgabewerte der Initialisierung möglich (wegen iban_init()),
593
+ * deshalb gibt es so viele mögliche Rückgabewerte.
594
+ *
595
+ * ====Mögliche Statuscodes:
596
+ * * -135 FALSE_UNTERKONTO_ATTACHED "falsch, es wurde ein Unterkonto hinzugefügt (IBAN-Regel)"
597
+ * * -133 BLZ_MARKED_AS_DELETED "Die BLZ ist in der Bundesbank-Datei als gelöscht markiert und somit ungültig"
598
+ * * -128 IBAN_INVALID_RULE "Die BLZ passt nicht zur angegebenen IBAN-Regel"
599
+ * * -127 IBAN_AMBIGUOUS_KTO "Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten)"
600
+ * * -125 IBAN_RULE_UNKNOWN "Die IBAN-Regel ist nicht bekannt"
601
+ * * -124 NO_IBAN_CALCULATION "Für die Bankverbindung ist keine IBAN-Berechnung erlaubt"
602
+ * * -112 KTO_CHECK_UNSUPPORTED_COMPRESSION "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
603
+ * * -77 BAV_FALSE "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
604
+ * * -69 MISSING_PARAMETER "Für die aufgerufene Funktion fehlt ein notwendiger Parameter"
605
+ * * -64 INIT_FATAL_ERROR "Initialisierung fehlgeschlagen (init_wait geblockt)"
606
+ * * -63 INCREMENTAL_INIT_NEEDS_INFO "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
607
+ * * -62 INCREMENTAL_INIT_FROM_DIFFERENT_FILE "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
608
+ * * -40 LUT2_NOT_INITIALIZED "die Programmbibliothek wurde noch nicht initialisiert"
609
+ * * -38 LUT2_PARTIAL_OK "es wurden nicht alle Blocks geladen"
610
+ * * -36 LUT2_Z_MEM_ERROR "Memory error in den ZLIB-Routinen"
611
+ * * -35 LUT2_Z_DATA_ERROR "Datenfehler im komprimierten LUT-Block"
612
+ * * -34 LUT2_BLOCK_NOT_IN_FILE "Der Block ist nicht in der LUT-Datei enthalten"
613
+ * * -33 LUT2_DECOMPRESS_ERROR "Fehler beim Dekomprimieren eines LUT-Blocks"
614
+ * * -31 LUT2_FILE_CORRUPTED "Die LUT-Datei ist korrumpiert"
615
+ * * -29 UNDEFINED_SUBMETHOD "Die (Unter)Methode ist nicht definiert"
616
+ * * -20 LUT_CRC_ERROR "Prüfsummenfehler in der blz.lut Datei"
617
+ * * -12 INVALID_KTO_LENGTH "ein Konto muß zwischen 1 und 10 Stellen haben"
618
+ * * -10 FILE_READ_ERROR "kann Datei nicht lesen"
619
+ * * -9 ERROR_MALLOC "kann keinen Speicher allokieren"
620
+ * * -7 INVALID_LUT_FILE "die blz.lut Datei ist inkosistent/ungültig"
621
+ * * -6 NO_LUT_FILE "die blz.lut Datei wurde nicht gefunden"
622
+ * * -5 INVALID_BLZ_LENGTH "die Bankleitzahl ist nicht achtstellig"
623
+ * * -4 INVALID_BLZ "die Bankleitzahl ist ungültig"
624
+ * * -3 INVALID_KTO "das Konto ist ungültig"
625
+ * * -2 NOT_IMPLEMENTED "die Methode wurde noch nicht implementiert"
626
+ * * -1 NOT_DEFINED "die Methode ist nicht definiert"
627
+ * * 0 FALSE "falsch"
628
+ * * 1 OK "ok"
629
+ * * 1 OK "ok"
630
+ * * 2 OK_NO_CHK "ok, ohne Prüfung"
631
+ * * 6 LUT1_SET_LOADED "Die Datei ist im alten LUT-Format (1.0/1.1)"
632
+ * * 18 OK_KTO_REPLACED "ok, die Kontonummer wurde allerdings ersetzt"
633
+ * * 21 OK_IBAN_WITHOUT_KC_TEST "ok, die Bankverbindung ist (ohne Test) als richtig anzusehen"
634
+ * * 25 OK_UNTERKONTO_ATTACHED "ok, es wurde ein (weggelassenes) Unterkonto angefügt"
635
+ */
636
+ static VALUE konto_check_regel(int argc,VALUE* argv,VALUE self)
637
+ {
638
+ char kto[16],blz[16],error_msg[512];
639
+ int retval;
640
+
641
+ get_params(argc,argv,blz,kto,NULL,NULL,2);
642
+ if((retval=kto_check_regel(blz,kto))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
643
+ return INT2FIX(retval);
644
+ }
645
+
646
+ /**
647
+ * ===KontoCheckRaw::konto_check_regel_dbg( blz, kto)
648
+ * =====KontoCheckRaw::konto_check_regel( blz, kto)
649
+ * =====KontoCheck::konto_check_regel( blz, kto)
650
+ * =====KontoCheck::konto_check_regel?( blz, kto)
651
+ * Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.
652
+ * Vor der Prüfung werden die IBAN-Regeln angewendet; dabei wird u.U.
653
+ * BLZ und/oder Kontonummer ersetzt. Die Funktion gibt viele Interna
654
+ * zurück und ist daher nur in der KontoCheckRaw:: Bibliothek enthalten.
655
+ *
656
+ * ====Aufruf:
657
+ * ret=KontoCheckRaw::konto_check_regel_dbg( blz, kto)
658
+ *
659
+ * ====Parameter:
660
+ * * blz: Die Bankleitzahl der zu testenden Bankverbindung
661
+ * * kto: Die Kontonummer der zu testenden Bankverbindung
662
+ *
663
+ * ====Rückgabe:
664
+ * Rückgabe ist ein Array mit 10 Elementen, der das Ergebnis der Prüfung sowie eine Reihe
665
+ * interner Werte enthält. Für den Statuscode sind auch die Rückgabewerte der Initialisierung
666
+ * möglich (wegen iban_init()), deshalb gibt es so viele mögliche Werte.
667
+ * * das erste Element enthält den Statuscode
668
+ * * das zweite Element enthält die benutzte BLZ (die BLZ wird durch die IBAN-Regeln u.U. ersetzt)
669
+ * * das dritte Element enthält die benutzte Kontonummer (wird manchmal auch ersetzt)
670
+ * * das vierte Element enthält den BIC der Bank
671
+ * * das fünfte Element enthält die benutzte IBAN-Regel
672
+ * * das sechste Element enthält die Regel-Version
673
+ * * das siebte Element enthält Prüfziffermethode als Text
674
+ * * das achte Element enthält die Prüfziffermethode (numerisch)
675
+ * * das neunte Element enthält die Prüfziffer
676
+ * * das zehnte Element enthält die Position der Prüfziffer
677
+ *
678
+ * ====Mögliche Statuscodes:
679
+ * * -135 FALSE_UNTERKONTO_ATTACHED "falsch, es wurde ein Unterkonto hinzugefügt (IBAN-Regel)"
680
+ * * -133 BLZ_MARKED_AS_DELETED "Die BLZ ist in der Bundesbank-Datei als gelöscht markiert und somit ungültig"
681
+ * * -128 IBAN_INVALID_RULE "Die BLZ passt nicht zur angegebenen IBAN-Regel"
682
+ * * -127 IBAN_AMBIGUOUS_KTO "Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten)"
683
+ * * -125 IBAN_RULE_UNKNOWN "Die IBAN-Regel ist nicht bekannt"
684
+ * * -124 NO_IBAN_CALCULATION "Für die Bankverbindung ist keine IBAN-Berechnung erlaubt"
685
+ * * -112 KTO_CHECK_UNSUPPORTED_COMPRESSION "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
686
+ * * -77 BAV_FALSE "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
687
+ * * -69 MISSING_PARAMETER "Für die aufgerufene Funktion fehlt ein notwendiger Parameter"
688
+ * * -64 INIT_FATAL_ERROR "Initialisierung fehlgeschlagen (init_wait geblockt)"
689
+ * * -63 INCREMENTAL_INIT_NEEDS_INFO "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
690
+ * * -62 INCREMENTAL_INIT_FROM_DIFFERENT_FILE "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
691
+ * * -40 LUT2_NOT_INITIALIZED "die Programmbibliothek wurde noch nicht initialisiert"
692
+ * * -38 LUT2_PARTIAL_OK "es wurden nicht alle Blocks geladen"
693
+ * * -36 LUT2_Z_MEM_ERROR "Memory error in den ZLIB-Routinen"
694
+ * * -35 LUT2_Z_DATA_ERROR "Datenfehler im komprimierten LUT-Block"
695
+ * * -34 LUT2_BLOCK_NOT_IN_FILE "Der Block ist nicht in der LUT-Datei enthalten"
696
+ * * -33 LUT2_DECOMPRESS_ERROR "Fehler beim Dekomprimieren eines LUT-Blocks"
697
+ * * -31 LUT2_FILE_CORRUPTED "Die LUT-Datei ist korrumpiert"
698
+ * * -29 UNDEFINED_SUBMETHOD "Die (Unter)Methode ist nicht definiert"
699
+ * * -20 LUT_CRC_ERROR "Prüfsummenfehler in der blz.lut Datei"
700
+ * * -12 INVALID_KTO_LENGTH "ein Konto muß zwischen 1 und 10 Stellen haben"
701
+ * * -10 FILE_READ_ERROR "kann Datei nicht lesen"
702
+ * * -9 ERROR_MALLOC "kann keinen Speicher allokieren"
703
+ * * -7 INVALID_LUT_FILE "die blz.lut Datei ist inkosistent/ungültig"
704
+ * * -6 NO_LUT_FILE "die blz.lut Datei wurde nicht gefunden"
705
+ * * -5 INVALID_BLZ_LENGTH "die Bankleitzahl ist nicht achtstellig"
706
+ * * -4 INVALID_BLZ "die Bankleitzahl ist ungültig"
707
+ * * -3 INVALID_KTO "das Konto ist ungültig"
708
+ * * -2 NOT_IMPLEMENTED "die Methode wurde noch nicht implementiert"
709
+ * * -1 NOT_DEFINED "die Methode ist nicht definiert"
710
+ * * 0 FALSE "falsch"
711
+ * * 1 OK "ok"
712
+ * * 1 OK "ok"
713
+ * * 2 OK_NO_CHK "ok, ohne Prüfung"
714
+ * * 6 LUT1_SET_LOADED "Die Datei ist im alten LUT-Format (1.0/1.1)"
715
+ * * 18 OK_KTO_REPLACED "ok, die Kontonummer wurde allerdings ersetzt"
716
+ * * 21 OK_IBAN_WITHOUT_KC_TEST "ok, die Bankverbindung ist (ohne Test) als richtig anzusehen"
717
+ * * 25 OK_UNTERKONTO_ATTACHED "ok, es wurde ein (weggelassenes) Unterkonto angefügt"
718
+ */
719
+ static VALUE konto_check_regel_dbg(int argc,VALUE* argv,VALUE self)
720
+ {
721
+ char kto[16],blz[16],kto2[16],blz2[16],error_msg[512];
722
+ const char *bic2;
723
+ int retval,regel;
724
+ RETVAL rv;
725
+
726
+ get_params(argc,argv,blz,kto,NULL,NULL,2);
727
+ if((retval=kto_check_regel_dbg(blz,kto,blz2,kto2,&bic2,&regel,&rv))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
728
+ 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),
729
+ rv.methode?rb_str_new2(rv.methode):Qnil,INT2FIX(rv.pz_methode),INT2FIX(rv.pz),INT2FIX(rv.pz_pos));
730
+ }
731
+
732
+ /**
733
+ * ===KontoCheckRaw::lut_blocks( mode)
734
+ * =====KontoCheck::lut_blocks( mode)
735
+ * Die Funktion gibt Auskunft, ob bei der Initialisierung alle angeforderten
736
+ * Blocks der LUT-Datei geladen wurden und gibt den Dateinamen der LUT-Datei,
737
+ * eine Liste der geladenen Blocks sowie eine Liste der Blocks die nicht
738
+ * geladen werden konnten, zurück.
739
+ *
740
+ * ====Aufruf:
741
+ * ret=KontoCheckRaw::lut_blocks( mode)
742
+ *
743
+ * ====Parameter:
744
+ * * mode: Ausgabeformat (1..3)
745
+ *
746
+ * ====Rückgabe:
747
+ * Rückgabe ist ein Array mit vier Elementen, das den Statuscode sowie drei Strings
748
+ * mit dem Dateinamen sowie den Blocklisten enthält:
749
+ *
750
+ * * das erste Element enthält den Statuscode
751
+ * * das zweite Element enthält den Dateinamen der verwendeten LUT-Datei
752
+ * * das dritte Element enthält eine Liste der geladenen LUT-Blocks
753
+ * * das vierte Element enthält eine Liste der LUT-Blocks, die nicht geladen werden konnten
754
+ *
755
+ * ====Mögliche Statuscodes:
756
+ * * -136 LUT2_BLOCKS_MISSING "ok, bei der Initialisierung konnten allerdings ein oder mehrere Blocks nicht geladen werden"
757
+ * * -40 LUT2_NOT_INITIALIZED "die Programmbibliothek wurde noch nicht initialisiert"
758
+ * * -9 ERROR_MALLOC "kann keinen Speicher allokieren"
759
+ * * 1 OK "ok"
760
+ */
761
+ static VALUE lut_blocks_rb(int argc,VALUE* argv,VALUE self)
762
+ {
763
+ char *lut_filename,*lut_blocks_ok,*lut_blocks_fehler;
764
+ int mode,retval;
765
+ VALUE mode_rb,filename_rb,blocks_ok_rb,blocks_fehler_rb;
766
+
767
+ rb_scan_args(argc,argv,"01",&mode_rb);
768
+ if(NIL_P(mode_rb))
769
+ mode=1;
770
+ else{
771
+ switch(TYPE(mode_rb)){
772
+ case RUBY_T_FLOAT:
773
+ case RUBY_T_FIXNUM:
774
+ case RUBY_T_BIGNUM:
775
+ mode=NUM2INT(mode_rb);
776
+ break;
777
+ default:
778
+ mode=1;
779
+ rb_raise(rb_eTypeError,"lut_blocks() requires an int parameter");
780
+ break;
781
+ }
782
+ }
783
+
784
+ if((retval=lut_blocks(mode,&lut_filename,&lut_blocks_ok,&lut_blocks_fehler))==LUT2_NOT_INITIALIZED || retval==ERROR_MALLOC)
785
+ filename_rb=blocks_ok_rb=blocks_fehler_rb=Qnil;
786
+ else{
787
+ filename_rb=rb_str_new2(lut_filename);
788
+ blocks_ok_rb=rb_str_new2(lut_blocks_ok);
789
+ blocks_fehler_rb=rb_str_new2(lut_blocks_fehler);
790
+ kc_free(lut_filename);
791
+ kc_free(lut_blocks_ok);
792
+ kc_free(lut_blocks_fehler);
793
+ }
794
+ return rb_ary_new3(4,INT2FIX(retval),filename_rb,blocks_ok_rb,blocks_fehler_rb);
795
+ }
796
+
797
+ /**
798
+ * ===KontoCheckRaw::lut_blocks1( )
799
+ * =====KontoCheckRaw::lut_blocks( mode)
800
+ * =====KontoCheck::lut_blocks( )
801
+ * Diese Funktion entspricht weitgehend der Funktion lut_blocks(); sie
802
+ * gibt allerdings nur den Statuscode zurück, keine Strings. Sie wird
803
+ * für die Funktion KontoCheck::lut_blocks() benutzt.
804
+ *
805
+ * ====Parameter:
806
+ * * keine
807
+ *
808
+ * ====Rückgabe:
809
+ * Rückgabe ist ein Integerwert, der Aufschluß über den aktuellen Stand der Initialisierung gibt.
810
+ *
811
+ * ====Mögliche Statuscodes:
812
+ * * -136 LUT2_BLOCKS_MISSING "ok, bei der Initialisierung konnten allerdings ein oder mehrere Blocks nicht geladen werden"
813
+ * * -40 LUT2_NOT_INITIALIZED "die Programmbibliothek wurde noch nicht initialisiert"
814
+ * * -9 ERROR_MALLOC "kann keinen Speicher allokieren"
815
+ * * 1 OK "ok"
816
+ */
817
+ static VALUE lut_blocks1_rb(int argc,VALUE* argv,VALUE self)
818
+ {
819
+ rb_scan_args(argc,argv,"0");
820
+ return INT2FIX(lut_blocks(0,NULL,NULL,NULL));
821
+ }
822
+
823
+ /**
824
+ * ===KontoCheckRaw::init( [p1 [,p2 [,set]]])
825
+ * =====KontoCheck::init( [p1 [,p2 [,set]]])
418
826
  * Diese Funktion initialisiert die Bibliothek und lädt die gewünschten
419
827
  * Datenblocks in den Speicher. Alle Argumente sind optional; in konto_check.h
420
828
  * werden die Defaultwerte definiert.
421
829
  *
422
- * Die beiden ersten Parameter sind der Dateiname und der
423
- * Initialisierungslevel. Der Dateiname ist immer als String anzugeben, der
424
- * Initialisierungslevel immer als Zahl, ansonsten wird eine TypeError
425
- * Exception geworfen. Auf diese Weise ist es problemlos möglich festzustellen,
426
- * wie die Parameter p1 und p2 den Variablen lutfile und level zuzuordnen
427
- * sind.
830
+ * ====Aufruf:
831
+ * * ret=KontoCheckRaw::init( [p1 [,p2 [,set]]])
832
+ * =====Beispielsaufrufe:
833
+ * * ret=KontoCheckRaw::init
834
+ * * ret=KontoCheckRaw::init( 5)
835
+ * * ret=KontoCheckRaw::init( "/etc/blz.lut")
836
+ * * ret=KontoCheckRaw::init( 3,"/etc/blz.lut")
837
+ * * ret=KontoCheckRaw::init( "/etc/blz.lut",9,2)
838
+
839
+ * ====Parameter:
840
+ * * Die Variablen p1 und p2 stehen für den Initialisierungslevel und den
841
+ * Dateinamen der LUT-Datei (in beliebiger Reihenfolge); die Zuordnung der
842
+ * beiden Parameter erfolgt on the fly durch eine Typüberprüfung. Der Dateiname
843
+ * ist immer als String anzugeben, der Initialisierungslevel immer als Zahl,
844
+ * ansonsten gibt es eine TypeError Exception. Auf diese Weise ist es
845
+ * eindeutig möglich festzustellen, wie die Parameter p1 und p2 den Variablen
846
+ * lutfile und level zuzuordnen sind.
847
+ * * Der Initialisierungslevel ist eine Zahl zwischen 0 und 9, die die zu ladenden Blocks angibt. Die folgenden Werte sind definiert:
848
+ *
849
+ * 0. BLZ,PZ
850
+ * 1. BLZ,PZ,NAME_KURZ
851
+ * 2. BLZ,PZ,NAME_KURZ,BIC
852
+ * 3. BLZ,PZ,NAME,PLZ,ORT
853
+ * 4. BLZ,PZ,NAME,PLZ,ORT,BIC
854
+ * 5. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC
855
+ * 6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ
856
+ * 7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG
857
+ * 8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,
858
+ * LOESCHUNG
859
+ * 9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,
860
+ * LOESCHUNG,PAN,NR
861
+ * * Der Parameter set bezeichnet den zu ladenden Datensatz (1 oder 2) der LUT-Datei.
862
+ * Falls der Parameter set nicht angegeben oder 0 ist, wird versucht, das aktuell
863
+ * gültige Set aus dem Systemdatum und dem Gültigkeitszeitraum der in der
864
+ * LUT-Datei gespeicherten Sets zu bestimmen.
428
865
  *
429
866
  * Für die LUT-Datei ist als Defaultwert sowohl für den Pfad als auch den
430
867
  * Dateinamen eine Liste möglich, die sequenziell abgearbeitet wird; diese wird
431
868
  * in konto_check.h spezifiziert (Compilerzeit-Konstante der C-Bibliothek). Die
432
869
  * folgenden Werte sind in der aktuellen konto_check.h definiert:
433
870
  *
434
- * DEFAULT_LUT_NAME blz.lut, blz.lut2f, blz.lut2
435
- * DEFAULT_LUT_PATH ., /usr/local/etc/, /etc/, /usr/local/bin/, /opt/konto_check/ (für nicht-Windows-Systeme)
436
- * DEFAULT_LUT_PATH ., C:, C:\\Programme\\konto_check (für Windows-Systeme)
871
+ * * DEFAULT_LUT_NAME blz.lut; blz.lut2f; blz.lut2
872
+ * * DEFAULT_LUT_PATH ., /usr/local/etc/; /etc/; /usr/local/bin/; /opt/konto_check/ <i>(für nicht-Windows-Systeme)</i>
873
+ * * DEFAULT_LUT_PATH .; C:; C:\\Programme\\konto_check <i>(für Windows-Systeme)</i>
437
874
  *
438
875
  * Der Defaultwert für level ist ebenfalls in konto_check.h definiert; in der
439
876
  * aktuellen Version ist er 5. Bei diesem Level werden die Blocks BLZ,
440
877
  * Prüfziffer, Name, Kurzname, PLZ, Ort und BIC geladen.
441
878
  *
442
- * Falls der Parameter set nicht angegeben ist, wird versucht, das aktuell
443
- * gültige Set aus dem Systemdatum und dem Gültigkeitszeitraum der in der
444
- * LUT-Datei gespeicherten Sets zu bestimmen.
445
- *
446
- * Hier noch einmal ein Überblick über die Parameter:
447
- *
448
- * * lutfile: die LUT-Datei, mit der initialisiert werden soll
449
- * * level: (0-9) Welche Daten geladen werden sollen (PZ steht in der folgenden Tabelle für Prüfziffer, NAME_NAME_KURZ ist ein Block, der sowohl den Namen als auch den Kurznamen der Bank enthält; dieser läßt sich besser komprimieren als wenn beide Blocks getrennt sind):
450
- * 0. BLZ,PZ
451
- * 1. BLZ,PZ,NAME_KURZ
452
- * 2. BLZ,PZ,NAME_KURZ,BIC
453
- * 3. BLZ,PZ,NAME,PLZ,ORT
454
- * 4. BLZ,PZ,NAME,PLZ,ORT,BIC
455
- * 5. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC
456
- * 6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ
457
- * 7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG
458
- * 8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG
459
- * 9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG,PAN,NR
460
- * * set (1 oder 2): Datensatz
461
- *
462
- * Mögliche Rückgabewerte:
463
- *
464
- * -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
465
- * -64 (INIT_FATAL_ERROR) "Initialisierung fehlgeschlagen (init_wait geblockt)"
466
- * -63 (INCREMENTAL_INIT_NEEDS_INFO) "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
467
- * -62 (INCREMENTAL_INIT_FROM_DIFFERENT_FILE) "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
468
- * -38 (LUT2_PARTIAL_OK) "es wurden nicht alle Blocks geladen"
469
- * -36 (LUT2_Z_MEM_ERROR) "Memory error in den ZLIB-Routinen"
470
- * -35 (LUT2_Z_DATA_ERROR) "Datenfehler im komprimierten LUT-Block"
471
- * -34 (LUT2_BLOCK_NOT_IN_FILE) "Der Block ist nicht in der LUT-Datei enthalten"
472
- * -33 (LUT2_DECOMPRESS_ERROR) "Fehler beim Dekomprimieren eines LUT-Blocks"
473
- * -31 (LUT2_FILE_CORRUPTED) "Die LUT-Datei ist korrumpiert"
474
- * -20 (LUT_CRC_ERROR) "Prüfsummenfehler in der blz.lut Datei"
475
- * -10 (FILE_READ_ERROR) "kann Datei nicht lesen"
476
- * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
477
- * -7 (INVALID_LUT_FILE) "die blz.lut Datei ist inkosistent/ungültig"
478
- * -6 (NO_LUT_FILE) "die blz.lut Datei wurde nicht gefunden"
479
- *
480
- * 1 (OK) "ok"
481
- * 6 (LUT1_SET_LOADED) "Die Datei ist im alten LUT-Format (1.0/1.1)"
482
- *
483
- * Anmerkung: Falls der Statuscode LUT2_PARTIAL_OK ist, waren bei der
484
- * Initialisierung nicht alle Blocks in der LUT-Datei enthalten.
879
+ * ====Rückgabe:
880
+ * Es wird ein skalarer Statuscode zurückgegeben, der Auskunft über die Initialisierung bzw.
881
+ * aufgetretene Fehler gibt.
882
+ *
883
+ * ====Mögliche Statuscodes:
884
+ * * -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
885
+ * * -64 (INIT_FATAL_ERROR) "Initialisierung fehlgeschlagen (init_wait geblockt)"
886
+ * * -63 (INCREMENTAL_INIT_NEEDS_INFO) "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
887
+ * * -62 (INCREMENTAL_INIT_FROM_DIFFERENT_FILE) "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
888
+ * * -38 (LUT2_PARTIAL_OK) "es wurden nicht alle Blocks geladen"
889
+ * * -36 (LUT2_Z_MEM_ERROR) "Memory error in den ZLIB-Routinen"
890
+ * * -35 (LUT2_Z_DATA_ERROR) "Datenfehler im komprimierten LUT-Block"
891
+ * * -34 (LUT2_BLOCK_NOT_IN_FILE) "Der Block ist nicht in der LUT-Datei enthalten"
892
+ * * -33 (LUT2_DECOMPRESS_ERROR) "Fehler beim Dekomprimieren eines LUT-Blocks"
893
+ * * -31 (LUT2_FILE_CORRUPTED) "Die LUT-Datei ist korrumpiert"
894
+ * * -20 (LUT_CRC_ERROR) "Prüfsummenfehler in der blz.lut Datei"
895
+ * * -10 (FILE_READ_ERROR) "kann Datei nicht lesen"
896
+ * * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
897
+ * * -7 (INVALID_LUT_FILE) "die blz.lut Datei ist inkosistent/ungültig"
898
+ * * -6 (NO_LUT_FILE) "die blz.lut Datei wurde nicht gefunden"
899
+ * * 1 (OK) "ok"
900
+ * * 6 (LUT1_SET_LOADED) "Die Datei ist im alten LUT-Format (1.0/1.1)"
901
+ *
902
+ * ====Anmerkung:
903
+ * Falls der Statuscode LUT2_PARTIAL_OK ist, waren bei der Initialisierung
904
+ * nicht alle Blocks in der LUT-Datei enthalten; in vielen Situationen ist dies
905
+ * mehr eine Warnung, nicht ein Fehler.
485
906
  */
486
907
  static VALUE init(int argc,VALUE* argv,VALUE self)
487
908
  {
@@ -502,26 +923,32 @@ static VALUE init(int argc,VALUE* argv,VALUE self)
502
923
  }
503
924
 
504
925
  /**
505
- * ===<tt>KontoCheckRaw::current_lutfile_name()</tt>
506
- * =====<tt>KontoCheck::current_lutfile_name()</tt>
507
- * =====<tt>KontoCheck::current_lutfile_set()</tt>
508
- * =====<tt>KontoCheck::current_init_level()</tt>
926
+ * ===KontoCheckRaw::current_lutfile_name()
927
+ * =====KontoCheck::current_lutfile_name()
928
+ * =====KontoCheck::current_lutfile_set()
929
+ * =====KontoCheck::current_init_level()
509
930
  *
510
931
  * Diese Funktion bestimmt den Dateinamen der zur Initialisierung benutzen
511
932
  * LUT-Datei, das benutzte Set und den Initialisierungslevel der aktuellen
512
- * Initialisierung. Rückgabewert ist ein Array mit vier Elementen: das erste
513
- * ist der Dateiname der LUT-Datei, das zweite das benutzte Set (0, falls
514
- * nicht initialisiert wurde, sonst 1 oder 2), das dritte der
515
- * Initialisierungslevel und das vierte der Statuscode.
516
- *
517
- * Mögliche Statuscodes:
933
+ * Initialisierung.
934
+ *
935
+ * ====Aufruf:
936
+ * retval=KontoCheckRaw::current_lutfile_name
937
+ *
938
+ * ====Rückgabe:
939
+ * Rückgabewert ist ein Array mit vier Elementen: das erste ist der Dateiname
940
+ * der LUT-Datei, das zweite das benutzte Set (0, falls nicht initialisiert
941
+ * wurde, sonst 1 oder 2), das dritte der Initialisierungslevel und das vierte
942
+ * der Statuscode.
943
+ *
518
944
  *
519
- * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
520
- * 1 (OK) "ok"
945
+ * ====Mögliche Statuscodes:
946
+ * * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
947
+ * * 1 (OK) "ok"
521
948
  */
522
949
  static VALUE current_lutfile_name_rb(VALUE self)
523
950
  {
524
- char *lut_filename;
951
+ const char *lut_filename;
525
952
  int set,level,retval;
526
953
  VALUE lut_filename_rb;
527
954
 
@@ -533,8 +960,8 @@ static VALUE current_lutfile_name_rb(VALUE self)
533
960
  }
534
961
 
535
962
  /**
536
- * ===<tt>KontoCheckRaw::free()</tt>
537
- * =====<tt>KontoCheck::free()</tt>
963
+ * ===KontoCheckRaw::free()
964
+ * =====KontoCheck::free()
538
965
  *
539
966
  * Diese Funktion gibt allen allokierten Speicher wieder frei. Der Rückgabewert ist immer true.
540
967
  */
@@ -545,11 +972,15 @@ static VALUE free_rb(VALUE self)
545
972
  }
546
973
 
547
974
  /**
548
- * ===<tt>KontoCheckRaw::generate_lutfile(inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])</tt>
549
- * =====<tt>KontoCheck::generate_lutfile(inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])</tt>
975
+ * ===KontoCheckRaw::generate_lutfile( inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])
976
+ * =====KontoCheck::generate_lutfile( inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])
550
977
  *
551
978
  * Diese Funktion generiert eine neue LUT-Datei aus der BLZ-Datei der Deutschen Bundesbank. Die folgenden
552
979
  * Parameter werden unterstützt:
980
+ * ====Aufruf:
981
+ *
982
+ * ====Parameter:
983
+ *
553
984
  * * inputfile: Eingabedatei (Textdatei) der Bundesbank
554
985
  * * outputfile: Name der Ausgabedatei
555
986
  * * user_info: Info-String der in die LUT-Datei geschrieben wird (frei wählbar; wird in den Info-Block aufgenommen)
@@ -562,28 +993,32 @@ static VALUE free_rb(VALUE self)
562
993
  * 4. BLZ,PZ,NAME,PLZ,ORT,BIC
563
994
  * 5. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC
564
995
  * 6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ
565
- * 7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG
566
- * 8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG
567
- * 9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG,PAN,NR
996
+ * 7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,
997
+ * AENDERUNG
998
+ * 8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,
999
+ * AENDERUNG,LOESCHUNG
1000
+ * 9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,
1001
+ * AENDERUNG,LOESCHUNG,PAN,NR
568
1002
  * * filialen: (0 oder 1) Flag, ob nur die Daten der Hauptstellen (0) oder auch die der Filialen aufgenommen werden sollen
569
1003
  * * 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.
570
1004
  * * iban_file: Datei der Banken, die einer Selbstberechnung des IBAN nicht zugestimmt haben. Näheres dazu (inklusive Weblink) findet sich bei der Funktion KontoCheckRaw::iban_gen(blz,kto).
571
1005
  *
572
- * Mögliche Rückgabewerte:
573
- *
574
- * -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
575
- * -57 (LUT2_GUELTIGKEIT_SWAPPED) "Im Gültigkeitsdatum sind Anfangs- und Enddatum vertauscht"
576
- * -56 (LUT2_INVALID_GUELTIGKEIT) "Das angegebene Gültigkeitsdatum ist ungültig (Soll: JJJJMMTT-JJJJMMTT)"
577
- * -32 (LUT2_COMPRESS_ERROR) "Fehler beim Komprimieren eines LUT-Blocks"
578
- * -31 (LUT2_FILE_CORRUPTED) "Die LUT-Datei ist korrumpiert"
579
- * -30 (LUT2_NO_SLOT_FREE) "Im Inhaltsverzeichnis der LUT-Datei ist kein Slot mehr frei"
580
- * -15 (INVALID_BLZ_FILE) "Fehler in der blz.txt Datei (falsche Zeilenlänge)"
581
- * -11 (FILE_WRITE_ERROR) "kann Datei nicht schreiben"
582
- * -10 (FILE_READ_ERROR) "kann Datei nicht lesen"
583
- * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
584
- * -7 (INVALID_LUT_FILE) "die blz.lut Datei ist inkosistent/ungültig"
585
- * 1 (OK) "ok"
586
- * 7 (LUT1_FILE_GENERATED) "ok; es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert"
1006
+ * ====Rückgabe:
1007
+ *
1008
+ * ====Mögliche Statuscodes:
1009
+ * * -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
1010
+ * * -57 (LUT2_GUELTIGKEIT_SWAPPED) "Im Gültigkeitsdatum sind Anfangs- und Enddatum vertauscht"
1011
+ * * -56 (LUT2_INVALID_GUELTIGKEIT) "Das angegebene Gültigkeitsdatum ist ungültig (Soll: JJJJMMTT-JJJJMMTT)"
1012
+ * * -32 (LUT2_COMPRESS_ERROR) "Fehler beim Komprimieren eines LUT-Blocks"
1013
+ * * -31 (LUT2_FILE_CORRUPTED) "Die LUT-Datei ist korrumpiert"
1014
+ * * -30 (LUT2_NO_SLOT_FREE) "Im Inhaltsverzeichnis der LUT-Datei ist kein Slot mehr frei"
1015
+ * * -15 (INVALID_BLZ_FILE) "Fehler in der blz.txt Datei (falsche Zeilenlänge)"
1016
+ * * -11 (FILE_WRITE_ERROR) "kann Datei nicht schreiben"
1017
+ * * -10 (FILE_READ_ERROR) "kann Datei nicht lesen"
1018
+ * * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
1019
+ * * -7 (INVALID_LUT_FILE) "die blz.lut Datei ist inkosistent/ungültig"
1020
+ * * 1 (OK) "ok"
1021
+ * * 7 (LUT1_FILE_GENERATED) "ok; es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert"
587
1022
  */
588
1023
  static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
589
1024
  {
@@ -597,16 +1032,16 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
597
1032
  &user_info_rb,&gueltigkeit_rb,&felder_rb,&filialen_rb,&set_rb,&iban_file_rb);
598
1033
 
599
1034
  if(TYPE(input_name_rb)==RUBY_T_STRING){
600
- strncpy(input_name,RSTRING_PTR(input_name_rb),FILENAME_MAX);
601
1035
  if((len=RSTRING_LEN(input_name_rb))>FILENAME_MAX)len=FILENAME_MAX;
1036
+ strncpy(input_name,RSTRING_PTR(input_name_rb),len);
602
1037
  *(input_name+len)=0;
603
1038
  }
604
1039
  else
605
1040
  rb_raise(rb_eTypeError,"Unable to convert given input filename.");
606
1041
 
607
1042
  if(TYPE(output_name_rb)==RUBY_T_STRING){
608
- strncpy(output_name,RSTRING_PTR(output_name_rb),FILENAME_MAX);
609
1043
  if((len=RSTRING_LEN(output_name_rb))>FILENAME_MAX)len=FILENAME_MAX;
1044
+ strncpy(output_name,RSTRING_PTR(output_name_rb),len);
610
1045
  *(output_name+len)=0;
611
1046
  }
612
1047
  else
@@ -616,8 +1051,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
616
1051
  *user_info=0;
617
1052
  }
618
1053
  else if(TYPE(user_info_rb)==RUBY_T_STRING){
619
- strncpy(user_info,RSTRING_PTR(user_info_rb),255);
620
1054
  if((len=RSTRING_LEN(user_info_rb))>255)len=255;
1055
+ strncpy(user_info,RSTRING_PTR(user_info_rb),len);
621
1056
  *(user_info+len)=0;
622
1057
  }
623
1058
  else
@@ -627,8 +1062,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
627
1062
  *gueltigkeit=0;
628
1063
  }
629
1064
  else if(TYPE(gueltigkeit_rb)==RUBY_T_STRING){
630
- strncpy(gueltigkeit,RSTRING_PTR(gueltigkeit_rb),19);
631
1065
  if((len=RSTRING_LEN(gueltigkeit_rb))>19)len=19;
1066
+ strncpy(gueltigkeit,RSTRING_PTR(gueltigkeit_rb),len);
632
1067
  *(gueltigkeit+len)=0;
633
1068
  }
634
1069
  else
@@ -637,8 +1072,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
637
1072
  if(NIL_P(felder_rb))
638
1073
  felder=DEFAULT_LUT_FIELDS_NUM;
639
1074
  else if(TYPE(felder_rb)==RUBY_T_STRING){
640
- strncpy(buffer,RSTRING_PTR(felder_rb),15);
641
1075
  if((len=RSTRING_LEN(felder_rb))>15)len=15;
1076
+ strncpy(buffer,RSTRING_PTR(felder_rb),len);
642
1077
  *(buffer+len)=0;
643
1078
  felder=atoi(buffer);
644
1079
  }
@@ -648,8 +1083,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
648
1083
  if(NIL_P(filialen_rb))
649
1084
  filialen=0;
650
1085
  else if(TYPE(filialen_rb)==RUBY_T_STRING){
651
- strncpy(buffer,RSTRING_PTR(filialen_rb),15);
652
1086
  if((len=RSTRING_LEN(felder_rb))>15)len=15;
1087
+ strncpy(buffer,RSTRING_PTR(filialen_rb),len);
653
1088
  *(buffer+len)=0;
654
1089
  filialen=atoi(buffer);
655
1090
  }
@@ -659,8 +1094,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
659
1094
  if(NIL_P(set_rb))
660
1095
  set=0;
661
1096
  else if(TYPE(set_rb)==RUBY_T_STRING){
662
- strncpy(buffer,RSTRING_PTR(set_rb),15);
663
1097
  if((len=RSTRING_LEN(set_rb))>15)len=15;
1098
+ strncpy(buffer,RSTRING_PTR(set_rb),len);
664
1099
  *(buffer+len)=0;
665
1100
  set=atoi(buffer);
666
1101
  }
@@ -671,8 +1106,8 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
671
1106
  *iban_file=0;
672
1107
  }
673
1108
  else if(TYPE(iban_file_rb)==RUBY_T_STRING){
674
- strncpy(iban_file,RSTRING_PTR(iban_file_rb),FILENAME_MAX);
675
1109
  if((len=RSTRING_LEN(iban_file_rb))>FILENAME_MAX)len=FILENAME_MAX;
1110
+ strncpy(iban_file,RSTRING_PTR(iban_file_rb),len);
676
1111
  *(iban_file+len)=0;
677
1112
  }
678
1113
  else
@@ -686,7 +1121,7 @@ static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
686
1121
 
687
1122
  static int enc_mode(int argc,VALUE *argv)
688
1123
  {
689
- int mode,t;
1124
+ int mode;
690
1125
  VALUE mode_rb=Qnil;
691
1126
 
692
1127
  rb_scan_args(argc,argv,"01",&mode_rb);
@@ -723,10 +1158,10 @@ static int enc_mode(int argc,VALUE *argv)
723
1158
  }
724
1159
 
725
1160
  /**
726
- * ===<tt>KontoCheckRaw::encoding([mode])</tt>
727
- * =====<tt>KontoCheck::encoding([mode])</tt>
728
- * =====<tt>KontoCheckRaw::encoding_str([mode])</tt>
729
- * =====<tt>KontoCheckRaw::keep_raw_data(mode)</tt>
1161
+ * ===KontoCheckRaw::encoding( [mode])
1162
+ * =====KontoCheck::encoding( [mode])
1163
+ * =====KontoCheckRaw::encoding_str( [mode])
1164
+ * =====KontoCheckRaw::keep_raw_data( mode)
730
1165
  *
731
1166
  * Diese Funktion legt den benutzten Zeichensatz für Fehlermeldungen durch die
732
1167
  * Funktion KontoCheckRaw::retval2txt() und einige Felder der LUT-Datei (Name,
@@ -740,47 +1175,54 @@ static int enc_mode(int argc,VALUE *argv)
740
1175
  * gesetzt ist, sollte die Funktion *vor* der Initialisierung aufgerufen werden,
741
1176
  * da in dem Fall die Daten der LUT-Datei nur bei der Initialisierung konvertiert
742
1177
  * werden. Mit der Funktion KontoCheckRaw::keep_raw_data() kann das Flag gesetzt
743
- * oder gelöscht werden.
744
- *
745
- * Für den Parameter mode werden die folgenden Werte akzeptiert (die Strings
746
- * sind nicht case sensitiv; Mi oder mI oder MI ist z.B. auch möglich. Wird der
747
- * Parameter nicht angegeben, wird die aktuelle Kodierung ausgegeben):
748
- *
749
- * 0: aktuelle Kodierung ausgeben
750
- * 1, 'i', 'I': ISO-8859-1
751
- * 2, 'u', 'U': UTF-8
752
- * 3, 'h', 'H': HTML
753
- * 4, 'd', 'D': DOS CP 850
754
- * 51, 'mi': ISO-8859-1, Makro für Fehlermeldungen
755
- * 52, 'mu': UTF-8, Makro für Fehlermeldungen
756
- * 53, 'mh': HTML, Makro für Fehlermeldungen
757
- * 54, 'md': DOS CP 850, Makro für Fehlermeldungen
758
- *
1178
+ * gelöscht und abgefragt werden.
1179
+ *
1180
+ * ====Aufruf:
1181
+ * KontoCheckRaw::encoding( [mode])
1182
+ *
1183
+ * ====Parameter:
1184
+ * * mode: die gewünschte Kodierung.
1185
+ * Falls der Parameter nicht angegeben wird, wird die aktuelle Kodierung
1186
+ * zurückgegeben. Ansonsten werden für den Parameter mode die folgenden Werte
1187
+ * akzeptiert (die Strings sind nicht case sensitiv; Mi oder mI oder MI ist
1188
+ * z.B. auch möglich.
1189
+ *
1190
+ * * 0: aktuelle Kodierung ausgeben
1191
+ * * 1, 'i', 'I': ISO-8859-1
1192
+ * * 2, 'u', 'U': UTF-8
1193
+ * * 3, 'h', 'H': HTML
1194
+ * * 4, 'd', 'D': DOS CP 850
1195
+ * * 51, 'mi': ISO-8859-1, Makro für Fehlermeldungen
1196
+ * * 52, 'mu': UTF-8, Makro für Fehlermeldungen
1197
+ * * 53, 'mh': HTML, Makro für Fehlermeldungen
1198
+ * * 54, 'md': DOS CP 850, Makro für Fehlermeldungen
1199
+ *
1200
+ * ====Rückgabe:
759
1201
  * Rückgabewert ist die aktuelle Kodierung als Integer (falls zwei Kodierungen
760
1202
  * angegeben sind, ist die erste die der Statusmeldungen, die zweite die der
761
1203
  * LUT-Blocks):
762
1204
  *
763
- * 0: "noch nicht spezifiziert" (vor der Initialisierung)
764
- * 1: "ISO-8859-1";
765
- * 2: "UTF-8";
766
- * 3: "HTML entities";
767
- * 4: "DOS CP 850";
768
- * 12: "ISO-8859-1/UTF-8";
769
- * 13: "ISO-8859-1/HTML";
770
- * 14: "ISO-8859-1/DOS CP 850";
771
- * 21: "UTF-8/ISO-8859-1";
772
- * 23: "UTF-8/HTML";
773
- * 24: "UTF-8/DOS CP-850";
774
- * 31: "HTML entities/ISO-8859-1";
775
- * 32: "HTML entities/UTF-8";
776
- * 34: "HTML entities/DOS CP-850";
777
- * 41: "DOS CP-850/ISO-8859-1";
778
- * 42: "DOS CP-850/UTF-8";
779
- * 43: "DOS CP-850/HTML";
780
- * 51: "Makro/ISO-8859-1";
781
- * 52: "Makro/UTF-8";
782
- * 53: "Makro/HTML";
783
- * 54: "Makro/DOS CP 850";
1205
+ * * 0: "noch nicht spezifiziert" (vor der Initialisierung)
1206
+ * * 1: "ISO-8859-1";
1207
+ * * 2: "UTF-8";
1208
+ * * 3: "HTML entities";
1209
+ * * 4: "DOS CP 850";
1210
+ * * 12: "ISO-8859-1/UTF-8";
1211
+ * * 13: "ISO-8859-1/HTML";
1212
+ * * 14: "ISO-8859-1/DOS CP 850";
1213
+ * * 21: "UTF-8/ISO-8859-1";
1214
+ * * 23: "UTF-8/HTML";
1215
+ * * 24: "UTF-8/DOS CP-850";
1216
+ * * 31: "HTML entities/ISO-8859-1";
1217
+ * * 32: "HTML entities/UTF-8";
1218
+ * * 34: "HTML entities/DOS CP-850";
1219
+ * * 41: "DOS CP-850/ISO-8859-1";
1220
+ * * 42: "DOS CP-850/UTF-8";
1221
+ * * 43: "DOS CP-850/HTML";
1222
+ * * 51: "Makro/ISO-8859-1";
1223
+ * * 52: "Makro/UTF-8";
1224
+ * * 53: "Makro/HTML";
1225
+ * * 54: "Makro/DOS CP 850";
784
1226
  */
785
1227
  static VALUE encoding_rb(int argc,VALUE* argv,VALUE self)
786
1228
  {
@@ -788,38 +1230,45 @@ static VALUE encoding_rb(int argc,VALUE* argv,VALUE self)
788
1230
  }
789
1231
 
790
1232
  /**
791
- * ===<tt>KontoCheckRaw::encoding_str(mode)</tt>
792
- * =====<tt>KontoCheck::encoding_str(mode)</tt>
793
- * =====<tt>KontoCheckRaw::encoding(mode)</tt>
794
- * =====<tt>KontoCheckRaw::keep_raw_data(mode)</tt>
1233
+ * ===KontoCheckRaw::encoding_str( mode)
1234
+ * =====KontoCheck::encoding_str( mode)
1235
+ * =====KontoCheckRaw::encoding( mode)
1236
+ * =====KontoCheckRaw::keep_raw_data( mode)
795
1237
  *
796
1238
  * Diese Funktion entspricht der Funktion KontoCheck::encoding(). Allerdings
797
1239
  * ist der Rückgabewert nicht numerisch, sondern ein String, der die aktuelle
798
- * Kodierung angibt. Die folgenden Rückgabewerte sind möglich (falls zwei
799
- * Kodierungen angegeben sind, ist die erste die der Statusmeldungen, die
800
- * zweite die der LUT-Blocks):
1240
+ * Kodierung angibt.
1241
+ *
1242
+ * ====Aufruf:
1243
+ * KontoCheckRaw::encoding_str( [mode])
1244
+ *
1245
+ * ====Parameter:
1246
+ * wie bei KontoCheckRaw::encoding()
801
1247
  *
802
- * "noch nicht spezifiziert" (vor der Initialisierung)
803
- * "ISO-8859-1";
804
- * "UTF-8";
805
- * "HTML entities";
806
- * "DOS CP 850";
807
- * "ISO-8859-1/UTF-8";
808
- * "ISO-8859-1/HTML";
809
- * "ISO-8859-1/DOS CP 850";
810
- * "UTF-8/ISO-8859-1";
811
- * "UTF-8/HTML";
812
- * "UTF-8/DOS CP-850";
813
- * "HTML entities/ISO-8859-1";
814
- * "HTML entities/UTF-8";
815
- * "HTML entities/DOS CP-850";
816
- * "DOS CP-850/ISO-8859-1";
817
- * "DOS CP-850/UTF-8";
818
- * "DOS CP-850/HTML";
819
- * "Makro/ISO-8859-1";
820
- * "Makro/UTF-8";
821
- * "Makro/HTML";
822
- * "Makro/DOS CP 850";
1248
+ * ====Rückgabe:
1249
+ * Rückgabewert ist die aktuelle Kodierung als String:
1250
+ *
1251
+ * * "noch nicht spezifiziert" (vor der Initialisierung)
1252
+ * * "ISO-8859-1";
1253
+ * * "UTF-8";
1254
+ * * "HTML entities";
1255
+ * * "DOS CP 850";
1256
+ * * "ISO-8859-1/UTF-8";
1257
+ * * "ISO-8859-1/HTML";
1258
+ * * "ISO-8859-1/DOS CP 850";
1259
+ * * "UTF-8/ISO-8859-1";
1260
+ * * "UTF-8/HTML";
1261
+ * * "UTF-8/DOS CP-850";
1262
+ * * "HTML entities/ISO-8859-1";
1263
+ * * "HTML entities/UTF-8";
1264
+ * * "HTML entities/DOS CP-850";
1265
+ * * "DOS CP-850/ISO-8859-1";
1266
+ * * "DOS CP-850/UTF-8";
1267
+ * * "DOS CP-850/HTML";
1268
+ * * "Makro/ISO-8859-1";
1269
+ * * "Makro/UTF-8";
1270
+ * * "Makro/HTML";
1271
+ * * "Makro/DOS CP 850";
823
1272
  */
824
1273
  static VALUE encoding_str_rb(int argc,VALUE* argv,VALUE self)
825
1274
  {
@@ -827,9 +1276,9 @@ static VALUE encoding_str_rb(int argc,VALUE* argv,VALUE self)
827
1276
  }
828
1277
 
829
1278
  /**
830
- * ===<tt>KontoCheckRaw::keep_raw_data(mode)</tt>
831
- * =====<tt>KontoCheckRaw::encoding(mode)</tt>
832
- * =====<tt>KontoCheck::encoding(mode)</tt>
1279
+ * ===KontoCheckRaw::keep_raw_data( mode)
1280
+ * =====KontoCheckRaw::encoding( mode)
1281
+ * =====KontoCheck::encoding( mode)
833
1282
  *
834
1283
  * Diese Funktion setzt bzw. liest das Flag keep_raw_data in der C-Bibliothek.
835
1284
  * Falls es gesetzt ist, werden werden die Rohdaten der Blocks Name, Kurzname
@@ -839,13 +1288,18 @@ static VALUE encoding_str_rb(int argc,VALUE* argv,VALUE self)
839
1288
  * wieder freigegeben würden.
840
1289
  *
841
1290
  * Da diese Funktion etwas exotisch ist, ist sie nur in der KontoCheckRaw
842
- * Bibliothek enthalten, nicht in KontoCheck..
1291
+ * Bibliothek enthalten, nicht in KontoCheck.
843
1292
  *
844
- * Parameter:
845
- * -1: Flag keep_raw_data ausschalten
846
- * 1: Flag keep_raw_data einschalten
847
- * 0: Flag lesen
1293
+ * ====Aufruf:
1294
+ * retval=KontoCheck::encoding( mode)
848
1295
  *
1296
+ * ====Parameter:
1297
+ * Das Verhalten der Funktion wird durch den Parameter mode gesteuert:
1298
+ * * -1: Flag keep_raw_data ausschalten
1299
+ * * 1: Flag keep_raw_data einschalten
1300
+ * * 0/nil: Flag lesen
1301
+ *
1302
+ * ====Mögliche Rückgabewerte
849
1303
  * Der Rückgabewert ist true oder false.
850
1304
  */
851
1305
  static VALUE keep_raw_data_rb(VALUE self, VALUE mode_rb)
@@ -864,13 +1318,22 @@ static VALUE keep_raw_data_rb(VALUE self, VALUE mode_rb)
864
1318
  }
865
1319
 
866
1320
  /**
867
- * ===<tt>KontoCheckRaw::retval2txt(retval)</tt>
868
- * =====<tt>KontoCheck::retval2txt(retval)</tt>
1321
+ * ===KontoCheckRaw::retval2txt( retval)
1322
+ * =====KontoCheck::retval2txt( retval)
869
1323
  *
870
1324
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
871
1325
  * Der benutzte Zeichensatz wird über die Funktion KontoCheckRaw::encoding()
872
1326
  * festgelegt. Falls diese Funktion nicht aufgerufen wurde, wird der Wert des
873
1327
  * Makros DEFAULT_ENCODING aus konto_check.h benutzt.
1328
+ *
1329
+ * ====Aufruf:
1330
+ * retval_str=KontoCheckRaw::retval2txt( retval)
1331
+ *
1332
+ * ====Parameter:
1333
+ * * retval: der zu konvertierende numerische Rückgabewert
1334
+ *
1335
+ * ====Rückgabe:
1336
+ * String, der dem Rückgabewert entspricht
874
1337
  */
875
1338
  static VALUE retval2txt_rb(VALUE self, VALUE retval)
876
1339
  {
@@ -878,11 +1341,20 @@ static VALUE retval2txt_rb(VALUE self, VALUE retval)
878
1341
  }
879
1342
 
880
1343
  /**
881
- * ===<tt>KontoCheckRaw::retval2iso(retval)</tt>
882
- * =====<tt>KontoCheck::retval2iso(retval)</tt>
1344
+ * ===KontoCheckRaw::retval2iso( retval)
1345
+ * =====KontoCheck::retval2iso( retval)
883
1346
  *
884
1347
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
885
1348
  * Der benutzte Zeichensatz ist ISO 8859-1.
1349
+ *
1350
+ * ====Aufruf:
1351
+ * retval_str=KontoCheckRaw::retval2iso( retval)
1352
+ *
1353
+ * ====Parameter:
1354
+ * * retval: der zu konvertierende numerische Rückgabewert
1355
+ *
1356
+ * ====Rückgabe:
1357
+ * String, der dem Rückgabewert entspricht
886
1358
  */
887
1359
  static VALUE retval2iso_rb(VALUE self, VALUE retval)
888
1360
  {
@@ -890,11 +1362,20 @@ static VALUE retval2iso_rb(VALUE self, VALUE retval)
890
1362
  }
891
1363
 
892
1364
  /**
893
- * ===<tt>KontoCheckRaw::retval2txt_short(retval)</tt>
894
- * =====<tt>KontoCheck::retval2txt_short(retval)</tt>
1365
+ * ===KontoCheckRaw::retval2txt_short( retval)
1366
+ * =====KontoCheck::retval2txt_short( retval)
895
1367
  *
896
1368
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen kurzen
897
1369
  * String. Die Ausgabe ist der Makroname, wie er in C benutzt wird.
1370
+ *
1371
+ * ====Aufruf:
1372
+ * retval_str=KontoCheckRaw::retval2txt_short( retval)
1373
+ *
1374
+ * ====Parameter:
1375
+ * * retval: der zu konvertierende numerische Rückgabewert
1376
+ *
1377
+ * ====Rückgabe:
1378
+ * String, der dem Rückgabewert entspricht
898
1379
  */
899
1380
  static VALUE retval2txt_short_rb(VALUE self, VALUE retval)
900
1381
  {
@@ -902,11 +1383,20 @@ static VALUE retval2txt_short_rb(VALUE self, VALUE retval)
902
1383
  }
903
1384
 
904
1385
  /**
905
- * ===<tt>KontoCheckRaw::retval2dos(<retval>)</tt>
906
- * =====<tt>KontoCheck::retval2dos(<retval>)</tt>
1386
+ * ===KontoCheckRaw::retval2dos( retval)
1387
+ * =====KontoCheck::retval2dos( retval)
907
1388
  *
908
1389
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
909
1390
  * Der benutzte Zeichensatz ist cp850 (DOS).
1391
+ *
1392
+ * ====Aufruf:
1393
+ * retval_str=KontoCheckRaw::retval2dos( retval)
1394
+ *
1395
+ * ====Parameter:
1396
+ * * retval: der zu konvertierende numerische Rückgabewert
1397
+ *
1398
+ * ====Rückgabe:
1399
+ * String, der dem Rückgabewert entspricht
910
1400
  */
911
1401
  static VALUE retval2dos_rb(VALUE self, VALUE retval)
912
1402
  {
@@ -914,11 +1404,20 @@ static VALUE retval2dos_rb(VALUE self, VALUE retval)
914
1404
  }
915
1405
 
916
1406
  /**
917
- * ===<tt>KontoCheckRaw::retval2html(<retval>)</tt>
918
- * =====<tt>KontoCheck::retval2html(<retval>)</tt>
1407
+ * ===KontoCheckRaw::retval2html( retval)
1408
+ * =====KontoCheck::retval2html( retval)
919
1409
  *
920
1410
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
921
1411
  * Für Umlaute werden HTML-Entities benutzt.
1412
+ *
1413
+ * ====Aufruf:
1414
+ * retval_str=KontoCheckRaw::retval2html( retval)
1415
+ *
1416
+ * ====Parameter:
1417
+ * * retval: der zu konvertierende numerische Rückgabewert
1418
+ *
1419
+ * ====Rückgabe:
1420
+ * String, der dem Rückgabewert entspricht
922
1421
  */
923
1422
  static VALUE retval2html_rb(VALUE self, VALUE retval)
924
1423
  {
@@ -926,11 +1425,20 @@ static VALUE retval2html_rb(VALUE self, VALUE retval)
926
1425
  }
927
1426
 
928
1427
  /**
929
- * ===<tt>KontoCheckRaw::retval2utf8(<retval>)</tt>
930
- * =====<tt>KontoCheck::retval2utf8(<retval>)</tt>
1428
+ * ===KontoCheckRaw::retval2utf8( retval)
1429
+ * =====KontoCheck::retval2utf8( retval)
931
1430
  *
932
1431
  * Diese Funktion konvertiert einen numerischen Rückgabewert in einen String.
933
1432
  * Der benutzte Zeichensatz ist UTF-8.
1433
+ *
1434
+ * ====Aufruf:
1435
+ * retval_str=KontoCheckRaw::retval2utf8( retval)
1436
+ *
1437
+ * ====Parameter:
1438
+ * * retval: der zu konvertierende numerische Rückgabewert
1439
+ *
1440
+ * ====Rückgabe:
1441
+ * String, der dem Rückgabewert entspricht
934
1442
  */
935
1443
  static VALUE retval2utf8_rb(VALUE self, VALUE retval)
936
1444
  {
@@ -938,28 +1446,35 @@ static VALUE retval2utf8_rb(VALUE self, VALUE retval)
938
1446
  }
939
1447
 
940
1448
  /**
941
- * ===<tt>KontoCheckRaw::dump_lutfile(lutfile)</tt>
942
- * =====<tt>KontoCheck::dump_lutfile(lutfile)</tt>
1449
+ * ===KontoCheckRaw::dump_lutfile( lutfile)
1450
+ * =====KontoCheck::dump_lutfile( lutfile)
943
1451
  *
944
1452
  * Diese Funktion liefert detaillierte Informationen über alle Blocks, die in
945
1453
  * der LUT-Datei gespeichert sind, sowie noch einige Internas der LUT-Datei.
1454
+ *
1455
+ * ====Aufruf:
1456
+ * retval=KontoCheckRaw::dump_lutfile( lutfile)
1457
+ *
1458
+ * ====Parameter:
1459
+ * * lutfile: Name der LUT-Datei.
1460
+ *
1461
+ * ====Rückgabe:
946
1462
  * Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein
947
1463
  * String mit den Infos, im zweiten ein Statuscode. Im Fehlerfall wird für den
948
1464
  * Infostring nil zurückgegeben.
949
1465
  *
950
- * Mögliche Werte für den Statuscode sind:
951
- *
952
- * -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
953
- * -70 (LUT1_FILE_USED) "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
954
- * -36 (LUT2_Z_MEM_ERROR) "Memory error in den ZLIB-Routinen"
955
- * -35 (LUT2_Z_DATA_ERROR) "Datenfehler im komprimierten LUT-Block"
956
- * -33 (LUT2_DECOMPRESS_ERROR) "Fehler beim Dekomprimieren eines LUT-Blocks"
957
- * -31 (LUT2_FILE_CORRUPTED) "Die LUT-Datei ist korrumpiert"
958
- * -20 (LUT_CRC_ERROR) "Prüfsummenfehler in der blz.lut Datei"
959
- * -10 (FILE_READ_ERROR) "kann Datei nicht lesen"
960
- * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
961
- * -7 (INVALID_LUT_FILE) "die blz.lut Datei ist inkosistent/ungültig"
962
- * 1 (OK) "ok"
1466
+ * ====Mögliche Statuscodes:
1467
+ * * -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
1468
+ * * -70 (LUT1_FILE_USED) "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
1469
+ * * -36 (LUT2_Z_MEM_ERROR) "Memory error in den ZLIB-Routinen"
1470
+ * * -35 (LUT2_Z_DATA_ERROR) "Datenfehler im komprimierten LUT-Block"
1471
+ * * -33 (LUT2_DECOMPRESS_ERROR) "Fehler beim Dekomprimieren eines LUT-Blocks"
1472
+ * * -31 (LUT2_FILE_CORRUPTED) "Die LUT-Datei ist korrumpiert"
1473
+ * * -20 (LUT_CRC_ERROR) "Prüfsummenfehler in der blz.lut Datei"
1474
+ * * -10 (FILE_READ_ERROR) "kann Datei nicht lesen"
1475
+ * * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
1476
+ * * -7 (INVALID_LUT_FILE) "die blz.lut Datei ist inkosistent/ungültig"
1477
+ * * 1 (OK) "ok"
963
1478
  */
964
1479
  static VALUE dump_lutfile_rb(int argc,VALUE* argv,VALUE self)
965
1480
  {
@@ -978,47 +1493,52 @@ static VALUE dump_lutfile_rb(int argc,VALUE* argv,VALUE self)
978
1493
  }
979
1494
 
980
1495
  /**
981
- * ===<tt>KontoCheckRaw::lut_info([lutfile])</tt>
982
- * =====<tt>KontoCheck::lut_info()</tt>
983
- * =====<tt>KontoCheck::lut_info1(lutfile)</tt>
984
- * =====<tt>KontoCheck::lut_info2(lutfile)</tt>
1496
+ * ===KontoCheckRaw::lut_info( [lutfile])
1497
+ * =====KontoCheck::lut_info()
1498
+ * =====KontoCheck::lut_info1( lutfile)
1499
+ * =====KontoCheck::lut_info2( lutfile)
985
1500
  *
986
1501
  * Diese Funktion liefert Informationen über die Datensätze sowie die beiden
987
- * Infoblocks einer LUT-Datei. Falls sie ohne Parameter aufgerufen wird,
988
- * werden Infos über die geladenen Blocks zurückgegeben.
1502
+ * Infoblocks einer LUT-Date oder die in den Speicher geladenen Blocks.
1503
+ *
1504
+ * ====Aufruf:
1505
+ * ret=KontoCheckRaw::lut_info( [lutfile])
989
1506
  *
1507
+ * ====Parameter:
1508
+ * * lutfile: Name der LUT-Datei, falls angegeben. Falls der Parameter weggelassen wird, werden Infnos über die geladenen Blocks zurückgegeben.
1509
+ *
1510
+ * ====Rückgabe:
1511
+ *
990
1512
  * Der Rückgabewert ist ein Array mit 5 Elementen:
991
1513
  *
992
- * 0. retval: Statuscode
993
- * 1. valid1: Gültigkeitscode für den ersten Block
994
- * 2. valid2: Gültigkeitscode für den zweiten Block
995
- * 3. info1: erster Infoblock, oder nil, falls der Block nicht existiert
996
- * 4. info2: zweiter Infoblock, oder nil, falls der Block nicht existiert
997
- *
998
- * Mögliche Statuscodes für valid1 and valid2 sind:
999
- *
1000
- * -105 (LUT2_NO_LONGER_VALID_BETTER) "Beide Datensätze sind nicht mehr gültig; dieser ist aber jünger als der andere"
1001
- * -59 (LUT2_NOT_YET_VALID) "Der Datenblock ist noch nicht gültig"
1002
- * -58 (LUT2_NO_LONGER_VALID) "Der Datenblock ist nicht mehr gültig"
1003
- * -34 (LUT2_BLOCK_NOT_IN_FILE) "Die LUT-Datei enthält den Infoblock nicht"
1004
- * 4 (LUT2_VALID) "Der Datenblock ist aktuell gültig"
1005
- * 5 (LUT2_NO_VALID_DATE) "Der Datenblock enthält kein Gültigkeitsdatum"
1006
- *
1007
- * Mögliche Werte für den Statuscode retval:
1008
- *
1009
- * -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
1010
- * -10 (FILE_READ_ERROR) "kann Datei nicht lesen"
1011
- * -70 (LUT1_FILE_USED) "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
1012
- * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
1013
- * -37 (LUT2_Z_BUF_ERROR) "Buffer error in den ZLIB Routinen"
1014
- * -36 (LUT2_Z_MEM_ERROR) "Memory error in den ZLIB-Routinen"
1015
- * -35 (LUT2_Z_DATA_ERROR) "Datenfehler im komprimierten LUT-Block"
1016
- * -34 (LUT2_BLOCK_NOT_IN_FILE) "Der Block ist nicht in der LUT-Datei enthalten"
1017
- * -31 (LUT2_FILE_CORRUPTED) "Die LUT-Datei ist korrumpiert"
1018
- * -20 (LUT_CRC_ERROR) "Prüfsummenfehler in der blz.lut Datei"
1019
- * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
1020
- * -7 (INVALID_LUT_FILE) "die blz.lut Datei ist inkosistent/ungültig"
1021
- * 1 (OK) "ok"
1514
+ * * das erste Element (retval) enthält den Statuscode für die Funktion insgesamt
1515
+ * * das zweite Element (valid1) enthält den Gültigkeitscode für den ersten Block
1516
+ * * das dritte Element (valid2) enthält den Gültigkeitscode für den zweiten Block
1517
+ * * das vierte Element (info1) enthält den erster Infoblock, oder nil, falls der Block nicht existiert
1518
+ * * das fünfte Element (info2) enthält den zweiter Infoblock, oder nil, falls der Block nicht existiert
1519
+ *
1520
+ * ====Mögliche Statuscodes für valid1 and valid2:
1521
+ * * -105 (LUT2_NO_LONGER_VALID_BETTER) "Beide Datensätze sind nicht mehr gültig; dieser ist aber jünger als der andere"
1522
+ * * -59 (LUT2_NOT_YET_VALID) "Der Datenblock ist noch nicht gültig"
1523
+ * * -58 (LUT2_NO_LONGER_VALID) "Der Datenblock ist nicht mehr gültig"
1524
+ * * -34 (LUT2_BLOCK_NOT_IN_FILE) "Die LUT-Datei enthält den Infoblock nicht"
1525
+ * * 4 (LUT2_VALID) "Der Datenblock ist aktuell gültig"
1526
+ * * 5 (LUT2_NO_VALID_DATE) "Der Datenblock enthält kein Gültigkeitsdatum"
1527
+ *
1528
+ * ====Mögliche Werte für den Statuscode retval:
1529
+ * * -112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
1530
+ * * -10 (FILE_READ_ERROR) "kann Datei nicht lesen"
1531
+ * * -70 (LUT1_FILE_USED) "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
1532
+ * * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
1533
+ * * -37 (LUT2_Z_BUF_ERROR) "Buffer error in den ZLIB Routinen"
1534
+ * * -36 (LUT2_Z_MEM_ERROR) "Memory error in den ZLIB-Routinen"
1535
+ * * -35 (LUT2_Z_DATA_ERROR) "Datenfehler im komprimierten LUT-Block"
1536
+ * * -34 (LUT2_BLOCK_NOT_IN_FILE) "Der Block ist nicht in der LUT-Datei enthalten"
1537
+ * * -31 (LUT2_FILE_CORRUPTED) "Die LUT-Datei ist korrumpiert"
1538
+ * * -20 (LUT_CRC_ERROR) "Prüfsummenfehler in der blz.lut Datei"
1539
+ * * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
1540
+ * * -7 (INVALID_LUT_FILE) "die blz.lut Datei ist inkosistent/ungültig"
1541
+ * * 1 (OK) "ok"
1022
1542
  */
1023
1543
  static VALUE lut_info_rb(int argc,VALUE* argv,VALUE self)
1024
1544
  {
@@ -1043,18 +1563,18 @@ static VALUE lut_info_rb(int argc,VALUE* argv,VALUE self)
1043
1563
  }
1044
1564
 
1045
1565
  /**
1046
- * ===<tt>KontoCheckRaw::load_bank_data(<datafile>)</tt>
1047
- * =====<tt>KontoCheck::load_bank_data(<datafile>)</tt>
1566
+ * ===KontoCheckRaw::load_bank_data( datafile)
1567
+ * =====KontoCheck::load_bank_data( datafile)
1048
1568
  *
1049
1569
  * Diese Funktion war die alte Initialisierungsroutine für konto_check; es ist
1050
1570
  * nun durch die Funktionen KontoCheck::init() und KontoCheck::generate_lutfile()
1051
1571
  * ersetzt. Zur Initialisierung benutzte sie die Textdatei der Deutschen
1052
- * Bundesbank und generiertge daraus eine LUT-Datei, die dann von der
1572
+ * Bundesbank und generierte daraus eine LUT-Datei, die dann von der
1053
1573
  * Initialisierungsroutine der C-Bibliothek benutzt wurde.
1054
1574
  *
1055
- * Die init() Funktion ist wesentlich schneller (7..20 mal so schnell ohne
1575
+ * Die init() Funktion ist wesentlich schneller (7...20 mal so schnell ohne
1056
1576
  * Generierung der Indexblocks; mit Indexblocks macht es noch wesentlich mehr
1057
- * aus) und hat eine Reihe weiterer Vorteile. So ist es z.B. möglich, zwwei
1577
+ * aus) und hat eine Reihe weiterer Vorteile. So ist es z.B. möglich, zwei
1058
1578
  * Datensätze mit unterschiedlichem Gültigkeitszeitraum in einer Datei zu
1059
1579
  * halten und den jeweils gültigen Satz automatisch (nach der Systemzeit)
1060
1580
  * auswählen zu lassen. Die einzelnen Datenblocks (Bankleitzahlen,
@@ -1064,10 +1584,20 @@ static VALUE lut_info_rb(int argc,VALUE* argv,VALUE self)
1064
1584
  * Format, so daß einzelne Blocks nicht unabhängig von anderen geladen werden
1065
1585
  * können.
1066
1586
  *
1067
- * Die Funktion load_bank_data() wird nur noch als ein schibbolet benutzt, um
1587
+ * Die Funktion load_bank_data() wird nur noch als ein Schibbolet benutzt, um
1068
1588
  * zu testen, ob jemand das alte Interface benutzt. Bei der Routine
1069
1589
  * KontoCheck::konto_check() wurde die Reihenfolge der Parameter getauscht, so
1070
1590
  * daß man in dem Falle den alten Code umstellen muß.
1591
+ *
1592
+ * ====Aufruf:
1593
+ * retval=KontoCheckRaw::load_bank_data( datafile)
1594
+ *
1595
+ * ====Parameter:
1596
+ * * der alte Parameter datafile ist die BLZ-Datei der Deutschen Bundesbank; er wird ignoriert.
1597
+ *
1598
+ * ====Rückgabe:
1599
+ * es erfolgt keine Rückgabe, sondern es wird nur eine runtime Exception generiert, daß
1600
+ * scheinbar das alte Interface benutzt wurde, dieses aber nicht mehr unterstützt wird.
1071
1601
  */
1072
1602
 
1073
1603
  static VALUE load_bank_data(VALUE self, VALUE path_rb)
@@ -1078,8 +1608,8 @@ static VALUE load_bank_data(VALUE self, VALUE path_rb)
1078
1608
  }
1079
1609
 
1080
1610
  /**
1081
- * ===<tt>KontoCheckRaw::iban2bic(iban)</tt>
1082
- * =====<tt>KontoCheck::iban2bic(iban)</tt>
1611
+ * ===KontoCheckRaw::iban2bic( iban)
1612
+ * =====KontoCheck::iban2bic( iban)
1083
1613
  *
1084
1614
  * Diese Funktion bestimmt zu einer (deutschen!) IBAN den zugehörigen BIC (Bank
1085
1615
  * Identifier Code). Der BIC wird für eine EU-Standard-Überweisung im
@@ -1087,19 +1617,25 @@ static VALUE load_bank_data(VALUE self, VALUE path_rb)
1087
1617
  * Banken ist er in der BLZ-Datei enthalten. Nähere Infos gibt es z.B. unter
1088
1618
  * http://www.bic-code.de/
1089
1619
  *
1620
+ * ====Aufruf:
1621
+ * ret=KontoCheckRaw::iban2bic( iban)
1622
+ *
1623
+ * ====Parameter:
1624
+ * * iban: die IBAN, zu der der entsprechende BIC bestimmt werden soll.
1625
+ *
1626
+ * ====Rückgabe:
1090
1627
  * Der Rückgabewert ist ein Array mit vier Elementen: im ersten steht der BIC,
1091
1628
  * im zweiten ein Statuscode, im dritten die BLZ und im vierten die Kontonummer
1092
1629
  * (die beiden letzteren werden aus der IBAN extrahiert). Im Fehlerfall wird
1093
1630
  * für BIC, BLZ und Kontonummer nil zurückgegeben.
1094
1631
  *
1095
- * Mögliche Statuscodes:
1096
- *
1097
- * -68 (IBAN2BIC_ONLY_GERMAN) "Die Funktion iban2bic() arbeitet nur mit deutschen Bankleitzahlen"
1098
- * -46 (LUT2_BIC_NOT_INITIALIZED) "Das Feld BIC wurde nicht initialisiert"
1099
- * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
1100
- * -5 (INVALID_BLZ_LENGTH) "die Bankleitzahl ist nicht achtstellig"
1101
- * -4 (INVALID_BLZ) "die Bankleitzahl ist ungültig"
1102
- * 1 (OK) "ok"
1632
+ * ====Mögliche Statuscodes:
1633
+ * * -68 (IBAN2BIC_ONLY_GERMAN) "Die Funktion iban2bic() arbeitet nur mit deutschen Bankleitzahlen"
1634
+ * * -46 (LUT2_BIC_NOT_INITIALIZED) "Das Feld BIC wurde nicht initialisiert"
1635
+ * * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
1636
+ * * -5 (INVALID_BLZ_LENGTH) "die Bankleitzahl ist nicht achtstellig"
1637
+ * * -4 (INVALID_BLZ) "die Bankleitzahl ist ungültig"
1638
+ * * 1 (OK) "ok"
1103
1639
  */
1104
1640
  static VALUE iban2bic_rb(int argc,VALUE* argv,VALUE self)
1105
1641
  {
@@ -1115,118 +1651,203 @@ static VALUE iban2bic_rb(int argc,VALUE* argv,VALUE self)
1115
1651
  }
1116
1652
 
1117
1653
  /**
1118
- * ===<tt>KontoCheckRaw::iban_gen(blz,kto)</tt>
1119
- * =====<tt>KontoCheck::iban_gen(kto,blz)</tt>
1120
- * Diese Funktion generiert aus (deutscher) BLZ und Konto einen IBAN. Hierbei
1121
- * ist zu beachten, daß nicht alle Banken der Selbstberechnung zugestimmt
1122
- * haben. Es gibt von den Sparkassen eine Liste dieser Institute; sie ist auch
1123
- * in der LUT-Datei mit der ID 22 (1. Eigene IBAN) enthalten. Bei diesen Banken
1124
- * wird - falls der Block in der LUT-Datei enthalten ist - keine Berechnung
1125
- * durchgeführt, sondern die Status-Variable auf NO_OWN_IBAN_CALCULATION
1126
- * gesetzt.
1127
- *
1128
- * Alle Banken der Liste erzeugen eine Statusmeldung mit dem Wert
1129
- * OK_UNTERKONTO_ATTACHED, OK_UNTERKONTO_POSSIBLE oder OK_UNTERKONTO_GIVEN.
1130
- * Falls einer dieser Stauswerte zurückgegeben wird, ist somit immer Vorsicht
1131
- * geboten; der generierte IBAN sollte direkt bei dem zugehörigen Institut
1132
- * überprüft werden.
1133
- *
1134
- * Hier ein Auszug aus der Anleitung des SEPA Account Converters:
1135
- *
1136
- * Der SEPA Account Converter ist so eingestellt, dass nur Kontoverbindungen in
1137
- * IBAN und BIC umgerechnet werden, bei denen das ausgebende Kreditinstitut der
1138
- * Umrechnung zugestimmt hat. Kreditinstitute, welche einer Umrechnung nicht
1139
- * zugestimmt haben und welche zum Teil spezielle, dem SEPA Account Converter
1140
- * nicht bekannte Umrechnungsmethoden verwenden, sind in der Datei "CONFIG.INI"
1141
- * hinterlegt. Durch Löschen der Datei "CONFIG.INI" aus dem Programmverzeichnis
1142
- * haben Sie die Möglichkeit, eine Umrechnung für alle Konten durchzuführen.
1143
- * Bitte beachten Sie dabei, dass die so erhaltenen IBAN und BIC fehlerhaft
1144
- * sein können und deshalb mit ihren Kunden zu überprüfen sind.
1145
- *
1146
- * Weblinks:
1147
- *
1148
- * https://www.sparkasse-rhein-neckar-nord.de/pdf/content/sepa/kurzanleitung.pdf
1149
- * https://www.sparkasse-rhein-neckar-nord.de/firmenkunden/internationales_geschaeft/sepa/vorteile/index.php
1150
- * https://www.sparkasse-rhein-neckar-nord.de/firmenkunden/internationales_geschaeft/sepa/vorteile/sepa_account_converter.msi
1654
+ * ===KontoCheckRaw::iban_gen( blz,kto)
1655
+ * =====KontoCheck::iban_gen( kto,blz)
1656
+ * Diese Funktion generiert aus (deutscher) BLZ und Konto einen IBAN, sowie den
1657
+ * zugehörigen BIC.
1658
+ *
1659
+ * Nachdem im Mai 2013 die IBAN-Regeln zur Berechnung von IBAN und BIC aus
1660
+ * Kontonummer und BLZ veröffentlicht wurden, gibt es endlich ein verbindliches
1661
+ * Verfahren zur Bestimmung der IBAN. Die definierten IBAN-Regeln wurden in der
1662
+ * C-Datei eingearbeitet und werden automatisch ausgewertet, falls der Block mit
1663
+ * den IBAN-Regeln in der LUT-Datei enthalten ist. Andere LUT-Dateien sollten
1664
+ * für die IBAN-Berechnung möglichst nicht verwendet werden, da die Anzahl der
1665
+ * BLZs mit Sonderregelungen doch sehr groß ist.
1151
1666
  *
1152
1667
  * Es ist möglich, sowohl die Prüfung auf Stimmigkeit der Kontonummer als auch
1153
- * auf Zulässigkeit der Selbstberechnung zu deaktivieren. Falls die IBAN trotz
1154
- * fehlender Zustimmung der Bank berechnet werden, ist vor die BLZ ein @ zu
1668
+ * die "schwarze Liste" (ausgeschlossene BLZs) zu deaktivieren. Falls die IBAN
1669
+ * ohne Test der Blacklist berechnet werden soll, ist vor die BLZ ein @ zu
1155
1670
  * setzen; falls auch bei falscher Bankverbindung ein IBAN berechnet werden
1156
1671
  * soll, ist vor die BLZ ein + zu setzen. Um beide Prüfungen zu deaktiviern,
1157
1672
  * kann @+ (oder +@) vor die BLZ gesetzt werden. Die so erhaltenen IBANs sind
1158
- * dann i.A. allerdings wohl nicht gültig.
1159
- *
1160
- * Mögliche Statuscodes sind:
1161
- * -110 OK_UNTERKONTO_ATTACHED "wahrscheinlich OK; es wurde allerdings ein (weggelassenes) Unterkonto angefügt"
1162
- * -77 (BAV_FALSE) "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
1163
- * -74 (NO_GERMAN_BIC) "Ein Konto kann kann nur für deutsche Banken geprüft werden"
1164
- * -69 (MISSING_PARAMETER) "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
1165
- * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
1166
- * -29 (UNDEFINED_SUBMETHOD) "Die (Unter)Methode ist nicht definiert"
1167
- * -12 (INVALID_KTO_LENGTH) "ein Konto muß zwischen 1 und 10 Stellen haben"
1168
- * -5 (INVALID_BLZ_LENGTH) "die Bankleitzahl ist nicht achtstellig"
1169
- * -4 (INVALID_BLZ) "Die (Unter)Methode ist nicht definiert"
1170
- * -3 (INVALID_KTO) "das Konto ist ungültig"
1171
- * -2 (NOT_IMPLEMENTED) "die Methode wurde noch nicht implementiert"
1172
- * -1 (NOT_DEFINED) "die Methode ist nicht definiert"
1173
- * 0 (FALSE) "falsch"
1174
- * 1 (OK) "ok"
1175
- * 2 (OK_NO_CHK) "ok, ohne Prüfung"
1176
- * 11 (OK_UNTERKONTO_POSSIBLE) "wahrscheinlich ok; die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten"
1177
- * 12 (OK_UNTERKONTO_GIVEN) "wahrscheinlich ok; die Kontonummer enthält eine Unterkontonummer"
1673
+ * dann u.U. allerdings wohl nicht gültig.
1674
+ *
1675
+ * ====Aufruf:
1676
+ * ret=KontoCheckRaw::iban_gen( blz,kto)
1677
+ *
1678
+ * ====Parameter:
1679
+ * * blz: die BLZ, zu der die IBAN generiert werden soll
1680
+ * * kto: Kontonummer
1681
+ *
1682
+ * ====Rückgabe:
1683
+ * Rückgabe ist ein Array mit sieben Elementen:
1684
+ * * das erste Element enthält die generierten IBAN in komprimierter Form
1685
+ * * das zweite Element enthält die generierte IBAN in Papierform (mit eingestreuten Blanks)
1686
+ * * das dritte Element enthält den Statuscode der Funktion
1687
+ * * 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.
1688
+ * * das fünfte Element enthält die verwendete BLZ
1689
+ * * das sechste Element enthält die verwendete Kontonummer
1690
+ * * das siebte Element enthält die verwendete IBAN-Regel
1691
+ *
1692
+ * ====Mögliche Statuscodes:
1693
+ * * -128 (IBAN_INVALID_RULE) "Die BLZ passt nicht zur angegebenen IBAN-Regel"
1694
+ * * -127 (IBAN_AMBIGUOUS_KTO) "Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten)"
1695
+ * * -125 (IBAN_RULE_UNKNOWN) "Die IBAN-Regel ist nicht bekannt"
1696
+ * * -124 (NO_IBAN_CALCULATION) "Für die Bankverbindung ist keine IBAN-Berechnung erlaubt"
1697
+ * * -123 (OLD_BLZ_OK_NEW_NOT) "Die Bankverbindung ist mit der alten BLZ stimmig, mit der Nachfolge-BLZ nicht"
1698
+ * * -122 (LUT2_IBAN_REGEL_NOT_INITIALIZED) "Das Feld IBAN-Regel wurde nicht initialisiert"
1699
+ * * -120 (LUT2_NO_ACCOUNT_GIVEN) "Keine Bankverbindung/IBAN angegeben"
1700
+ * * -113 (NO_OWN_IBAN_CALCULATION) "das Institut erlaubt keine eigene IBAN-Berechnung"
1701
+ * * -77 (BAV_FALSE) "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
1702
+ * * -74 (NO_GERMAN_BIC) "Ein Konto kann kann nur für deutsche Banken geprüft werden"
1703
+ * * -69 (MISSING_PARAMETER) "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
1704
+ * * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
1705
+ * * -29 (UNDEFINED_SUBMETHOD) "Die (Unter)Methode ist nicht definiert"
1706
+ * * -12 (INVALID_KTO_LENGTH) "ein Konto muß zwischen 1 und 10 Stellen haben"
1707
+ * * -5 (INVALID_BLZ_LENGTH) "die Bankleitzahl ist nicht achtstellig"
1708
+ * * -4 (INVALID_BLZ) "Die Bankleitzahl ist nicht definiert"
1709
+ * * -3 (INVALID_KTO) "das Konto ist ungültig"
1710
+ * * -2 (NOT_IMPLEMENTED) "die Methode wurde noch nicht implementiert"
1711
+ * * -1 (NOT_DEFINED) "die (Unter)Methode ist nicht definiert"
1712
+ * * 0 (FALSE) "falsch"
1713
+ * * 1 (OK) "ok"
1714
+ * * 2 (OK_NO_CHK) "ok, ohne Prüfung"
1715
+ * * 11 (OK_UNTERKONTO_POSSIBLE) "wahrscheinlich ok; die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten"
1716
+ * * 12 (OK_UNTERKONTO_GIVEN) "wahrscheinlich ok; die Kontonummer enthält eine Unterkontonummer"
1717
+ * * 18 (OK_KTO_REPLACED) "ok; die Kontonummer wurde allerdings ersetzt"
1718
+ * * 19 (OK_BLZ_REPLACED) "ok; die Bankleitzahl wurde allerdings ersetzt"
1719
+ * * 20 (OK_BLZ_KTO_REPLACED) "ok; die Bankleitzahl und Kontonummer wurde allerdings ersetzt"
1720
+ * * 21 (OK_IBAN_WITHOUT_KC_TEST) "ok; die Bankverbindung ist (ohne Test) als richtig anzusehen"
1721
+ * * 22 (OK_INVALID_FOR_IBAN) "ok; für IBAN ist (durch eine Regel) allerdings ein anderer BIC definiert"
1722
+ * * 24 (OK_KTO_REPLACED_NO_PZ) "ok; die Kontonummer wurde ersetzt, die neue Kontonummer hat keine Prüfziffer"
1723
+ * * 25 (OK_UNTERKONTO_ATTACHED) "ok; es wurde ein (weggelassenes) Unterkonto angefügt"
1178
1724
  */
1179
1725
  static VALUE iban_gen_rb(int argc,VALUE* argv,VALUE self)
1180
1726
  {
1181
- char iban[128],*papier,*ptr,*dptr,blz[20],kto[20];
1182
- int retval;
1183
- VALUE iban_rb,papier_rb;
1727
+ char iban[128],*papier,*ptr,*dptr,blz[20],kto[20],blz2[20],kto2[20];
1728
+ const char *bic;
1729
+ int retval,regel;
1730
+ VALUE iban_rb,papier_rb,bic_rb,blz2_rb,kto2_rb;
1184
1731
 
1185
1732
  get_params(argc,argv,blz,kto,NULL,NULL,2);
1186
- papier=iban_gen(blz,kto,&retval);
1187
- if(retval==OK || retval==OK_UNTERKONTO_ATTACHED || retval==OK_UNTERKONTO_POSSIBLE || retval==OK_UNTERKONTO_GIVEN){
1733
+ papier=iban_bic_gen(blz,kto,&bic,blz2,kto2,&retval);
1734
+ regel=-1;
1735
+ if(retval>0){
1188
1736
  for(ptr=papier,dptr=iban;*ptr;ptr++)if(*ptr!=' ')*dptr++=*ptr;
1189
1737
  *dptr=0;
1190
1738
  iban_rb=rb_str_new2(iban);
1191
1739
  papier_rb=rb_str_new2(papier);
1740
+ bic_rb=rb_str_new2(bic);
1741
+ blz2_rb=rb_str_new2(blz2);
1742
+ kto2_rb=rb_str_new2(kto2);
1192
1743
  kc_free(papier); /* die C-Funktion allokiert Speicher, der muß wieder freigegeben werden */
1744
+ regel=lut_iban_regel(blz,0,NULL)/100;
1193
1745
  }
1194
1746
  else
1195
- iban_rb=papier_rb=Qnil;
1196
- return rb_ary_new3(3,iban_rb,papier_rb,INT2FIX(retval));
1747
+ iban_rb=papier_rb=blz2_rb=kto2_rb=bic_rb=Qnil;
1748
+ return rb_ary_new3(7,iban_rb,papier_rb,INT2FIX(retval),bic_rb,blz2_rb,kto2_rb,INT2FIX(regel));
1749
+ }
1750
+
1751
+ /**
1752
+ * ===KontoCheckRaw::ci_check( ci)
1753
+ * =====KontoCheck::ci_check( ci)
1754
+ * Diese Funktion testet eine Gläubiger-Identifikationsnummer (Credit Identifier, ci)
1755
+ *
1756
+ * ====Aufruf:
1757
+ * ret=KontoCheckRaw::ci_check( ci)
1758
+ *
1759
+ * ====Parameter:
1760
+ * * ci: der CI, der getestet werden soll
1761
+ *
1762
+ * ====Mögliche Rückgabewerte für den Test:
1763
+ * * 0 (FALSE) "falsch"
1764
+ * * 1 (OK) "ok"
1765
+ *
1766
+ */
1767
+ static VALUE ci_check_rb(int argc,VALUE* argv,VALUE self)
1768
+ {
1769
+ char ci[128];
1770
+
1771
+ get_params(argc,argv,ci,NULL,NULL,NULL,3);
1772
+ return INT2FIX(ci_check(ci));
1773
+ }
1774
+
1775
+ /**
1776
+ * ===KontoCheckRaw::bic_check( bic)
1777
+ * =====KontoCheck::bic_check( bic)
1778
+ * Diese Funktion testet einen BIC (nur für deutsche Bankverbindungen). Die
1779
+ * Rückgabe ist ein Array mit zwei Elementen: im ersten (retval) wird das
1780
+ * Testergebnis für die zurückgegeben, im zweiten die Änzahl Banken, die diesen
1781
+ * BIC benutzen (interessant bei 8stelligen BICs)
1782
+ *
1783
+ * ====Aufruf:
1784
+ * ret=KontoCheckRaw::bic_check( bic)
1785
+ *
1786
+ * ====Parameter:
1787
+ * * bic: der bic, der getestet werden soll
1788
+ *
1789
+ * ====Rückgabe:
1790
+ * Rückgabe ist ein Array mit zwei Elementen:
1791
+ * * das erste Element enthält den Statuscode
1792
+ * * das zweite Element enthält die Anzahl Banken, die diesen BIC benutzen
1793
+ *
1794
+ * ====Mögliche Rückgabewerte:
1795
+ * * -145 (BIC_ONLY_GERMAN) "Es werden nur deutsche BICs unterstützt";
1796
+ * * -144 (INVALID_BIC_LENGTH) "Die Länge des BIC muß genau 8 oder 11 Zeichen sein"
1797
+ * * 0 (FALSE) "falsch"
1798
+ * * 1 (OK) "ok"
1799
+ */
1800
+ static VALUE bic_check_rb(int argc,VALUE* argv,VALUE self)
1801
+ {
1802
+ char bic[12];
1803
+ int retval,cnt;
1804
+
1805
+ get_params(argc,argv,bic,NULL,NULL,NULL,8);
1806
+ retval=bic_check(bic,&cnt);
1807
+ return rb_ary_new3(2,INT2FIX(retval),INT2FIX(cnt));
1197
1808
  }
1198
1809
 
1199
1810
  /**
1200
- * ===<tt>KontoCheckRaw::iban_check(blz)</tt>
1201
- * =====<tt>KontoCheck::iban_check(iban)</tt>
1811
+ * ===KontoCheckRaw::iban_check( iban)
1812
+ * =====KontoCheck::iban_check( iban)
1202
1813
  * Diese Funktion testet eine IBAN; bei deutschen Bankverbindungen wird
1203
1814
  * zusätzlich noch die Plausibilität der Bankverbindung getestet und im
1204
1815
  * Statuswert zurückgegeben. Die Rückgabe ist ein Array mit zwei Elementen: im
1205
1816
  * ersten (retval) wird das Testergebnis für die IBAN zurückgegeben, im zweiten
1206
1817
  * (bei deutschen Bankverbindungen) das Testergebnis des Kontotests.
1207
1818
  *
1208
- * Mögliche Rückgabewerte für den IBAN-Test:
1209
- *
1210
- * -67 (IBAN_OK_KTO_NOT) "Die Prüfziffer der IBAN stimmt, die der Kontonummer nicht"
1211
- * -66 (KTO_OK_IBAN_NOT) "Die Prüfziffer der Kontonummer stimmt, die der IBAN nicht"
1212
- * 0 (FALSE) "falsch"
1213
- * 1 (OK) "ok"
1214
- *
1215
- * Mögliche Rückgabewerte für den Kontotest:
1216
- * -77 (BAV_FALSE) "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
1217
- * -74 (NO_GERMAN_BIC) "Ein Konto kann kann nur für deutsche Banken geprüft werden"
1218
- * -69 (MISSING_PARAMETER) "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
1219
- * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
1220
- * -29 (UNDEFINED_SUBMETHOD) "Die (Unter)Methode ist nicht definiert"
1221
- * -12 (INVALID_KTO_LENGTH) "ein Konto muß zwischen 1 und 10 Stellen haben"
1222
- * -5 (INVALID_BLZ_LENGTH) "die Bankleitzahl ist nicht achtstellig"
1223
- * -4 (INVALID_BLZ) "Die (Unter)Methode ist nicht definiert"
1224
- * -3 (INVALID_KTO) "das Konto ist ungültig"
1225
- * -2 (NOT_IMPLEMENTED) "die Methode wurde noch nicht implementiert"
1226
- * -1 (NOT_DEFINED) "die Methode ist nicht definiert"
1227
- * 0 (FALSE) "falsch"
1228
- * 1 (OK) "ok"
1229
- * 2 (OK_NO_CHK) "ok, ohne Prüfung"
1819
+ * ====Aufruf:
1820
+ * ret=KontoCheckRaw::iban_check( iban)
1821
+ *
1822
+ * ====Parameter:
1823
+ * * iban: die IBAN, die getestet werden soll
1824
+ *
1825
+ * ====Rückgabe:
1826
+ * Rückgabe ist ein Array mit zwei Elementen:
1827
+ * * das erste Element enthält den Statuscode für den IBAN-Test
1828
+ * * das zweite Element enthält den Statuscode für den Test der Bankverbindung (nur für deutsche Kontoverbindungen)
1829
+ *
1830
+ * ====Mögliche Rückgabewerte für den IBAN-Test:
1831
+ * * -67 (IBAN_OK_KTO_NOT) "Die Prüfziffer der IBAN stimmt, die der Kontonummer nicht"
1832
+ * * -66 (KTO_OK_IBAN_NOT) "Die Prüfziffer der Kontonummer stimmt, die der IBAN nicht"
1833
+ * * 0 (FALSE) "falsch"
1834
+ * * 1 (OK) "ok"
1835
+ *
1836
+ * ====Mögliche Rückgabewerte für den Kontotest:
1837
+ * * -77 (BAV_FALSE) "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
1838
+ * * -74 (NO_GERMAN_BIC) "Ein Konto kann kann nur für deutsche Banken geprüft werden"
1839
+ * * -69 (MISSING_PARAMETER) "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
1840
+ * * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
1841
+ * * -29 (UNDEFINED_SUBMETHOD) "Die (Unter)Methode ist nicht definiert"
1842
+ * * -12 (INVALID_KTO_LENGTH) "ein Konto muß zwischen 1 und 10 Stellen haben"
1843
+ * * -5 (INVALID_BLZ_LENGTH) "die Bankleitzahl ist nicht achtstellig"
1844
+ * * -4 (INVALID_BLZ) "Die (Unter)Methode ist nicht definiert"
1845
+ * * -3 (INVALID_KTO) "das Konto ist ungültig"
1846
+ * * -2 (NOT_IMPLEMENTED) "die Methode wurde noch nicht implementiert"
1847
+ * * -1 (NOT_DEFINED) "die Methode ist nicht definiert"
1848
+ * * 0 (FALSE) "falsch"
1849
+ * * 1 (OK) "ok"
1850
+ * * 2 (OK_NO_CHK) "ok, ohne Prüfung"
1230
1851
  */
1231
1852
  static VALUE iban_check_rb(int argc,VALUE* argv,VALUE self)
1232
1853
  {
@@ -1239,24 +1860,38 @@ static VALUE iban_check_rb(int argc,VALUE* argv,VALUE self)
1239
1860
  }
1240
1861
 
1241
1862
  /**
1242
- * ===<tt>KontoCheckRaw::ipi_gen(<zweck>)</tt>
1243
- * =====<tt>KontoCheck::ipi_gen(<zweck>)</tt>
1244
- *
1245
- * Diese Funktion generiert einen "Strukturierten Verwendungszweck" für SEPA-Überweisungen.
1246
- * Der Rückgabewert ist der Strukturierte Verwendungszweck als String oder nil, falls ein Fehler
1247
- * aufgetreten ist.
1248
- *
1249
- * Der String für den Strukturierten Verwendungszweck darf maximal 18 Byte lang sein und nur
1250
- * alphanumerische Zeichen enthalten (also auch keine Umlaute).
1251
- *
1252
- * Der Rückgabewert ist ein Array mit drei Elementen: im ersten steht der Strukturierte Verwendungszweck,
1253
- * im zweiten ein Statuscode und im dritten die Papierform (mit eingestreuten Blanks).
1254
- *
1255
- * Mögliche Statuscodes:
1256
- *
1257
- * -71 (IPI_INVALID_LENGTH) "Die Länge des IPI-Verwendungszwecks darf maximal 18 Byte sein"
1258
- * -72 (IPI_INVALID_CHARACTER) "Im strukturierten Verwendungszweck dürfen nur alphanumerische Zeichen vorkommen"
1259
- * 1 (OK) "ok"
1863
+ * ===KontoCheckRaw::ipi_gen( zweck)
1864
+ * =====KontoCheck::ipi_gen( zweck)
1865
+ *
1866
+ * Diese Funktion generiert einen "Strukturierten Verwendungszweck" für
1867
+ * SEPA-Überweisungen. Der Rückgabewert ist der Strukturierte Verwendungszweck
1868
+ * als String oder nil, falls ein Fehler aufgetreten ist.
1869
+ *
1870
+ * _ACHTUNG_ Die Reihenfolge der Parameter dieser Funktion hat sich in Version
1871
+ * 0.2.2 geändert; der Statuscode wird nun als letzter Arraywert zurückgegeben,
1872
+ * die Papierform als zweiter Wert (wie bei iban_gen(). Es ist nicht schön,so
1873
+ * allerdings insgesamt konsistenter (ich habe auch eine Abneigung gegen
1874
+ * Änderungen des Interfaces, aber an dieser Stelle schien es geboten zu sein).
1875
+ *
1876
+ * ====Aufruf:
1877
+ * ret=KontoCheckRaw::ipi_gen( zweck)
1878
+ *
1879
+ * ====Parameter:
1880
+ * * zweck: String für den ein Strukturierter Verwendungszweck generiert werden soll.
1881
+ * Der String für den Strukturierten Verwendungszweck darf maximal 18 Byte lang
1882
+ * sein und nur alphanumerische Zeichen enthalten (also auch keine Umlaute).
1883
+ *
1884
+ *
1885
+ * ====Rückgabe:
1886
+ * Der Rückgabewert ist ein Array mit drei Elementen:
1887
+ * * im ersten steht der Strukturierte Verwendungszweck,
1888
+ * * im zweiten die Papierform (mit eingestreuten Blanks).
1889
+ * * im dritten ein Statuscode
1890
+ *
1891
+ * ====Mögliche Statuscodes:
1892
+ * * -71 (IPI_INVALID_LENGTH) "Die Länge des IPI-Verwendungszwecks darf maximal 18 Byte sein"
1893
+ * * -72 (IPI_INVALID_CHARACTER) "Im strukturierten Verwendungszweck dürfen nur alphanumerische Zeichen vorkommen"
1894
+ * * 1 (OK) "ok"
1260
1895
  */
1261
1896
  static VALUE ipi_gen_rb(int argc,VALUE* argv,VALUE self)
1262
1897
  {
@@ -1266,22 +1901,32 @@ static VALUE ipi_gen_rb(int argc,VALUE* argv,VALUE self)
1266
1901
  get_params(argc,argv,zweck,NULL,NULL,NULL,4);
1267
1902
  retval=ipi_gen(zweck,dst,papier);
1268
1903
  if(retval==OK)
1269
- return rb_ary_new3(3,rb_str_new2(dst),INT2FIX(retval),rb_str_new2(papier));
1904
+ return rb_ary_new3(3,rb_str_new2(dst),rb_str_new2(papier),INT2FIX(retval));
1270
1905
  else
1271
- return rb_ary_new3(3,Qnil,INT2FIX(retval),Qnil);
1906
+ return rb_ary_new3(3,Qnil,Qnil,INT2FIX(retval));
1272
1907
  }
1273
1908
 
1274
1909
  /**
1275
- * ===<tt>KontoCheckRaw::ipi_check(<zweck>)</tt>
1276
- * =====<tt>KontoCheck::ipi_check(<zweck>)</tt>
1910
+ * ===KontoCheckRaw::ipi_check( zweck)
1911
+ * =====KontoCheck::ipi_check( zweck)
1277
1912
  *
1278
1913
  * Die Funktion testet, ob ein Strukturierter Verwendungszweck gültig ist
1279
- * (Anzahl Zeichen, Prüfziffer). Die Rückgabe ist ein Statuscode, der die
1280
- * folgenden Werte annehmen kann:
1914
+ * (Anzahl Zeichen, Prüfziffer).
1915
+ *
1916
+ * ====Aufruf:
1917
+ * ret=KontoCheckRaw::ipi_check( zweck)
1918
+ *
1919
+ * ====Parameter:
1920
+ * * zweck: der Strukturierte Verwendungszweck, der getestet werden soll
1921
+ *
1922
+ * ====Rückgabe:
1923
+ * Zurückgegeben wird ein skalarer Statuscode.
1281
1924
  *
1282
- * -73 (IPI_CHECK_INVALID_LENGTH) "Der zu validierende strukturierete Verwendungszweck muß genau 20 Zeichen enthalten"
1283
- * 0 (FALSE) "falsch"
1284
- * 1 (OK) "ok"
1925
+ *
1926
+ * ====Mögliche Statuscodes:
1927
+ * * -73 (IPI_CHECK_INVALID_LENGTH) "Der zu validierende strukturierete Verwendungszweck muß genau 20 Zeichen enthalten"
1928
+ * * 0 (FALSE) "falsch"
1929
+ * * 1 (OK) "ok"
1285
1930
  */
1286
1931
  static VALUE ipi_check_rb(int argc,VALUE* argv,VALUE self)
1287
1932
  {
@@ -1292,9 +1937,9 @@ static VALUE ipi_check_rb(int argc,VALUE* argv,VALUE self)
1292
1937
  }
1293
1938
 
1294
1939
  /**
1295
- * ====<tt>KontoCheckRaw::bank_valid(blz [,filiale])</tt>
1296
- * ====== <tt>KontoCheck::bank_valid(blz [,filiale])</tt>
1297
- * ====== <tt>KontoCheck::bank_valid?(blz [,filiale])</tt>
1940
+ * ====KontoCheckRaw::bank_valid( blz [,filiale])
1941
+ * ====== KontoCheck::bank_valid( blz [,filiale])
1942
+ * ====== KontoCheck::bank_valid?( blz [,filiale])
1298
1943
  * Diese Funktion testet, ob eine gegebene BLZ gültig ist. Der Rückgabewert ist ein
1299
1944
  * Statuscode mit den unten angegebenen Werten. Falls das Argument filiale auch
1300
1945
  * angegeben ist, wird zusätzlich noch getestet, ob eine Filiale mit dem gegebenen
@@ -1320,8 +1965,8 @@ static VALUE bank_valid(int argc,VALUE* argv,VALUE self)
1320
1965
  }
1321
1966
 
1322
1967
  /**
1323
- * ===<tt>KontoCheckRaw::bank_filialen(blz)</tt>
1324
- * =====<tt>KontoCheck::bank_filialen(blz)</tt>
1968
+ * ===KontoCheckRaw::bank_filialen( blz)
1969
+ * =====KontoCheck::bank_filialen( blz)
1325
1970
  *
1326
1971
  * Diese Funktion liefert die Anzahl Filialen einer Bank (inklusive Hauptstelle).
1327
1972
  * Die LUT-Datei muß dazu natürlich mit den Filialdaten generiert sein, sonst
@@ -1350,8 +1995,8 @@ static VALUE bank_filialen(int argc,VALUE* argv,VALUE self)
1350
1995
  }
1351
1996
 
1352
1997
  /**
1353
- * ===<tt>KontoCheckRaw::bank_alles(blz[,filiale])</tt>
1354
- * =====<tt>KontoCheck::bank_alles(blz[,filiale])</tt>
1998
+ * ===KontoCheckRaw::bank_alles( blz [,filiale])
1999
+ * =====KontoCheck::bank_alles( blz [,filiale])
1355
2000
  *
1356
2001
  * Dies ist eine Mammutfunktion, die alle vorhandenen Informationen über eine
1357
2002
  * Bank zurückliefert. Das Ergebnis ist ein Array mit den folgenden Komponenten:
@@ -1422,8 +2067,8 @@ static VALUE bank_alles(int argc,VALUE* argv,VALUE self)
1422
2067
  }
1423
2068
 
1424
2069
  /**
1425
- * ===<tt>KontoCheckRaw::bank_name(blz[,filiale])</tt>
1426
- * =====<tt>KontoCheck::bank_name(blz[,filiale])</tt>
2070
+ * ===KontoCheckRaw::bank_name( blz [,filiale])
2071
+ * =====KontoCheck::bank_name( blz [,filiale])
1427
2072
  *
1428
2073
  * Diese Funktion liefert den Namen einer Bank. Der Rückgabewert ist ein
1429
2074
  * Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im
@@ -1451,8 +2096,8 @@ static VALUE bank_name(int argc,VALUE* argv,VALUE self)
1451
2096
  }
1452
2097
 
1453
2098
  /**
1454
- * ===<tt>KontoCheckRaw::bank_name_kurz(blz [,filiale])</tt>
1455
- * =====<tt>KontoCheck::bank_name_kurz(blz [,filiale])</tt>
2099
+ * ===KontoCheckRaw::bank_name_kurz( blz [,filiale])
2100
+ * =====KontoCheck::bank_name_kurz( blz [,filiale])
1456
2101
  *
1457
2102
  * Diese Funktion liefert den Kurznamen einer Bank. Der Rückgabewert ist ein
1458
2103
  * Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im
@@ -1480,8 +2125,8 @@ static VALUE bank_name_kurz(int argc,VALUE* argv,VALUE self)
1480
2125
  }
1481
2126
 
1482
2127
  /**
1483
- * ===<tt>KontoCheckRaw::bank_ort(blz[,filiale])</tt>
1484
- * =====<tt>KontoCheck::bank_ort(blz[,filiale])</tt>
2128
+ * ===KontoCheckRaw::bank_ort( blz [,filiale])
2129
+ * =====KontoCheck::bank_ort( blz [,filiale])
1485
2130
  *
1486
2131
  * Diese Funktion liefert den Ort einer Bank. Falls der Parameter filiale nicht
1487
2132
  * angegeben ist, wird der Sitz der Hauptstelle ausgegeben. Der Rückgabewert
@@ -1511,8 +2156,8 @@ static VALUE bank_ort(int argc,VALUE* argv,VALUE self)
1511
2156
  }
1512
2157
 
1513
2158
  /**
1514
- * ===<tt>KontoCheckRaw::bank_plz(blz [,filiale])</tt>
1515
- * =====<tt>KontoCheck::bank_plz(blz [,filiale])</tt>
2159
+ * ===KontoCheckRaw::bank_plz( blz [,filiale])
2160
+ * =====KontoCheck::bank_plz( blz [,filiale])
1516
2161
  *
1517
2162
  * Diese Funktion liefert die Postleitzahl einer Bank. Falls der Parameter
1518
2163
  * filiale nicht angegeben ist, wird die PLZ der Hauptstelle ausgegeben. Der
@@ -1540,8 +2185,8 @@ static VALUE bank_plz(int argc,VALUE* argv,VALUE self)
1540
2185
  }
1541
2186
 
1542
2187
  /**
1543
- * ===<tt>KontoCheckRaw::bank_pz(blz)</tt>
1544
- * =====<tt>KontoCheck::bank_pz(blz)</tt>
2188
+ * ===KontoCheckRaw::bank_pz( blz)
2189
+ * =====KontoCheck::bank_pz( blz)
1545
2190
  *
1546
2191
  * Diese Funktion liefert die Prüfziffer einer Bank. Die Funktion unterstützt
1547
2192
  * keine Filialen; zu jeder BLZ kann es in der LUT-Datei nur eine
@@ -1570,8 +2215,8 @@ static VALUE bank_pz(int argc,VALUE* argv,VALUE self)
1570
2215
  }
1571
2216
 
1572
2217
  /**
1573
- * ===<tt>KontoCheckRaw::bank_bic(blz[,filiale])</tt>
1574
- * =====<tt>KontoCheck::bank_bic(blz[,filiale])</tt>
2218
+ * ===KontoCheckRaw::bank_bic( blz [,filiale])
2219
+ * =====KontoCheck::bank_bic( blz [,filiale])
1575
2220
  *
1576
2221
  * Diese Funktion liefert den BIC (Bank Identifier Code) einer Bank. Der
1577
2222
  * Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String
@@ -1600,8 +2245,8 @@ static VALUE bank_bic(int argc,VALUE* argv,VALUE self)
1600
2245
  }
1601
2246
 
1602
2247
  /**
1603
- * ===<tt>KontoCheckRaw::bank_aenderung(blz [,filiale])</tt>
1604
- * =====<tt>KontoCheck::bank_aenderung(blz [,filiale])</tt>
2248
+ * ===KontoCheckRaw::bank_aenderung( blz [,filiale])
2249
+ * =====KontoCheck::bank_aenderung( blz [,filiale])
1605
2250
  *
1606
2251
  * Diese Funktion liefert das 'Änderung' Flag einer Bank (als string).
1607
2252
  * Mögliche Werte sind: A (Addition), M (Modified), U (Unchanged), D
@@ -1631,8 +2276,8 @@ static VALUE bank_aenderung(int argc,VALUE* argv,VALUE self)
1631
2276
  }
1632
2277
 
1633
2278
  /**
1634
- * ===<tt>KontoCheck::bank_loeschung(blz [,filiale])</tt>
1635
- * =====<tt>KontoCheckRaw::bank_loeschung(blz [,filiale])</tt>
2279
+ * ===KontoCheckRaw::bank_loeschung( blz [,filiale])
2280
+ * =====KontoCheck::bank_loeschung( blz [,filiale])
1636
2281
  *
1637
2282
  * Diese Funktion liefert das Lösch-Flag für eine Bank zurück (als Integer;
1638
2283
  * mögliche Werte sind 0 und 1). Der Rückgabewert ist ein Array mit zwei
@@ -1660,8 +2305,8 @@ static VALUE bank_loeschung(int argc,VALUE* argv,VALUE self)
1660
2305
  }
1661
2306
 
1662
2307
  /**
1663
- * ===<tt>KontoCheckRaw::bank_nachfolge_blz(blz [,filiale])</tt>
1664
- * =====<tt>KontoCheck::bank_nachfolge_blz(blz [,filiale])</tt>
2308
+ * ===KontoCheckRaw::bank_nachfolge_blz( blz [,filiale])
2309
+ * =====KontoCheck::bank_nachfolge_blz( blz [,filiale])
1665
2310
  *
1666
2311
  * Diese Funktion liefert die Nachfolge-BLZ für eine Bank, die gelöscht werden
1667
2312
  * soll (bei der das 'Löschung' Flag 1 ist). Der Rückgabewert ist ein Array mit
@@ -1689,10 +2334,8 @@ static VALUE bank_nachfolge_blz(int argc,VALUE* argv,VALUE self)
1689
2334
  }
1690
2335
 
1691
2336
  /**
1692
- * ===<tt>KontoCheckRaw::bank_pan(blz[,filiale])</tt>
1693
- *
1694
- * ===<tt>KontoCheckRaw::bank_pan(blz [,filiale])</tt>
1695
- * =====<tt>KontoCheck::bank_pan(blz [,filiale])</tt>
2337
+ * ===KontoCheckRaw::bank_pan( blz [,filiale])
2338
+ * =====KontoCheck::bank_pan( blz [,filiale])
1696
2339
  *
1697
2340
  * Diese Funktion liefert den PAN (Primary Account Number) einer Bank. Der
1698
2341
  * Rückgabewert ist ein Array mit zwei Elementen: im ersten steht der PAN, im
@@ -1719,8 +2362,8 @@ static VALUE bank_pan(int argc,VALUE* argv,VALUE self)
1719
2362
  }
1720
2363
 
1721
2364
  /**
1722
- * ===<tt>KontoCheck::bank_nr(blz [,filiale])</tt>
1723
- * =====<tt>KontoCheckRaw::bank_nr(blz[,filiale])</tt>
2365
+ * ===KontoCheckRaw::bank_nr( blz [,filiale])
2366
+ * =====KontoCheck::bank_nr( blz [,filiale])
1724
2367
  *
1725
2368
  * Diese Funktion liefert die laufende Nummer einer Bank (internes Feld der
1726
2369
  * BLZ-Datei). Der Wert wird wahrscheinlich nicht oft benötigt, ist aber der
@@ -1835,18 +2478,75 @@ static VALUE bank_nr(int argc,VALUE* argv,VALUE self)
1835
2478
  *
1836
2479
  */
1837
2480
 
2481
+ /* bank_suche_int(): dies ist die generische Suchfunktion für alle Textsuchen.
2482
+ * Die jeweilige Suchfunktion der C-Bibliothek wird durch einen
2483
+ * Funktionspointer (letztes Argument) festgelegt.
2484
+ */
2485
+ static VALUE bank_suche_int(int argc,VALUE* argv,VALUE self,int (*suchfkt_s)(char*,int*,int**,int**,char***,int**),
2486
+ int (*suchfkt_i)(int,int,int*,int**,int**,int**,int**))
2487
+ {
2488
+ char such_name[128],**base_name,error_msg[512];
2489
+ int i,j,k,retval,such1,such2,anzahl,anzahl2,last_blz,uniq,*start_idx,*zweigstelle,*blz_base,*base_name_i;
2490
+ int *idx_o,*cnt_o;
2491
+ VALUE ret_blz,ret_idx,ret_suche;
2492
+
2493
+ if(suchfkt_s){
2494
+ get_params(argc,argv,such_name,NULL,NULL,&uniq,7);
2495
+ retval=(*suchfkt_s)(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
2496
+ }
2497
+ else{
2498
+ get_params_int(argc,argv,&such1,&such2,&uniq);
2499
+ if(!such2)such2=such1;
2500
+ retval=(*suchfkt_i)(such1,such2,&anzahl,&start_idx,&zweigstelle,&base_name_i,&blz_base);
2501
+ }
2502
+ if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
2503
+ if(retval<0)RUNTIME_ERROR(retval);
2504
+ if(uniq) /* bei uniq>0 sortieren, uniq>1 sortieren + uniq */
2505
+ lut_suche_sort1(anzahl,blz_base,zweigstelle,start_idx,&anzahl2,&idx_o,&cnt_o,uniq>1);
2506
+ else{
2507
+ anzahl2=anzahl;
2508
+ idx_o=start_idx;
2509
+ cnt_o=NULL;
2510
+ }
2511
+ ret_suche=rb_ary_new2(anzahl2);
2512
+ ret_blz=rb_ary_new2(anzahl2);
2513
+ ret_idx=rb_ary_new2(anzahl2);
2514
+ for(i=k=0,last_blz=-1;i<anzahl2;i++){
2515
+ j=idx_o[i]; /* Index innerhalb der BLZ-Datei */
2516
+ if(uniq>1 && blz_base[j]==last_blz)
2517
+ continue;
2518
+ else
2519
+ last_blz=blz_base[j];
2520
+ if(suchfkt_s)
2521
+ rb_ary_store(ret_suche,k,rb_str_new2(base_name[j]));
2522
+ else{
2523
+ if(suchfkt_i==lut_suche_regel)
2524
+ rb_ary_store(ret_suche,k,INT2FIX(base_name_i[j]/100)); /* nur die Regel ausgeben, ohne Version */
2525
+ else
2526
+ rb_ary_store(ret_suche,k,INT2FIX(base_name_i[j]));
2527
+ }
2528
+ rb_ary_store(ret_blz,k,INT2FIX(blz_base[j]));
2529
+ rb_ary_store(ret_idx,k++,INT2FIX(zweigstelle[j]));
2530
+ }
2531
+ if(uniq){
2532
+ kc_free((char*)idx_o);
2533
+ kc_free((char*)cnt_o);
2534
+ }
2535
+ return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl2));
2536
+ }
2537
+
1838
2538
  /**
1839
- * ===<tt>KontoCheckRaw::bank_suche_bic(search_bic)</tt>
1840
- * =====<tt>KontoCheck::suche()</tt>
2539
+ * ===KontoCheckRaw::bank_suche_bic( search_bic [,sort_uniq [,sort]])
2540
+ * =====KontoCheck::suche()
1841
2541
  *
1842
2542
  * Diese Funktion sucht alle Banken, deren BIC mit dem angegebenen Wert <search_bic> beginnen.
1843
2543
  * Die Rückgabe ist ein Array mit fünf Elementen:
1844
2544
  *
1845
- * 0. Das erste Element ist ein Array mit den gefundenen BIC-Werten
1846
- * 1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
1847
- * 2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
1848
- * 3. das vierte Element ist der Statuscode (s.u.)
1849
- * 4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2545
+ * * Das erste Element ist ein Array mit den gefundenen BIC-Werten
2546
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2547
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2548
+ * * das vierte Element ist der Statuscode (s.u.)
2549
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
1850
2550
  *
1851
2551
  * Mögliche Statuscodes:
1852
2552
  *
@@ -1859,38 +2559,21 @@ static VALUE bank_nr(int argc,VALUE* argv,VALUE self)
1859
2559
  */
1860
2560
  static VALUE bank_suche_bic(int argc,VALUE* argv,VALUE self)
1861
2561
  {
1862
- char such_name[128],**base_name,error_msg[512];
1863
- int i,j,retval,anzahl,*start_idx,*zweigstelle,*blz_base;
1864
- VALUE ret_blz,ret_idx,ret_suche;
1865
-
1866
- get_params(argc,argv,such_name,NULL,NULL,NULL,3);
1867
- retval=lut_suche_bic(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
1868
- if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
1869
- if(retval<0)RUNTIME_ERROR(retval);
1870
- ret_suche=rb_ary_new2(anzahl);
1871
- ret_blz=rb_ary_new2(anzahl);
1872
- ret_idx=rb_ary_new2(anzahl);
1873
- for(i=0;i<anzahl;i++){
1874
- j=start_idx[i]; /* Index innerhalb der BLZ-Datei */
1875
- rb_ary_store(ret_suche,i,rb_str_new2(base_name[j]));
1876
- rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
1877
- rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
1878
- }
1879
- return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
2562
+ return bank_suche_int(argc,argv,self,lut_suche_bic,NULL);
1880
2563
  }
1881
2564
 
1882
2565
  /**
1883
- * ===<tt>KontoCheckRaw::bank_suche_namen(name)</tt>
1884
- * =====<tt>KontoCheck::suche()</tt>
2566
+ * ===KontoCheckRaw::bank_suche_namen( name [,sort_uniq [,sort]])
2567
+ * =====KontoCheck::suche()
1885
2568
  *
1886
- * Diese Funktion sucht alle Banken, deren Namen mit dem angegebenen Wert <search_bic> beginnen.
2569
+ * Diese Funktion sucht alle Banken, deren Namen mit dem angegebenen Wert <name> beginnen.
1887
2570
  * Die Rückgabe ist ein Array mit fünf Elementen:
1888
2571
  *
1889
- * 0. Das erste Element ist ein Array mit den gefundenen Namenswerten
1890
- * 1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
1891
- * 2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
1892
- * 3. das vierte Element ist der Statuscode (s.u.)
1893
- * 4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2572
+ * * Das erste Element ist ein Array mit den gefundenen Namen
2573
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2574
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2575
+ * * das vierte Element ist der Statuscode (s.u.)
2576
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
1894
2577
  *
1895
2578
  * Mögliche Statuscodes:
1896
2579
  *
@@ -1903,38 +2586,21 @@ static VALUE bank_suche_bic(int argc,VALUE* argv,VALUE self)
1903
2586
  */
1904
2587
  static VALUE bank_suche_namen(int argc,VALUE* argv,VALUE self)
1905
2588
  {
1906
- char such_name[128],**base_name,error_msg[512];
1907
- int i,j,retval,anzahl,*start_idx,*zweigstelle,*blz_base;
1908
- VALUE ret_blz,ret_idx,ret_suche;
1909
-
1910
- get_params(argc,argv,such_name,NULL,NULL,NULL,3);
1911
- retval=lut_suche_namen(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
1912
- if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
1913
- if(retval<0)RUNTIME_ERROR(retval);
1914
- ret_suche=rb_ary_new2(anzahl);
1915
- ret_blz=rb_ary_new2(anzahl);
1916
- ret_idx=rb_ary_new2(anzahl);
1917
- for(i=0;i<anzahl;i++){
1918
- j=start_idx[i]; /* Index innerhalb der BLZ-Datei */
1919
- rb_ary_store(ret_suche,i,rb_str_new2(base_name[j]));
1920
- rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
1921
- rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
1922
- }
1923
- return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
2589
+ return bank_suche_int(argc,argv,self,lut_suche_namen,NULL);
1924
2590
  }
1925
2591
 
1926
2592
  /**
1927
- * ===<tt>KontoCheckRaw::bank_suche_namen_kurz(short_name)</tt>
1928
- * =====<tt>KontoCheck::suche()</tt>
2593
+ * ===KontoCheckRaw::bank_suche_namen_kurz( short_name [,sort_uniq [,sort]])
2594
+ * =====KontoCheck::suche()
1929
2595
  *
1930
2596
  * Diese Funktion sucht alle Banken, deren Kurznamen mit dem angegebenen Wert <search_bic> beginnen.
1931
2597
  * Die Rückgabe ist ein Array mit fünf Elementen:
1932
2598
  *
1933
- * 0. Das erste Element ist ein Array mit den gefundenen Namenswerten
1934
- * 1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
1935
- * 2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
1936
- * 3. das vierte Element ist der Statuscode (s.u.)
1937
- * 4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2599
+ * * Das erste Element ist ein Array mit den gefundenen Kurznamen
2600
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2601
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2602
+ * * das vierte Element ist der Statuscode (s.u.)
2603
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
1938
2604
  *
1939
2605
  * Mögliche Statuscodes:
1940
2606
  *
@@ -1947,39 +2613,22 @@ static VALUE bank_suche_namen(int argc,VALUE* argv,VALUE self)
1947
2613
  */
1948
2614
  static VALUE bank_suche_namen_kurz(int argc,VALUE* argv,VALUE self)
1949
2615
  {
1950
- char such_name[128],**base_name,error_msg[512];
1951
- int i,j,retval,anzahl,*start_idx,*zweigstelle,*blz_base;
1952
- VALUE ret_blz,ret_idx,ret_suche;
1953
-
1954
- get_params(argc,argv,such_name,NULL,NULL,NULL,3);
1955
- retval=lut_suche_namen_kurz(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
1956
- if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
1957
- if(retval<0)RUNTIME_ERROR(retval);
1958
- ret_suche=rb_ary_new2(anzahl);
1959
- ret_blz=rb_ary_new2(anzahl);
1960
- ret_idx=rb_ary_new2(anzahl);
1961
- for(i=0;i<anzahl;i++){
1962
- j=start_idx[i]; /* Index innerhalb der BLZ-Datei */
1963
- rb_ary_store(ret_suche,i,rb_str_new2(base_name[j]));
1964
- rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
1965
- rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
1966
- }
1967
- return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
2616
+ return bank_suche_int(argc,argv,self,lut_suche_namen_kurz,NULL);
1968
2617
  }
1969
2618
 
1970
2619
  /**
1971
- * ===<tt>KontoCheckRaw::bank_suche_plz(plz1[,plz2])</tt>
1972
- * =====<tt>KontoCheck::suche()</tt>
2620
+ * ===KontoCheckRaw::bank_suche_plz( plz1 [,plz2 [,sort_uniq [,sort]]])
2621
+ * =====KontoCheck::suche()
1973
2622
  *
1974
2623
  * Diese Funktion sucht alle Banken, deren PLZ gleich <plz1> ist oder (bei
1975
- * Angabe von plz2) die im Bereich zwischen <plz1> und <plz2> liegen.. Die
2624
+ * Angabe von plz2) die im Bereich zwischen <plz1> und <plz2> liegen. Die
1976
2625
  * Rückgabe ist ein Array mit fünf Elementen:
1977
2626
  *
1978
- * 0. Das erste Element ist ein Array mit den gefundenen Namenswerten
1979
- * 1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
1980
- * 2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
1981
- * 3. das vierte Element ist der Statuscode (s.u.)
1982
- * 4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2627
+ * * Das erste Element ist ein Array mit den gefundenen Postleitzahlen
2628
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2629
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2630
+ * * das vierte Element ist der Statuscode (s.u.)
2631
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
1983
2632
  *
1984
2633
  * Mögliche Statuscodes:
1985
2634
  *
@@ -1992,39 +2641,22 @@ static VALUE bank_suche_namen_kurz(int argc,VALUE* argv,VALUE self)
1992
2641
  */
1993
2642
  static VALUE bank_suche_plz(int argc,VALUE* argv,VALUE self)
1994
2643
  {
1995
- char error_msg[512];
1996
- int i,j,retval,such1,such2,anzahl,*start_idx,*base_name,*zweigstelle,*blz_base;
1997
- VALUE ret_blz,ret_idx,ret_suche;
1998
-
1999
- get_params_int(argc,argv,&such1,&such2);
2000
- retval=lut_suche_plz(such1,such2,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
2001
- if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
2002
- if(retval<0)RUNTIME_ERROR(retval);
2003
- ret_suche=rb_ary_new2(anzahl);
2004
- ret_blz=rb_ary_new2(anzahl);
2005
- ret_idx=rb_ary_new2(anzahl);
2006
- for(i=0;i<anzahl;i++){
2007
- j=start_idx[i]; /* Index innerhalb der BLZ-Datei */
2008
- rb_ary_store(ret_suche,i,INT2FIX(base_name[j]));
2009
- rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
2010
- rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
2011
- }
2012
- return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
2644
+ return bank_suche_int(argc,argv,self,NULL,lut_suche_plz);
2013
2645
  }
2014
2646
 
2015
2647
  /**
2016
- * ===<tt>KontoCheckRaw::bank_suche_pz(pz1[,pz2])</tt>
2017
- * =====<tt>KontoCheck::suche()</tt>
2648
+ * === KontoCheckRaw::bank_suche_pz( pz1 [,pz2 [,sort_uniq [,sort]]])
2649
+ * ===== KontoCheck::suche()
2018
2650
  *
2019
2651
  * Diese Funktion sucht alle Banken, deren Prüfziffer gleich <pz1> ist oder (bei
2020
- * Angabe von pz2) die im Bereich zwischen <pz1> und <pz2> liegen.. Die
2652
+ * Angabe von pz2) die im Bereich zwischen <pz1> und <pz2> liegen. Die
2021
2653
  * Rückgabe ist ein Array mit fünf Elementen:
2022
2654
  *
2023
- * 0. Das erste Element ist ein Array mit den gefundenen Prüfziffern
2024
- * 1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2025
- * 2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2026
- * 3. das vierte Element ist der Statuscode (s.u.)
2027
- * 4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2655
+ * * Das erste Element ist ein Array mit den gefundenen Prüfziffern
2656
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2657
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2658
+ * * das vierte Element ist der Statuscode (s.u.)
2659
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2028
2660
  *
2029
2661
  * Mögliche Statuscodes:
2030
2662
  *
@@ -2037,46 +2669,25 @@ static VALUE bank_suche_plz(int argc,VALUE* argv,VALUE self)
2037
2669
  */
2038
2670
  static VALUE bank_suche_pz(int argc,VALUE* argv,VALUE self)
2039
2671
  {
2040
- char error_msg[512];
2041
- int i,j,retval,such1,such2,anzahl,*start_idx,*base_name,*zweigstelle,*blz_base;
2042
- VALUE ret_blz,ret_idx,ret_suche;
2043
-
2044
- get_params_int(argc,argv,&such1,&such2);
2045
- retval=lut_suche_pz(such1,such2,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
2046
- if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
2047
- if(retval<0)RUNTIME_ERROR(retval);
2048
- ret_suche=rb_ary_new2(anzahl);
2049
- ret_blz=rb_ary_new2(anzahl);
2050
- ret_idx=rb_ary_new2(anzahl);
2051
- for(i=0;i<anzahl;i++){
2052
- j=start_idx[i]; /* Index innerhalb der BLZ-Datei */
2053
- rb_ary_store(ret_suche,i,INT2FIX(base_name[j]));
2054
- rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
2055
- rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
2056
- }
2057
- return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
2672
+ return bank_suche_int(argc,argv,self,NULL,lut_suche_pz);
2058
2673
  }
2059
2674
 
2060
2675
  /**
2061
- * ===<tt>KontoCheckRaw::bank_suche_blz(blz1[,blz2])</tt>
2062
- * =====<tt>KontoCheck::suche()</tt>
2676
+ * ===KontoCheckRaw::bank_suche_blz( blz1 [,blz2 [,uniq]])
2677
+ * =====KontoCheck::suche()
2063
2678
  *
2064
2679
  * Diese Funktion sucht alle Banken, deren Bankleitzahl gleich <blz1> ist oder (bei
2065
- * Angabe von blz2) die im Bereich zwischen <blz1> und <blz2> liegen.. Die
2680
+ * Angabe von blz2) die im Bereich zwischen <blz1> und <blz2> liegen. Die
2066
2681
  * Rückgabe ist ein Array mit fünf Elementen:
2067
2682
  *
2068
- * 0. Das erste Element ist ein Array mit den gefundenen Bankleitzahlen
2069
- * 1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen (bei dieser Funktion doppelt gemoppelt :-) )
2070
- * 2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2071
- * 3. das vierte Element ist der Statuscode (s.u.)
2072
- * 4. das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2683
+ * * Das erste Element ist ein Array mit den gefundenen Bankleitzahlen
2684
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen (bei dieser Funktion doppelt gemoppelt :-) )
2685
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2686
+ * * das vierte Element ist der Statuscode (s.u.)
2687
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2073
2688
  *
2074
2689
  * Mögliche Statuscodes:
2075
2690
  *
2076
- * find all banks with bic between blz1 and blz2
2077
- *
2078
- * possible return values (and short description):
2079
- *
2080
2691
  * -78 (KEY_NOT_FOUND) "Die Suche lieferte kein Ergebnis"
2081
2692
  * -70 (LUT1_FILE_USED) "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
2082
2693
  * -53 (LUT2_BLZ_NOT_INITIALIZED) "Das Feld BLZ wurde nicht initialisiert"
@@ -2086,34 +2697,75 @@ static VALUE bank_suche_pz(int argc,VALUE* argv,VALUE self)
2086
2697
  */
2087
2698
  static VALUE bank_suche_blz(int argc,VALUE* argv,VALUE self)
2088
2699
  {
2089
- char error_msg[512];
2090
- int i,j,retval,such1,such2,anzahl,*start_idx,*base_name,*zweigstelle,*blz_base;
2091
- VALUE ret_blz,ret_idx,ret_suche;
2092
-
2093
- get_params_int(argc,argv,&such1,&such2);
2094
- retval=lut_suche_blz(such1,such2,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
2095
- if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
2096
- if(retval<0)RUNTIME_ERROR(retval);
2097
- ret_suche=rb_ary_new2(anzahl);
2098
- ret_blz=rb_ary_new2(anzahl);
2099
- ret_idx=rb_ary_new2(anzahl);
2100
- for(i=0;i<anzahl;i++){
2101
- j=start_idx[i]; /* Index innerhalb der BLZ-Datei */
2102
- rb_ary_store(ret_suche,i,INT2FIX(base_name[j]));
2103
- rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
2104
- rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
2105
- }
2106
- return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
2700
+ return bank_suche_int(argc,argv,self,NULL,lut_suche_blz);
2107
2701
  }
2108
2702
 
2109
2703
  /**
2110
- * ===<tt>KontoCheckRaw::bank_suche_ort(suchort)</tt>
2111
- * =====<tt>KontoCheck::suche()</tt>
2704
+ * ===KontoCheckRaw::bank_suche_ort( suchort [,uniq])
2705
+ * =====KontoCheck::suche()
2112
2706
  *
2113
2707
  * Diese Funktion sucht alle Banken, deren Sitz mit dem angegebenen Wert <suchort> beginnen.
2114
2708
  * Die Rückgabe ist ein Array mit fünf Elementen:
2115
2709
  *
2116
- * 0. Das erste Element ist ein Array mit den gefundenen Orten
2710
+ * * Das erste Element ist ein Array mit den gefundenen Orten
2711
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2712
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2713
+ * * das vierte Element ist der Statuscode (s.u.)
2714
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2715
+ *
2716
+ * Mögliche Statuscodes:
2717
+ *
2718
+ * -78 (KEY_NOT_FOUND) "Die Suche lieferte kein Ergebnis"
2719
+ * -70 (LUT1_FILE_USED) "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
2720
+ * -49 (LUT2_ORT_NOT_INITIALIZED) "Das Feld Ort wurde nicht initialisiert"
2721
+ * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
2722
+ * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
2723
+ * 1 (OK) "ok"
2724
+ */
2725
+ static VALUE bank_suche_ort(int argc,VALUE* argv,VALUE self)
2726
+ {
2727
+ return bank_suche_int(argc,argv,self,lut_suche_ort,NULL);
2728
+ }
2729
+
2730
+ /**
2731
+ * === KontoCheckRaw::bank_suche_regel( regel1 [,regel2 [,sort_uniq [,sort]]])
2732
+ * ===== KontoCheck::suche()
2733
+ *
2734
+ * Diese Funktion sucht alle Banken, deren IBAN-Regel gleich <regel1> ist oder
2735
+ * (bei Angabe von regel2) die im Bereich zwischen <regel1> und <regel2>
2736
+ * liegen. Die Rückgabe ist ein Array mit fünf Elementen:
2737
+ *
2738
+ * * Das erste Element ist ein Array mit den gefundenen Regeln
2739
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2740
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2741
+ * * das vierte Element ist der Statuscode (s.u.)
2742
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2743
+ *
2744
+ * Mögliche Statuscodes:
2745
+ *
2746
+ * -78 (KEY_NOT_FOUND) "Die Suche lieferte kein Ergebnis"
2747
+ * -70 (LUT1_FILE_USED) "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
2748
+ * -45 (LUT2_PZ_NOT_INITIALIZED) "Das Feld Prüfziffer wurde nicht initialisiert"
2749
+ * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
2750
+ * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
2751
+ * 1 (OK) "ok"
2752
+ */
2753
+ static VALUE bank_suche_regel(int argc,VALUE* argv,VALUE self)
2754
+ {
2755
+ return bank_suche_int(argc,argv,self,NULL,lut_suche_regel);
2756
+ }
2757
+
2758
+ /**
2759
+ * ===KontoCheckRaw::bank_suche_volltext( suchwort [,sort_uniq [,sort]])
2760
+ * =====KontoCheck::suche()
2761
+ *
2762
+ * Diese Funktion sucht alle Banken, bei denen in Name, Kurzname oder Ort das
2763
+ * angegebenen Wort <suchwort> vorkommt. Dabei wird immer nur ein einziges Wort
2764
+ * gesucht; falls mehrere Worte angegeben werden, wird der Fehlerwert
2765
+ * LUT2_VOLLTEXT_SINGLE_WORD_ONLY zurückgegeben. Die Rückgabe ist ein Array mit
2766
+ * fünf Elementen:
2767
+ *
2768
+ * 0. Das erste Element ist ein Array mit den gefundenen Suchworten
2117
2769
  * 1. Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2118
2770
  * 2. Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2119
2771
  * 3. das vierte Element ist der Statuscode (s.u.)
@@ -2121,44 +2773,205 @@ static VALUE bank_suche_blz(int argc,VALUE* argv,VALUE self)
2121
2773
  *
2122
2774
  * Mögliche Statuscodes:
2123
2775
  *
2124
- * LUT1_FILE_USED "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
2125
- * LUT2_NOT_INITIALIZED "die Programmbibliothek wurde noch nicht initialisiert"
2126
- * LUT2_ORT_NOT_INITIALIZED "Das Feld Ort wurde nicht initialisiert"
2127
- * ERROR_MALLOC "kann keinen Speicher allokieren"
2128
- * KEY_NOT_FOUND "Die Suche lieferte kein Ergebnis"
2129
- * OK "ok"
2776
+ * -118 (LUT2_VOLLTEXT_SINGLE_WORD_ONLY) "Die Volltextsuche sucht jeweils nur ein einzelnes Wort; benutzen Sie bank_suche_multiple() zur Suche nach mehreren Worten"
2777
+ * -114 (LUT2_VOLLTEXT_NOT_INITIALIZED) "Das Feld Volltext wurde nicht initialisiert"
2778
+ * -78 (KEY_NOT_FOUND) "Die Suche lieferte kein Ergebnis"
2779
+ * -70 (LUT1_FILE_USED) "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
2780
+ * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
2781
+ * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
2782
+ * 1 (OK) "ok"
2130
2783
  */
2131
- static VALUE bank_suche_ort(int argc,VALUE* argv,VALUE self)
2784
+ static VALUE bank_suche_volltext(int argc,VALUE* argv,VALUE self)
2132
2785
  {
2133
- char such_name[128],**base_name,error_msg[512];
2134
- int i,j,retval,anzahl,*start_idx,*zweigstelle,*blz_base;
2786
+ char such_wort[128],**base_name,error_msg[512];
2787
+ int i,j,k,retval,anzahl,anzahl2,last_blz,uniq,*start_idx,*zweigstelle,*blz_base,base_name_idx,zweigstellen_anzahl;
2788
+ int *idx_o,*cnt_o;
2135
2789
  VALUE ret_blz,ret_idx,ret_suche;
2136
2790
 
2137
- get_params(argc,argv,such_name,NULL,NULL,NULL,3);
2138
- retval=lut_suche_ort(such_name,&anzahl,&start_idx,&zweigstelle,&base_name,&blz_base);
2791
+ get_params(argc,argv,such_wort,NULL,NULL,&uniq,7);
2792
+ retval=lut_suche_volltext(such_wort,&anzahl,&base_name_idx,&base_name,&zweigstellen_anzahl,&start_idx,&zweigstelle,&blz_base);
2139
2793
  if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
2140
2794
  if(retval<0)RUNTIME_ERROR(retval);
2141
2795
  ret_suche=rb_ary_new2(anzahl);
2142
- ret_blz=rb_ary_new2(anzahl);
2143
- ret_idx=rb_ary_new2(anzahl);
2144
- for(i=0;i<anzahl;i++){
2145
- j=start_idx[i]; /* Index innerhalb der BLZ-Datei */
2796
+
2797
+ /* base_name ist hier komplett unabhängig von den Bankleitzahlen; auch
2798
+ * die Größe der beiden Arrays stimmt nicht überein!!! Daher müssen
2799
+ * die gefundenen Volltexte in einer eigenen Schleife gespeichert werden.
2800
+ */
2801
+ for(i=0;i<anzahl;i++){ /* gefundene Volltexte zurückgeben */
2802
+ j=base_name_idx+i;
2146
2803
  rb_ary_store(ret_suche,i,rb_str_new2(base_name[j]));
2147
- rb_ary_store(ret_blz,i,INT2FIX(blz_base[j]));
2148
- rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[j]));
2149
2804
  }
2150
- return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
2805
+ /* die Anzahl der BLZs steht in der Variablen zweigstellen_anzahl */
2806
+ if(uniq) /* bei uniq>0 sortieren, uniq>1 sortieren + uniq */
2807
+ lut_suche_sort1(zweigstellen_anzahl,blz_base,zweigstelle,start_idx,&anzahl2,&idx_o,&cnt_o,uniq>1);
2808
+ else{
2809
+ anzahl2=zweigstellen_anzahl;
2810
+ idx_o=start_idx;
2811
+ cnt_o=NULL;
2812
+ }
2813
+ ret_blz=rb_ary_new2(anzahl2);
2814
+ ret_idx=rb_ary_new2(anzahl2);
2815
+ for(i=k=0,last_blz=-1;i<anzahl2;i++){
2816
+ j=idx_o[i]; /* Index innerhalb der BLZ-Datei */
2817
+ if(uniq>1 && blz_base[j]==last_blz)
2818
+ continue;
2819
+ else
2820
+ last_blz=blz_base[j];
2821
+ rb_ary_store(ret_blz,k,INT2FIX(blz_base[j]));
2822
+ rb_ary_store(ret_idx,k++,INT2FIX(zweigstelle[j]));
2823
+ }
2824
+ if(uniq){
2825
+ kc_free((char*)idx_o);
2826
+ kc_free((char*)cnt_o);
2827
+ }
2828
+ return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl2));
2151
2829
  }
2152
2830
 
2153
2831
  /**
2154
- * ===<tt>KontoCheckRaw::version()</tt>
2155
- * =====<tt>KontoCheck::version()</tt>
2832
+ * ===KontoCheckRaw::bank_suche_multiple( suchtext [,such_cmd] [,uniq])
2833
+ * =====KontoCheck::suche()
2834
+ *
2835
+ * Diese Funktion sucht alle Banken, die mehreren Kriterien entsprechen. Dabei
2836
+ * können bis zu 26 Teilsuchen definiert werden, die beliebig miteinander
2837
+ * verknüpft werden können (additiv, subtraktiv und multiplikativ).
2838
+ *
2839
+ * ====Aufruf:
2840
+ * result=bank_suche_multiple(such_string [,such_cmd] [,uniq])
2841
+ *
2842
+ * ====Parameter:
2843
+ * * such_string: Dieser Parameter gibt die Felder an, nach denen gesucht wird.
2844
+ * Er besteht aus einem oder mehreren Suchbefehlen, die jeweils folgenden
2845
+ * Aufbau haben: [such_index:]suchwert[@suchfeld]
2846
+ *
2847
+ * Der (optionale) Suchindex ist ein Buchstabe von a-z, mit dem das Suchfeld
2848
+ * im Suchkommando (zweiter Parameter) referenziert werden kann. Falls er
2849
+ * nicht angegeben wird, erhält der erste Suchstring den Index a, der zweite
2850
+ * den Index b etc.
2851
+ *
2852
+ * Der Suchwert ist der Wert nach dem gesucht werden soll. Für die Textfelder
2853
+ * ist es der Beginn des Wortes (aa passt z.B. auf Aach, Aachen, Aalen,
2854
+ * Aarbergen), für numerische Felder kann es eine Zahl oder ein Zahlbereich
2855
+ * in der Form 22-33 sein.
2856
+ *
2857
+ * Das Suchfeld gibt an, nach welchem Feld der BLZ-Datei gesucht werden soll.
2858
+ * Falls das Suchfeld nicht angegeben wird, wird eine Volltextsuche (alle
2859
+ * Einzelworte in Name, Kurzname und Ort) gemacht. Die folgende Werte sind
2860
+ * möglich:
2861
+ *
2862
+ * bl BLZ
2863
+ * bi BIC
2864
+ * k Kurzname
2865
+ * n Name
2866
+ * o Ort
2867
+ * pl PLZ
2868
+ * pr Prüfziffer
2869
+ * pz Prüfziffer
2870
+ * v Volltext
2871
+ *
2872
+ * In der obigen Tabelle der Suchfelder sind nur die
2873
+ * Kurzversionen angegeben; eine Angabe wie aa@ort oder
2874
+ * 57000-58000@plz ist auch problemlos möglich.
2875
+ *
2876
+ * * such_cmd: Dieser Parameter gibt an, wie die Teilsuchen miteinander
2877
+ * verknüpft werden sollen. Der Ausdruck abc bedeutet, daß die BLZs in den
2878
+ * Teilsuchen a, b und c enthalten sein müssen; der Ausdruck a+b+c, daß sie
2879
+ * in mindestens einer Teilsuche enthalten sein muß; der Ausdruck a-b, daß
2880
+ * sie in a, aber nicht in b enthalten sein darf (Beispiel s.u.). Falls das
2881
+ * Suchkommando nicht angegeben wird, müssen die Ergebnis-BLZs in allen
2882
+ * Teilsuchen enthalten sein.
2883
+ *
2884
+ * * uniq: Falls dieser Parameter 0 ist, werden alle gefundenen Zweigstellen
2885
+ * ausgegeben; falls er 1 ist, wird für jede Bank nur eine Zweigstelle
2886
+ * ausgegeben. Die Ausgabe ist (anders als bei den anderen Suchroutinen,
2887
+ * bedingt durch die Arbeitsweise der Funktion) immer nach BLZ sortiert.
2888
+ * Falls der Parameter weggelassen wird, wird der Standardwert für uniq aus
2889
+ * konto_check.h benutzt.
2890
+ *
2891
+ * ====Beispiele:
2892
+ * * ret=KontoCheckRaw::bank_suche_multiple( "b:55000000-55100000@blz o:67000-68000@plz sparkasse","bo")
2893
+ * Bei diesem Aufruf werden nur die beiden ersten Teilsuchen (nach BLZ und
2894
+ * PLZ) benutzt; die Suche findet alle Banken mit einer BLZ zwischen 55000000
2895
+ * und 55100000 im PLZ-Bereich 67000 bis 68000.
2896
+ * * ret=KontoCheckRaw::bank_suche_multiple( "b:55000000-55030000@blz o:67000-68000@plz sparkasse","co")
2897
+ * Ähnlicher Aufruf wie oben, allerdings werden nur die beiden letzten Teilsuchen
2898
+ * berücksichtigt.
2899
+ * * ret=KontoCheckRaw::bank_suche_multiple( "67000-68000@plz sparda",0)
2900
+ * Dieser Aufruf gibt alle Filialen der Sparda-Bank im PLZ-Bereich 67000 bis 68000
2901
+ * zurück.
2902
+ * * ret=KontoCheckRaw::bank_suche_multiple( "skat")
2903
+ * Dieser Aufruf ist einfach eine Volltextsuche nach der Skat-Bank. Der
2904
+ * direkte Aufruf von bank_suche_volltext() ist intern natürlich wesentlich
2905
+ * leichtgewichtiger, aber die Suche so auch möglich.
2906
+ *
2907
+ * ====Rückgabe:
2908
+ * Die Rückgabe ist ein Array mit fünf Elementen:
2909
+ *
2910
+ * * Das erste Element ist immer nil (nur für Kompatibilität mit den anderen Suchfunktionen)
2911
+ * * Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
2912
+ * * Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
2913
+ * * das vierte Element ist der Statuscode (s.u.)
2914
+ * * das fünfte Element gibt die Anzahl der gefundenen Banken zurück.
2156
2915
  *
2157
- * Diese Funktion gibt den Versions-String der C-Bibliothek zurück.
2916
+ *
2917
+ * ====Mögliche Statuscodes:
2918
+ * * -70 (LUT1_FILE_USED) "Es wurde eine LUT-Datei im Format 1.0/1.1 geladen"
2919
+ * * -48 (LUT2_NAME_KURZ_NOT_INITIALIZED) "Das Feld Kurzname wurde nicht initialisiert"
2920
+ * * -40 (LUT2_NOT_INITIALIZED) "die Programmbibliothek wurde noch nicht initialisiert"
2921
+ * * -9 (ERROR_MALLOC) "kann keinen Speicher allokieren"
2922
+ * * 1 (OK) "ok"
2923
+ * * 14 (SOME_KEYS_NOT_FOUND) "ok; ein(ige) Schlüssel wurden nicht gefunden"
2924
+ */
2925
+ static VALUE bank_suche_multiple(int argc,VALUE* argv,VALUE self)
2926
+ {
2927
+ char such_text[1280],such_cmd[256],error_msg[512];
2928
+ int i,retval,uniq;
2929
+ UINT4 *blz,*zweigstelle,anzahl;
2930
+ VALUE ret_blz,ret_idx;
2931
+
2932
+ get_params(argc,argv,such_text,such_cmd,NULL,&uniq,6);
2933
+ retval=lut_suche_multiple(such_text,uniq>1,such_cmd,&anzahl,&zweigstelle,&blz);
2934
+ if(retval==KEY_NOT_FOUND || !anzahl)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
2935
+ if(retval<0)RUNTIME_ERROR(retval);
2936
+ ret_blz=rb_ary_new2(anzahl);
2937
+ ret_idx=rb_ary_new2(anzahl);
2938
+ for(i=0;i<(int)anzahl;i++){
2939
+ rb_ary_store(ret_blz,i,INT2FIX(blz[i]));
2940
+ rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[i]));
2941
+ }
2942
+ kc_free((char*)blz);
2943
+ kc_free((char*)zweigstelle);
2944
+ return rb_ary_new3(5,Qnil,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
2945
+ }
2946
+
2947
+
2948
+ /**
2949
+ * ===KontoCheckRaw::version( [mode] )
2950
+ * =====KontoCheck::version( [mode] )
2951
+ *
2952
+ * Diese Funktion gibt die Versions-Infos der C-Bibliothek zurück.
2953
+ *
2954
+ * ====Mögliche Werte für mode:
2955
+ * * 0 bzw. ohne Parameter: Versionsstring der C-Bibliothek
2956
+ * * 1: Versionsnummer
2957
+ * * 2: Versionsdatum
2958
+ * * 3: Compilerdatum und -zeit
2959
+ * * 4: Datum der Prüfziffermethoden
2960
+ * * 5: Datum der IBAN-Regeln
2961
+ * * 6: Klartext-Datum der Bibliotheksversion
2962
+ * * 7: Versionstyp (devel, beta, final)
2158
2963
  */
2159
2964
  static VALUE version_rb(int argc,VALUE* argv,VALUE self)
2160
2965
  {
2161
- return rb_str_new2(get_kto_check_version());
2966
+ int level;
2967
+ VALUE level_rb;
2968
+
2969
+ rb_scan_args(argc,argv,"01",&level_rb);
2970
+ if(NIL_P(level_rb))
2971
+ level=0;
2972
+ else
2973
+ level=NUM2INT(level_rb);
2974
+ return rb_str_new2(get_kto_check_version_x(level));
2162
2975
  }
2163
2976
 
2164
2977
  /**
@@ -2168,18 +2981,23 @@ void Init_konto_check_raw()
2168
2981
  {
2169
2982
  /*
2170
2983
  * This is a C/Ruby library to check the validity of German Bank Account
2171
- * Numbers. All currently defined test methods by Deutsche Bundesbank (April
2172
- * 2011: 00 to D8) are implemented.
2984
+ * Numbers. All currently defined test methods by Deutsche Bundesbank
2985
+ * (March 2013: 00 to E0) are implemented.
2173
2986
  *
2174
- * <b>ATTENTION:</b> There are a few important changes in the API between version 0.0.2 (version
2175
- * by Peter Horn/Provideal), version 0.0.6 (jeanmartin) and this version:
2987
+ * <b>ATTENTION:</b> There are a few important changes in the API between
2988
+ * version 0.0.2 (version by Peter Horn/Provideal), version 0.0.6 (jeanmartin)
2989
+ * and this version:
2176
2990
  *
2177
- * * The function KontoCheck::load_bank_data() is no longer used; it is replaced by KontoCheck::init() and KontoCheck::generate_lutfile().
2178
- * * The function KontoCheck::konto_check(blz,kto) changed the order of parameters from (kto,blz) to (blz,kto)
2991
+ * * The function KontoCheck::load_bank_data() is no longer used; it is
2992
+ * replaced by KontoCheck::init() and KontoCheck::generate_lutfile().
2993
+ * * The function KontoCheck::konto_check( blz,kto) changed the order of
2994
+ * parameters from (kto,blz) to (blz,kto)
2179
2995
  *
2180
2996
  * Another change affects only the version 0.0.6 by jeanmartin:
2181
2997
  *
2182
- * * In KontoCheck::init(level,name,set) the order of the two first parameters is now free; the order is determined by the type of the variable (level is integer, filename string).
2998
+ * * In KontoCheck::init( level,name,set) the order of the two first parameters
2999
+ * is now free; the order is determined by the type of the variable (level is
3000
+ * integer, filename string).
2183
3001
  *
2184
3002
  * Because this class is inteded for german bank accounts, the rest of the
2185
3003
  * documentation is in german too.
@@ -2258,6 +3076,8 @@ void Init_konto_check_raw()
2258
3076
  rb_define_module_function(KontoCheck,"free",free_rb,0);
2259
3077
  rb_define_module_function(KontoCheck,"konto_check",konto_check,-1);
2260
3078
  rb_define_module_function(KontoCheck,"konto_check_pz",konto_check_pz,-1);
3079
+ rb_define_module_function(KontoCheck,"konto_check_regel",konto_check_regel,-1);
3080
+ rb_define_module_function(KontoCheck,"konto_check_regel_dbg",konto_check_regel_dbg,-1);
2261
3081
  rb_define_module_function(KontoCheck,"bank_valid",bank_valid,-1);
2262
3082
  rb_define_module_function(KontoCheck,"bank_filialen",bank_filialen,-1);
2263
3083
  rb_define_module_function(KontoCheck,"bank_alles",bank_alles,-1);
@@ -2273,6 +3093,8 @@ void Init_konto_check_raw()
2273
3093
  rb_define_module_function(KontoCheck,"bank_loeschung",bank_loeschung,-1);
2274
3094
  rb_define_module_function(KontoCheck,"bank_nachfolge_blz",bank_nachfolge_blz,-1);
2275
3095
  rb_define_module_function(KontoCheck,"dump_lutfile",dump_lutfile_rb,-1);
3096
+ rb_define_module_function(KontoCheck,"lut_blocks",lut_blocks_rb,-1);
3097
+ rb_define_module_function(KontoCheck,"lut_blocks1",lut_blocks1_rb,-1);
2276
3098
  rb_define_module_function(KontoCheck,"lut_info",lut_info_rb,-1);
2277
3099
  rb_define_module_function(KontoCheck,"keep_raw_data",keep_raw_data_rb,1);
2278
3100
  rb_define_module_function(KontoCheck,"encoding",encoding_rb,-1);
@@ -2284,6 +3106,7 @@ void Init_konto_check_raw()
2284
3106
  rb_define_module_function(KontoCheck,"retval2html",retval2html_rb,1);
2285
3107
  rb_define_module_function(KontoCheck,"retval2utf8",retval2utf8_rb,1);
2286
3108
  rb_define_module_function(KontoCheck,"generate_lutfile",generate_lutfile_rb,-1);
3109
+ rb_define_module_function(KontoCheck,"ci_check",ci_check_rb,1);
2287
3110
  rb_define_module_function(KontoCheck,"iban_check",iban_check_rb,-1);
2288
3111
  rb_define_module_function(KontoCheck,"iban2bic",iban2bic_rb,-1);
2289
3112
  rb_define_module_function(KontoCheck,"iban_gen",iban_gen_rb,-1);
@@ -2296,18 +3119,85 @@ void Init_konto_check_raw()
2296
3119
  rb_define_module_function(KontoCheck,"bank_suche_blz",bank_suche_blz,-1);
2297
3120
  rb_define_module_function(KontoCheck,"bank_suche_plz",bank_suche_plz,-1);
2298
3121
  rb_define_module_function(KontoCheck,"bank_suche_pz",bank_suche_pz,-1);
2299
- rb_define_module_function(KontoCheck,"version",version_rb,0);
3122
+ rb_define_module_function(KontoCheck,"bank_suche_regel",bank_suche_regel,-1);
3123
+ rb_define_module_function(KontoCheck,"bank_suche_volltext",bank_suche_volltext,-1);
3124
+ rb_define_module_function(KontoCheck,"bank_suche_multiple",bank_suche_multiple,-1);
3125
+ rb_define_module_function(KontoCheck,"version",version_rb,-1);
2300
3126
  rb_define_module_function(KontoCheck,"load_bank_data",load_bank_data,1);
2301
3127
 
2302
3128
  /* Rückgabewerte der konto_check Bibliothek */
3129
+ /* (-145) Es werden nur deutsche BICs unterstützt */
3130
+ rb_define_const(KontoCheck,"BIC_ONLY_GERMAN",INT2FIX(BIC_ONLY_GERMAN));
3131
+ /* (-144) Die Länge des BIC muß genau 8 oder 11 Zeichen sein */
3132
+ rb_define_const(KontoCheck,"INVALID_BIC_LENGTH",INT2FIX(INVALID_BIC_LENGTH));
3133
+ /* (-143) Die IBAN-Prüfsumme stimmt, es wurde allerdings eine IBAN-Regel nicht beachtet (BLZ nicht ersetzt, wahrscheinlich falsch) */
3134
+ rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_RULE_IGNORED_BLZ",INT2FIX(IBAN_CHKSUM_OK_RULE_IGNORED_BLZ));
3135
+ /* (-142) Die IBAN-Prüfsumme stimmt, konto_check wurde jedoch noch nicht initialisiert (Kontoprüfung nicht möglich) */
3136
+ rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_KC_NOT_INITIALIZED",INT2FIX(IBAN_CHKSUM_OK_KC_NOT_INITIALIZED));
3137
+ /* (-141) Die IBAN-Prüfsumme stimmt, die BLZ ist allerdings ungültig */
3138
+ rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_BLZ_INVALID",INT2FIX(IBAN_CHKSUM_OK_BLZ_INVALID));
3139
+ /* (-140) Die IBAN-Prüfsumme stimmt, für die Bank gibt es allerdings eine (andere) Nachfolge-BLZ */
3140
+ rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_NACHFOLGE_BLZ_DEFINED",INT2FIX(IBAN_CHKSUM_OK_NACHFOLGE_BLZ_DEFINED));
3141
+ /* (-139) es konnten nicht alle Datenblocks die für die IBAN-Berechnung notwendig sind geladen werden */
3142
+ rb_define_const(KontoCheck,"LUT2_NOT_ALL_IBAN_BLOCKS_LOADED",INT2FIX(LUT2_NOT_ALL_IBAN_BLOCKS_LOADED));
3143
+ /* (-138) Der Datensatz ist noch nicht gültig, außerdem konnten nicht alle Blocks geladen werden */
3144
+ rb_define_const(KontoCheck,"LUT2_NOT_YET_VALID_PARTIAL_OK",INT2FIX(LUT2_NOT_YET_VALID_PARTIAL_OK));
3145
+ /* (-137) Der Datensatz ist nicht mehr gültig, außerdem konnten nicht alle Blocks geladen werdeng */
3146
+ rb_define_const(KontoCheck,"LUT2_NO_LONGER_VALID_PARTIAL_OK",INT2FIX(LUT2_NO_LONGER_VALID_PARTIAL_OK));
3147
+ /* (-136) ok, bei der Initialisierung konnten allerdings ein oder mehrere Blocks nicht geladen werden */
3148
+ rb_define_const(KontoCheck,"LUT2_BLOCKS_MISSING",INT2FIX(LUT2_BLOCKS_MISSING));
3149
+ /* (-135) falsch, es wurde ein Unterkonto hinzugefügt (IBAN-Regel) */
3150
+ rb_define_const(KontoCheck,"FALSE_UNTERKONTO_ATTACHED",INT2FIX(FALSE_UNTERKONTO_ATTACHED));
3151
+ /* (-134) Die BLZ findet sich in der Ausschlussliste für IBAN-Berechnungen */
3152
+ rb_define_const(KontoCheck,"BLZ_BLACKLISTED",INT2FIX(BLZ_BLACKLISTED));
3153
+ /* (-133) Die BLZ ist in der Bundesbank-Datei als gelöscht markiert und somit ungültig */
3154
+ rb_define_const(KontoCheck,"BLZ_MARKED_AS_DELETED",INT2FIX(BLZ_MARKED_AS_DELETED));
3155
+ /* (-132) Die IBAN-Prüfsumme stimmt, es gibt allerdings einen Fehler in der eigenen IBAN-Bestimmung (wahrscheinlich falsch) */
3156
+ rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_SOMETHING_WRONG",INT2FIX(IBAN_CHKSUM_OK_SOMETHING_WRONG));
3157
+ /* (-131) Die IBAN-Prüfsumme stimmt, eine IBAN-Berechnung ist allerdings nicht erlaubt (wahrscheinlich falsch) */
3158
+ rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_NO_IBAN_CALCULATION",INT2FIX(IBAN_CHKSUM_OK_NO_IBAN_CALCULATION));
3159
+ /* (-130) Die IBAN-Prüfsumme stimmt, es wurde allerdings eine IBAN-Regel nicht beachtet (wahrscheinlich falsch) */
3160
+ rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_RULE_IGNORED",INT2FIX(IBAN_CHKSUM_OK_RULE_IGNORED));
3161
+ /* (-129) Die IBAN-Prüfsumme stimmt, es fehlt aber ein Unterkonto (wahrscheinlich falsch) */
3162
+ rb_define_const(KontoCheck,"IBAN_CHKSUM_OK_UNTERKTO_MISSING",INT2FIX(IBAN_CHKSUM_OK_UNTERKTO_MISSING));
3163
+ /* (-128) Die BLZ passt nicht zur angegebenen IBAN-Regel */
3164
+ rb_define_const(KontoCheck,"IBAN_INVALID_RULE",INT2FIX(IBAN_INVALID_RULE));
3165
+ /* (-127) Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten) */
3166
+ rb_define_const(KontoCheck,"IBAN_AMBIGUOUS_KTO",INT2FIX(IBAN_AMBIGUOUS_KTO));
3167
+ /* (-126) Die IBAN-Regel ist noch nicht implementiert */
3168
+ rb_define_const(KontoCheck,"IBAN_RULE_NOT_IMPLEMENTED",INT2FIX(IBAN_RULE_NOT_IMPLEMENTED));
3169
+ /* (-125) Die IBAN-Regel ist nicht bekannt */
3170
+ rb_define_const(KontoCheck,"IBAN_RULE_UNKNOWN",INT2FIX(IBAN_RULE_UNKNOWN));
3171
+ /* (-124) Für die Bankverbindung ist keine IBAN-Berechnung erlaubt */
3172
+ rb_define_const(KontoCheck,"NO_IBAN_CALCULATION",INT2FIX(NO_IBAN_CALCULATION));
3173
+ /* (-123) Die Bankverbindung ist mit der alten BLZ stimmig, mit der Nachfolge-BLZ nicht */
3174
+ rb_define_const(KontoCheck,"OLD_BLZ_OK_NEW_NOT",INT2FIX(OLD_BLZ_OK_NEW_NOT));
3175
+ /* (-122) Das Feld IBAN-Regel wurde nicht initialisiert */
3176
+ rb_define_const(KontoCheck,"LUT2_IBAN_REGEL_NOT_INITIALIZED",INT2FIX(LUT2_IBAN_REGEL_NOT_INITIALIZED));
3177
+ /* (-121) Die Länge der IBAN für das angegebene Länderkürzel ist falsch */
3178
+ rb_define_const(KontoCheck,"INVALID_IBAN_LENGTH",INT2FIX(INVALID_IBAN_LENGTH));
3179
+ /* (-120) Keine Bankverbindung/IBAN angegeben */
3180
+ rb_define_const(KontoCheck,"LUT2_NO_ACCOUNT_GIVEN",INT2FIX(LUT2_NO_ACCOUNT_GIVEN));
3181
+ /* (-119) Ungültiges Zeichen ( ()+-/&.,\' ) für die Volltextsuche gefunden */
3182
+ rb_define_const(KontoCheck,"LUT2_VOLLTEXT_INVALID_CHAR",INT2FIX(LUT2_VOLLTEXT_INVALID_CHAR));
3183
+ /* (-118) Die Volltextsuche sucht jeweils nur ein einzelnes Wort, benutzen Sie lut_suche_multiple() zur Suche nach mehreren Worten */
3184
+ rb_define_const(KontoCheck,"LUT2_VOLLTEXT_SINGLE_WORD_ONLY",INT2FIX(LUT2_VOLLTEXT_SINGLE_WORD_ONLY));
3185
+ /* (-117) die angegebene Suchresource ist ungültig */
3186
+ rb_define_const(KontoCheck,"LUT_SUCHE_INVALID_RSC",INT2FIX(LUT_SUCHE_INVALID_RSC));
3187
+ /* (-116) Suche: im Verknüpfungsstring sind nur die Zeichen a-z sowie + und - erlaubt */
3188
+ rb_define_const(KontoCheck,"LUT_SUCHE_INVALID_CMD",INT2FIX(LUT_SUCHE_INVALID_CMD));
3189
+ /* (-115) Suche: es müssen zwischen 1 und 26 Suchmuster angegeben werden */
3190
+ rb_define_const(KontoCheck,"LUT_SUCHE_INVALID_CNT",INT2FIX(LUT_SUCHE_INVALID_CNT));
3191
+ /* (-114) Das Feld Volltext wurde nicht initialisiert */
3192
+ rb_define_const(KontoCheck,"LUT2_VOLLTEXT_NOT_INITIALIZED",INT2FIX(LUT2_VOLLTEXT_NOT_INITIALIZED));
2303
3193
  /* (-113) das Institut erlaubt keine eigene IBAN-Berechnung */
2304
3194
  rb_define_const(KontoCheck,"NO_OWN_IBAN_CALCULATION",INT2FIX(NO_OWN_IBAN_CALCULATION));
2305
3195
  /* (-112) die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden */
2306
3196
  rb_define_const(KontoCheck,"KTO_CHECK_UNSUPPORTED_COMPRESSION",INT2FIX(KTO_CHECK_UNSUPPORTED_COMPRESSION));
2307
3197
  /* (-111) der angegebene Wert für die Default-Kompression ist ungültig */
2308
3198
  rb_define_const(KontoCheck,"KTO_CHECK_INVALID_COMPRESSION_LIB",INT2FIX(KTO_CHECK_INVALID_COMPRESSION_LIB));
2309
- /* (-110) wahrscheinlich OK; es wurde allerdings ein (weggelassenes) Unterkonto angefügt */
2310
- rb_define_const(KontoCheck,"OK_UNTERKONTO_ATTACHED",INT2FIX(OK_UNTERKONTO_ATTACHED));
3199
+ /* (-110) (nicht mehr als Fehler, sondern positive Ausgabe - Dummy für den alten Wert) */
3200
+ rb_define_const(KontoCheck,"OK_UNTERKONTO_ATTACHED_OLD",INT2FIX(OK_UNTERKONTO_ATTACHED_OLD));
2311
3201
  /* (-109) Ungültige Signatur im Default-Block */
2312
3202
  rb_define_const(KontoCheck,"KTO_CHECK_DEFAULT_BLOCK_INVALID",INT2FIX(KTO_CHECK_DEFAULT_BLOCK_INVALID));
2313
3203
  /* (-108) Die maximale Anzahl Einträge für den Default-Block wurde erreicht */
@@ -2316,7 +3206,7 @@ void Init_konto_check_raw()
2316
3206
  rb_define_const(KontoCheck,"KTO_CHECK_NO_DEFAULT_BLOCK",INT2FIX(KTO_CHECK_NO_DEFAULT_BLOCK));
2317
3207
  /* (-106) Der angegebene Schlüssel wurde im Default-Block nicht gefunden */
2318
3208
  rb_define_const(KontoCheck,"KTO_CHECK_KEY_NOT_FOUND",INT2FIX(KTO_CHECK_KEY_NOT_FOUND));
2319
- /* (-105) Beide Datensätze sind nicht mehr gültig; dieser ist aber jünger als der andere */
3209
+ /* (-105) Beide Datensätze sind nicht mehr gültig, dieser ist aber jünger als der andere */
2320
3210
  rb_define_const(KontoCheck,"LUT2_NO_LONGER_VALID_BETTER",INT2FIX(LUT2_NO_LONGER_VALID_BETTER));
2321
3211
  /* (-104) Die Auftraggeber-Kontonummer des C-Datensatzes unterscheidet sich von der des A-Satzes */
2322
3212
  rb_define_const(KontoCheck,"DTA_SRC_KTO_DIFFERENT",INT2FIX(DTA_SRC_KTO_DIFFERENT));
@@ -2388,7 +3278,7 @@ void Init_konto_check_raw()
2388
3278
  rb_define_const(KontoCheck,"IPI_INVALID_LENGTH",INT2FIX(IPI_INVALID_LENGTH));
2389
3279
  /* (-70) Es wurde eine LUT-Datei im Format 1.0/1.1 geladen */
2390
3280
  rb_define_const(KontoCheck,"LUT1_FILE_USED",INT2FIX(LUT1_FILE_USED));
2391
- /* (-69) Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto) */
3281
+ /* (-69) Für die aufgerufene Funktion fehlt ein notwendiger Parameter */
2392
3282
  rb_define_const(KontoCheck,"MISSING_PARAMETER",INT2FIX(MISSING_PARAMETER));
2393
3283
  /* (-68) Die Funktion iban2bic() arbeitet nur mit deutschen Bankleitzahlen */
2394
3284
  rb_define_const(KontoCheck,"IBAN2BIC_ONLY_GERMAN",INT2FIX(IBAN2BIC_ONLY_GERMAN));
@@ -2498,7 +3388,7 @@ void Init_konto_check_raw()
2498
3388
  rb_define_const(KontoCheck,"BLZ_GELOESCHT",INT2FIX(BLZ_GELOESCHT));
2499
3389
  /* (-15) Fehler in der blz.txt Datei (falsche Zeilenlänge) */
2500
3390
  rb_define_const(KontoCheck,"INVALID_BLZ_FILE",INT2FIX(INVALID_BLZ_FILE));
2501
- /* (-14) undefinierte Funktion; die library wurde mit THREAD_SAFE=0 kompiliert */
3391
+ /* (-14) undefinierte Funktion, die library wurde mit THREAD_SAFE=0 kompiliert */
2502
3392
  rb_define_const(KontoCheck,"LIBRARY_IS_NOT_THREAD_SAFE",INT2FIX(LIBRARY_IS_NOT_THREAD_SAFE));
2503
3393
  /* (-13) schwerer Fehler im Konto_check-Modul */
2504
3394
  rb_define_const(KontoCheck,"FATAL_ERROR",INT2FIX(FATAL_ERROR));
@@ -2532,7 +3422,7 @@ void Init_konto_check_raw()
2532
3422
  rb_define_const(KontoCheck,"OK",INT2FIX(OK));
2533
3423
  /* (2) ok, ohne Prüfung */
2534
3424
  rb_define_const(KontoCheck,"OK_NO_CHK",INT2FIX(OK_NO_CHK));
2535
- /* (3) ok; für den Test wurde eine Test-BLZ verwendet */
3425
+ /* (3) ok, für den Test wurde eine Test-BLZ verwendet */
2536
3426
  rb_define_const(KontoCheck,"OK_TEST_BLZ_USED",INT2FIX(OK_TEST_BLZ_USED));
2537
3427
  /* (4) Der Datensatz ist aktuell gültig */
2538
3428
  rb_define_const(KontoCheck,"LUT2_VALID",INT2FIX(LUT2_VALID));
@@ -2540,18 +3430,42 @@ void Init_konto_check_raw()
2540
3430
  rb_define_const(KontoCheck,"LUT2_NO_VALID_DATE",INT2FIX(LUT2_NO_VALID_DATE));
2541
3431
  /* (6) Die Datei ist im alten LUT-Format (1.0/1.1) */
2542
3432
  rb_define_const(KontoCheck,"LUT1_SET_LOADED",INT2FIX(LUT1_SET_LOADED));
2543
- /* (7) ok; es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert */
3433
+ /* (7) ok, es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert */
2544
3434
  rb_define_const(KontoCheck,"LUT1_FILE_GENERATED",INT2FIX(LUT1_FILE_GENERATED));
2545
3435
  /* (8) In der DTAUS-Datei wurden kleinere Fehler gefunden */
2546
3436
  rb_define_const(KontoCheck,"DTA_FILE_WITH_WARNINGS",INT2FIX(DTA_FILE_WITH_WARNINGS));
2547
- /* (9) ok; es wurde allerdings eine LUT-Datei im Format 2.0 generiert (Compilerswitch) */
3437
+ /* (9) ok, es wurde allerdings eine LUT-Datei im Format 2.0 generiert (Compilerswitch) */
2548
3438
  rb_define_const(KontoCheck,"LUT_V2_FILE_GENERATED",INT2FIX(LUT_V2_FILE_GENERATED));
2549
- /* (10) ok; der Wert für den Schlüssel wurde überschrieben */
3439
+ /* (10) ok, der Wert für den Schlüssel wurde überschrieben */
2550
3440
  rb_define_const(KontoCheck,"KTO_CHECK_VALUE_REPLACED",INT2FIX(KTO_CHECK_VALUE_REPLACED));
2551
- /* (11) wahrscheinlich ok; die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten */
3441
+ /* (11) wahrscheinlich ok, die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten */
2552
3442
  rb_define_const(KontoCheck,"OK_UNTERKONTO_POSSIBLE",INT2FIX(OK_UNTERKONTO_POSSIBLE));
2553
- /* (12) wahrscheinlich ok; die Kontonummer enthält eine Unterkontonummer */
3443
+ /* (12) wahrscheinlich ok, die Kontonummer enthält eine Unterkontonummer */
2554
3444
  rb_define_const(KontoCheck,"OK_UNTERKONTO_GIVEN",INT2FIX(OK_UNTERKONTO_GIVEN));
2555
- /* (13) ok; die Anzahl Slots wurde auf SLOT_CNT_MIN hochgesetzt */
3445
+ /* (13) ok, die Anzahl Slots wurde auf SLOT_CNT_MIN (60) hochgesetzt */
2556
3446
  rb_define_const(KontoCheck,"OK_SLOT_CNT_MIN_USED",INT2FIX(OK_SLOT_CNT_MIN_USED));
3447
+ /* (14) ok, ein(ige) Schlüssel wurden nicht gefunden */
3448
+ rb_define_const(KontoCheck,"SOME_KEYS_NOT_FOUND",INT2FIX(SOME_KEYS_NOT_FOUND));
3449
+ /* (15) Die Bankverbindung wurde nicht getestet */
3450
+ rb_define_const(KontoCheck,"LUT2_KTO_NOT_CHECKED",INT2FIX(LUT2_KTO_NOT_CHECKED));
3451
+ /* (16) Es wurden fast alle Blocks (außer den IBAN-Regeln) geladen */
3452
+ rb_define_const(KontoCheck,"LUT2_OK_WITHOUT_IBAN_RULES",INT2FIX(LUT2_OK_WITHOUT_IBAN_RULES));
3453
+ /* (17) ok, für die BLZ wurde allerdings die Nachfolge-BLZ eingesetzt */
3454
+ rb_define_const(KontoCheck,"OK_NACHFOLGE_BLZ_USED",INT2FIX(OK_NACHFOLGE_BLZ_USED));
3455
+ /* (18) ok, die Kontonummer wurde allerdings ersetzt */
3456
+ rb_define_const(KontoCheck,"OK_KTO_REPLACED",INT2FIX(OK_KTO_REPLACED));
3457
+ /* (19) ok, die Bankleitzahl wurde allerdings ersetzt */
3458
+ rb_define_const(KontoCheck,"OK_BLZ_REPLACED",INT2FIX(OK_BLZ_REPLACED));
3459
+ /* (20) ok, die Bankleitzahl und Kontonummer wurde allerdings ersetzt */
3460
+ rb_define_const(KontoCheck,"OK_BLZ_KTO_REPLACED",INT2FIX(OK_BLZ_KTO_REPLACED));
3461
+ /* (21) ok, die Bankverbindung ist (ohne Test) als richtig anzusehen */
3462
+ rb_define_const(KontoCheck,"OK_IBAN_WITHOUT_KC_TEST",INT2FIX(OK_IBAN_WITHOUT_KC_TEST));
3463
+ /* (22) ok, für IBAN ist (durch eine Regel) allerdings ein anderer BIC definiert */
3464
+ rb_define_const(KontoCheck,"OK_INVALID_FOR_IBAN",INT2FIX(OK_INVALID_FOR_IBAN));
3465
+ /* (23) ok, für die BIC-Bestimmung der ehemaligen Hypo-Bank für IBAN wird i.A. zusätzlich die Kontonummer benötigt */
3466
+ rb_define_const(KontoCheck,"OK_HYPO_REQUIRES_KTO",INT2FIX(OK_HYPO_REQUIRES_KTO));
3467
+ /* (24) ok, die Kontonummer wurde ersetzt, die neue Kontonummer hat keine Prüfziffer */
3468
+ rb_define_const(KontoCheck,"OK_KTO_REPLACED_NO_PZ",INT2FIX(OK_KTO_REPLACED_NO_PZ));
3469
+ /* (25) ok, es wurde ein (weggelassenes) Unterkonto angefügt */
3470
+ rb_define_const(KontoCheck,"OK_UNTERKONTO_ATTACHED",INT2FIX(OK_UNTERKONTO_ATTACHED));
2557
3471
  }